def __init__(self, repo):
DataBase.__init__(self, "solidworks", repo)
self.designtables = []
if not exists(self.backend_root):
e = MalformedRepositoryError("solidworks 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
try:
base = list(
yaml.load_all(open(basefilename, "r", "utf8"),
Loader=yaml.SafeLoader))
# SafeLoader is not implemented in pyyaml < 5.1
except AttributeError:
# this is deprecated for newer pyyaml versions
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 designtable in base:
if not designtable["type"] == "solidworks":
continue
self.designtables.append(
DesignTable(designtable, coll, self.backend_root))
def __init__(self,path):
DataBase.__init__(self,"drawings", path)
self.getbase = {}
if not exists(path):
e = MalformedRepositoryError("Repo directory does not exist")
e.set_repo_path(path)
raise e
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
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:
draw = Drawing(drawing_element, coll, self.backend_root)
for id in drawing_element["classids"]:
self.getbase[id] = draw
def __init__(self,path):
DataBase.__init__(self,"solidworks",path)
self.designtables = []
if not exists(path):
e = MalformedRepositoryError("Repo directory does not exist")
e.set_repo_path(path)
raise e
if not exists(join(self.backend_root)):
e = MalformedRepositoryError("solidworks 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
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 designtable in base:
if not designtable["type"] == "solidworks":
continue
self.designtables.append(DesignTable(designtable,coll,self.backend_root))
def __init__(self, repo):
DataBase.__init__(self, "solidworks", repo)
self.designtables = []
if not exists(self.backend_root):
e = MalformedRepositoryError("solidworks 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 designtable in base:
if not designtable["type"] == "solidworks":
continue
self.designtables.append(
DesignTable(designtable, coll, self.backend_root))
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,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,path):
DataBase.__init__(self,"freecad",path)
self.getbase = {}
if not exists(path):
e = MalformedRepositoryError("Repo directory does not exist")
e.set_repo_path(path)
raise e
if not exists(join(self.backend_root)):
e = MalformedRepositoryError("freecad 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
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,"%s.py" % coll)
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)
for id in func["classids"]:
if id in self.getbase:
raise NonUniqueBaseError(id)
self.getbase[id] = function
except ParsingError as e:
e.set_base(basefile["filename"])
e.set_collection(coll)
raise e
elif basefile["type"] == "fcstd":
basepath = join(self.backend_root,coll,basefile["filename"])
if not exists(basepath):
continue
for obj in basefile["objects"]:
try:
fcstd = BaseFcstd(obj,basefile,coll,self.backend_root)
for id in obj["classids"]:
if id in self.getbase:
raise NonUniqueBaseError(id)
self.getbase[id] = fcstd
except ParsingError as e:
e.set_base(basefile["filename"])
e.set_collection(coll)
raise e
def __init__(self,path):
DataBase.__init__(self,"openscad",path)
#maps class id to base module
self.getbase = {}
if not exists(path):
e = MalformedRepositoryError("Repo directory does not exist")
e.set_repo_path(path)
raise e
if not exists(join(self.backend_root)):
e = MalformedRepositoryError("openscad 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
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:
if basefile["type"] == "module":
for mod in basefile["modules"]:
try:
module = BaseModule(mod,basefile,coll)
for id in module.classids:
if id in self.getbase:
raise NonUniqueBaseError(id)
self.getbase[id] = module
except ParsingError as e:
e.set_base(basefile["filename"])
raise e
elif basefile["type"] == "stl":
try:
module = BaseSTL(basefile,coll)
for id in module.classids:
if id in self.getbase:
raise NonUniqueBaseError(id)
self.getbase[id] = module
except ParsingError as e:
e.set_base(basefile["filename"])
raise e
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 SetMusic(UserId, MusicId, Level, BaseRate):
Music = Func.Get_BestScore(UserId, MusicId)
DataBase = DB.LoadBaseRate()
Dic = {
'MusicId': MusicId,
'Level': Level,
'MusicName': Music['musicName'],
'Image': Music['musicFileName'],
'ArtistName': Music['artistName'],
'BaseRate': BaseRate
}
DataBase.SetMusic(Dic)
def __init__(self,path):
DataBase.__init__(self,"drawings", path)
self.getdimensions = {}
self.getconnectors = {}
if not exists(path):
e = MalformedRepositoryError("Repo directory does not exist")
e.set_repo_path(path)
raise e
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
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)
for id in drawing_element["classids"]:
self.getdimensions[id] = draw
if drawing_element["type"] == "drawing-connector":
draw = DrawingConnectors(drawing_element, coll, self.backend_root)
for id in drawing_element["classids"]:
if not id in self.getconnectors:
self.getconnectors[id] = {draw.location: draw}
elif draw.location not in self.getconnectors[id]:
self.getconnectors[id][draw.location] = draw
else:
raise MalformedRepositoryError("More than one drawing for location %s of class %s" %
(draw.location,id))
def CheckMusic(userId):
MusicIdList = Func.Get_MusicIdList(userId)
DataBase = DB.LoadBaseRate()
BaseRateList = DataBase.Get_BaseRateList()
NoneMusicList = []
ExistMusicList = []
for level in range(2, 4):
for MusicId in MusicIdList[level - 2]:
if MusicId in BaseRateList[level - 2]:
Music = DataBase.Get_BaseRate(MusicId, level)
if Music['BaseRate'] is not None:
BaseRate = Music['BaseRate']
Dic = {
'MusicId': MusicId,
'MusicName': Music['MusicName'],
'MusicImage': Music['Image'],
'ArtistName': Music['ArtistName'],
'Level': level,
'BaseRate': BaseRate,
'AirPlus': Music['AirPlus']
}
ExistMusicList.append(Dic)
continue
Music = Func.Get_BestScore(userId, MusicId)
Dic = {
'MusicId': MusicId,
'MusicName': Music['musicName'],
'MusicImage': Music['musicFileName'],
'ArtistName': Music['artistName'],
'Level': level,
'BaseRate': None,
'AirPlus': False
}
NoneMusicList.append(Dic)
DataBase.SetMusic(Dic, True)
return NoneMusicList, ExistMusicList
def SearchMusic(UserId, Dic):
DataBase = DB.LoadBaseRate()
MusicList = DataBase.SerchMusic_DB(Dic)
MusicIdList = {
x['MusicId']: idx
for idx, x in enumerate(MusicList) if x['Level'] == 2
}, {
x['MusicId']: idx
for idx, x in enumerate(MusicList) if x['Level'] == 3
}
GenreList = Func.Get_Genre(UserId, Dic['Genre'], Dic['DiffLevel'])
ResultList = []
if Dic['DiffLevel']:
for MusicId in GenreList:
if MusicId in MusicIdList[int(Dic['DiffLevel']) - 2]:
idx = MusicIdList[int(Dic['DiffLevel']) - 2][MusicId]
ResultList.append(MusicList[idx])
else:
for level in range(2, 4):
for MusicId in GenreList[level - 2]:
if MusicId in MusicIdList[level - 2]:
idx = MusicIdList[level - 2][MusicId]
ResultList.append(MusicList[idx])
return ResultList
def DispBest(Hash):
DataBase = DB.UserDataBase(Hash)
Best = DataBase.LoadBest()
User = DataBase.LoadUser()
Rate = DataBase.LoadRate()
return Best, User, Rate
def CalcRate(userId):
'''レートを計算してデータベースに保存する'''
Base = DB.LoadBaseRate()
FriendCode = Func.Get_FriendCode(userId)
if FriendCode is None:
return None
Hash = hashlib.sha256(str(FriendCode).encode('utf8')).hexdigest()
Rating = {}
DataBase = DB.UserDataBase(Hash)
#Best枠について
MusicIdList = Func.Get_MusicIdList(userId) #MusicIdのリストの取得
if MusicIdList is None:
return None
Musics = []
i = 0
for Level in range(2, 4):
MusicBestScore = Func.Get_DiffList(
userId,
"1990" + str(Level)) #エキスパート(19902)とマスター(19903)の曲別最大スコアのリストの取得
if MusicBestScore is None:
return None
for MusicId in MusicIdList[Level - 2]:
for Music in MusicBestScore['userMusicList']:
if Music['musicId'] == MusicId:
MusicDetail = Base.Get_BaseRate(MusicId, Level)
if MusicDetail is None or MusicDetail['BaseRate'] is None:
continue
else:
Dic = {
'MusicId':
MusicId,
'Level':
Level,
'MusicName':
MusicDetail['MusicName'],
'Image':
MusicDetail['Image'],
'BaseRate':
MusicDetail['BaseRate'],
'Rate':
Func.Score2Rate(Music['scoreMax'],
MusicDetail['BaseRate']),
'Score':
Music['scoreMax']
}
Musics.append(Dic)
#ソート
Best = sorted(Musics, key=lambda x: x["Rate"], reverse=True)
Rate = {'BestRate': 0, 'MaxBestRate': 0}
for Music in Best:
if i < 30:
Music['MaxScore'] = None
Rate['BestRate'] += Music['Rate']
if i == 0:
Rate['MaxBestRate'] = Music['Rate']
elif i == 29:
Rate['MinBestRate'] = Music['Rate']
else:
if Music['Score'] >= 1007500:
Music['MaxScore'] = None
else:
MaxScore = Func.Rate2Score(Music['BaseRate'],
Rate['MinBestRate'])
if MaxScore <= 1007500 and MaxScore > 0 and MaxScore - Music[
'Score'] > 0:
Music['MaxScore'] = MaxScore
else:
Music['MaxScore'] = None
i += 1
#データーベースに保存
DataBase.SetBest(Best)
#Recent
Playlog = Func.Get_PlayLog(userId)
if Playlog is None:
return None
Recent = DataBase.LoadRecent()
LevelMap = {'master': 3, "expert": 2}
FinalPlayDate = Playlog['userPlaylogList'][0]['userPlayDate'][0:-2]
Musics = []
for Play in Playlog['userPlaylogList'][0:30]:
if Play['levelName'] == 'expert' or Play['levelName'] == 'master':
MusicId = Base.Get_MusicId(Play['musicFileName'])
if MusicId is None:
continue
MusicDetail = Base.Get_BaseRate(MusicId,
LevelMap[Play['levelName']])
if MusicDetail is None or MusicDetail['BaseRate'] is None:
continue
else:
Dic = {
'MusicId': MusicId,
'Level': LevelMap[Play['levelName']],
'MusicName': MusicDetail['MusicName'],
'Image': MusicDetail['Image'],
'BaseRate': MusicDetail['BaseRate'],
'Rate': Func.Score2Rate(Play['score'],
MusicDetail['BaseRate']),
'Score': Play['score'],
'PlayDate': Play['userPlayDate'][0:-2]
}
Musics.append(Dic)
if Recent is None:
#レート順にソート
Recent = sorted(Musics, key=lambda x: x['Rate'], reverse=True)
else:
#レート順にソート
Recent = sorted(Recent, key=lambda x: x['Rate'], reverse=True)
if len(Recent) > 10:
UserData = DataBase.LoadUser()
#UserDataがゼロではなかったら
if len(UserData):
OldDate = datetime.strptime(UserData[-1]['FinalPlayDate'],
'%Y-%m-%d %H:%M:%S')
for Play in Musics:
NowDate = datetime.strptime(Play['PlayDate'],
'%Y-%m-%d %H:%M:%S')
#最後に実行されたときの曲と現在の曲の新旧
if NowDate > OldDate:
#Recent枠の最小と比較
if Play['Rate'] > Recent[9]['Rate']:
#Recent枠の最小と入れ替え
Recent[-1]['MusicId'] = Play['MusicId']
Recent[-1]['Level'] = Play['Level']
Recent[-1]['MusicName'] = Play['MusicName']
Recent[-1]['Image'] = Play['Image']
Recent[-1]['BaseRate'] = Play['BaseRate']
Recent[-1]['Score'] = Play['Score']
Recent[-1]['Rate'] = Play['Rate']
Recent[-1]['PlayDate'] = Play['PlayDate']
elif Play['Score'] >= 1007500:
pass
elif Play['Score'] >= Recent[-1]['Score']:
pass
else:
#プレイ日時順にソート
Recent = sorted(
Recent,
key=lambda x: datetime.strptime(
x['PlayDate'], '%Y-%m-%d %H:%M:%S'),
reverse=True)
#Recent候補枠の一番古い曲と入れ替え
Recent[-1]['MusicId'] = Play['MusicId']
Recent[-1]['Level'] = Play['Level']
Recent[-1]['MusicName'] = Play['MusicName']
Recent[-1]['Image'] = Play['Image']
Recent[-1]['BaseRate'] = Play['BaseRate']
Recent[-1]['Score'] = Play['Score']
Recent[-1]['Rate'] = Play['Rate']
Recent[-1]['PlayDate'] = Play['PlayDate']
#レート順にソート
Recent = sorted(Recent,
key=lambda x: x['Rate'],
reverse=True)
else:
pass
else:
pass
else:
pass
RecentRates = 0
i = 0
for Music in Recent:
if i < 10:
RecentRates += Music['Rate']
i += 1
#ユーザーデータ
UserInfo = Func.Get_UserData(userId)
if UserInfo is None:
return None
else:
UserInfo = UserInfo['userInfo']
NowDate = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
User = {
'TotalPoint': UserInfo['totalPoint'],
'TrophyType': UserInfo['trophyType'],
'WebLimitDate': UserInfo['webLimitDate'][0:-2],
'CharacterFileName': UserInfo['characterFileName'],
'FriendCount': UserInfo['friendCount'],
'Point': UserInfo['point'],
'PlayCount': UserInfo['playCount'],
'CharacterLevel': UserInfo['characterLevel'],
'TrophyName': UserInfo['trophyName'],
'ReincarnationNum': UserInfo['reincarnationNum'],
'UserName': UserInfo['userName'],
'Level': UserInfo['level'],
'FriendCode': FriendCode,
'Hash': Hash,
'FinalPlayDate': FinalPlayDate,
'ExecuteDate': NowDate
}
#データベースに保存
DataBase.SetRecent(Recent)
#レート計算
DispRate = (UserInfo['playerRating'] / 100.0)
BestRate = math.floor((Rate['BestRate'] / 30) * 100) / 100
Rating = {
'DispRate':
DispRate,
'HighestRating': (UserInfo['highestRating'] / 100.0),
'MaxRate': (math.floor(
((Rate['BestRate'] + Rate['MaxBestRate'] * 10) / 40) * 100) / 100),
'BestRate':
BestRate,
#'RecentRate':(math.floor(((DispRate * 40 - BestRate * 30) / 10) * 100) / 100),
'RecentRate': (math.floor((RecentRates / 10) * 100) / 100),
'Credits':
UserInfo['playCount'],
'ExecuteDate':
NowDate
}
#データベースに保存
DataBase.SetRate(Rating)
#データベースに保存
DataBase.SetUser(User)
Admin = DB.AdminDataBase()
Data = {
'UserName': UserInfo['userName'],
'FriendCode': FriendCode,
'Hash': Hash,
'Credits': UserInfo['playCount'],
'DispRate': DispRate,
'HighestRating': Rating['HighestRating'],
'MaxRate': Rating['MaxRate'],
'BestRate': BestRate,
'RecentRate': Rating['RecentRate'],
}
Admin.SetData(Data)
return Hash
def DispTools(Hash):
DataBase = DB.UserDataBase(Hash)
Rate = DataBase.LoadRate()
User = DataBase.LoadUser()
return User, Rate
def DispRecent(Hash):
DataBase = DB.UserDataBase(Hash)
Recent = DataBase.LoadRecent()
User = DataBase.LoadUser()
Rate = DataBase.LoadRate()
return Recent, User, Rate
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, 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"])
