def getDefaultLoader(self):
with cd(self.defAbsDir):
defPath = [Path(p).absolute().as_posix() for p in self.defPath]
with cd(self.cfgAbsDir):
cfgPath = [Path(p).absolute().as_posix() for p in self.cfgPath]
loader = ChoiceLoader([
FileSystemLoader(cfgPath),
FileSystemLoader(defPath)])
return loader
def getDefaultLoader(self):
with cd(self.defAbsDir):
defPath = [Path(p).absolute().as_posix() for p in self.defPath]
with cd(self.cfgAbsDir):
cfgPath = [Path(p).absolute().as_posix() for p in self.cfgPath]
loader = ChoiceLoader(
[FileSystemLoader(cfgPath),
FileSystemLoader(defPath)])
return loader
def templateExists(self, filename):
'''
Test if a template exists in this segement.
:param Path filename: relative filename of template file.
:returns: True if exists.
:rtype: boolean
'''
with cd(self.absDirname):
with cd(self.properties.defaultTemplatePath):
absDst = filename.absolute()
return absDst.exists()
def deleteTemplate(self, filename):
'''
Delete a template from this segment.
:param Path filename: relative filename of template file.
:returns: True if success.
:rtype: boolean
'''
with cd(self.absDirname):
with cd(self.properties.defaultTemplatePath):
absDst = filename.absolute()
if absDst.exists():
absDst.unlink()
return True
def test_findModuleDefinitions(self, tmp_path):
'''Test finding segment xform files.'''
fashionHome = Path(__file__).resolve().parent.parent / "fashion"
segPath = fashionHome / "warehouse" / "fashion.core"
with cd(segPath):
seg = Segment.load(Path("segment.json"))
xformModules = seg.findModuleDefinitions()
def nab(args):
'''Create a template and xform from a file.'''
global portfolio
if not setup(args):
return
filename = portfolio.normalizeFilename(args.filename)
with cd(portfolio.projectPath):
if not filename.exists():
print("{0} not found.".format(filename))
return
tp = portfolio.warehouse.getDefaultsTemplatePath()
seg = portfolio.defaultSegment()
xformName = filename.stem
model = {
"template": filename.as_posix(),
"targetFile": filename.as_posix()
}
tplFile = "defaultNabXformTemplate.py"
if seg.templateExists(filename):
if query_yes_no("Are you sure you want to overwrite the template?", "no"):
seg.deleteTemplate(filename)
else:
return
if seg.xformExists(xformName):
if query_yes_no("Are you sure you want to overwrite the xform?", "no"):
seg.deleteXform(str(filename))
else:
return
seg.createTemplate(filename)
seg.createXform(xformName, tp, templateFile=tplFile, model=model)
def createXform(self, xformName, templatePath, templateFile="defaultXformTemplate.py", model={}, moduleName=None):
'''
Create an xform module in this segment.
:param string xformName: name of xform to create.
:param list(string) templatePath: ordered list of search paths for template files.
:param string templateFile: the template to use to generate the xform code.
:param dictionary model: the model passed to the xform source code generator.
:param string moduleName: the moduleName for this xform module, else default is same as xformName.
:returns: True if succeeded.
:rtype: boolean
'''
with cd(self.absDirname):
filename = Path(xformName + ".py")
targetFile = Path(self.properties.defaultXformPath) / filename
if moduleName is None:
moduleName = filename.stem
if not createDefaultXform(templatePath, targetFile, templateFile=templateFile, model=model):
print("Failed!")
else:
self.properties.xformModules.append({
"moduleName": moduleName,
"filename": targetFile.as_posix(),
"inputKinds": [],
"outputKinds": [],
"tags": []
})
self.properties.xformConfig.append({
"moduleName": self.properties.name + "." + moduleName,
"parameters": {},
"tags": []
})
self.save()
return True
def loadSchemas(self):
'''Load all schemas from the warehouse.'''
self.schemaDefs = self.warehouse.getSchemaDefintions()
for _, schDef in self.schemaDefs.items():
# TODO: insert schema definition record into database
with cd(schDef.absDirname):
self.schemaRepo.addFromDescription(schDef)
def deleteTemplate(args):
global portfolio
if not setup(args):
return
filename = portfolio.normalizeFilename(args.name)
with cd(portfolio.projectPath):
seg = portfolio.defaultSegment()
seg.deleteTemplate(filename)
def createTemplate(args):
global portfolio
if not setup(args):
return
filename = portfolio.normalizeFilename(args.name)
with cd(portfolio.projectPath):
tp = portfolio.warehouse.getDefaultsTemplatePath()
seg = portfolio.defaultSegment()
seg.createTemplate(filename, tp)
def test_saveLoad(self, tmp_path):
logging.basicConfig(level=logging.DEBUG)
with cd(tmp_path):
pf = Portfolio(tmp_path)
pf.create()
pf.save()
pf.db.close()
pf2 = Portfolio(tmp_path)
assert pf2.properties.name == "fashion"
def createTemplate(self, filename):
'''
Create a template in this segment from a file.
:param Path filename: filename of template file, relative to portfolio project directory.
:returns: True if success.
:rtype: boolean
'''
absFn = filename.absolute()
with cd(self.absDirname):
with cd(self.properties.defaultTemplatePath):
absDst = filename.absolute()
try:
absDst.parent.mkdir(parents=True, exist_ok=True)
except:
pass
shutil.copy(absFn.as_posix(), absDst.as_posix())
return True
def importSegment(self, zipfilename):
'''
Import a segment from a zip file.
:param string zipfilename: filename of export.
'''
with zipfile.ZipFile(zipfilename, mode='r') as zip:
with cd(self.dir):
zip.extractall()
def test_createDelete(self, tmp_path):
logging.basicConfig(level=logging.DEBUG)
with cd(tmp_path):
pf = Portfolio(tmp_path)
assert pf is not None
assert pf.exists() == False
pf.create()
assert pf.exists() == True
pf.delete()
assert pf.exists() == False
def build(args):
'''Build the output.'''
global portfolio
if not setup(args):
return
print("building...")
with cd(portfolio.projectPath):
r = portfolio.getRunway()
r.plan()
r.execute()
def getAbsPath(self, filename):
'''
Translate filename relative to this segment.
:param Path filename: the relative filename to translate.
:returns: the absolute path of the filename.
:rtype: Path
'''
with cd(self.absDirname):
return filename.absolute()
def listSegments(self):
'''
List names of segments in this warehouse.
:returns: a list of segment names in this warehouse.
:rtype: list(string)
'''
# Return the named subdirectories.
with cd(self.dir):
return [d.name for d in self.dir.iterdir() if d.is_dir()]
def xformExists(self, xformName):
'''
Test if an xform exists in this segment.
:param string xformName: name of xform to test.
:returns: True if xform exists.
:rtype: boolean
'''
filename = Path(xformName + ".py")
targetFile = Path(self.properties.defaultXformPath) / filename
with cd(self.absDirname):
return targetFile.exists()
def initModules(self, tags=None):
'''Initialize modules from their configs.'''
self.moduleCfgs = self.warehouse.getModuleConfigs(self.dba, self.modules)
verbose = self.dba.isVerbose()
for cfg in self.moduleCfgs:
with cd(cfg.absDirname):
with ModelAccess(self.dba, self.schemaRepo, cfg) as mdb:
self.setMdb(mdb)
mod = self.modules[cfg.moduleName]
if verbose:
print("Initializing module {0}".format(
mod.properties.moduleName))
self.codeRegistry.setObjectConfig(cfg)
mod.init(cfg, self.codeRegistry, tags)
def exportSegment(self, segname, db):
'''
Export a segment to a zip file.
:param string segname: name of segment to export.
'''
seg = self.loadSegment(segname, db)
exportName = segname + "_v" + seg.properties.version + ".zip"
dirName = seg.absDirname.parent.resolve()
with zipfile.ZipFile(exportName, mode='w') as zip:
with cd(dirName):
for root, _, files in os.walk(segname):
if os.path.basename(root) != '__pycache__':
for file in files:
zip.write(os.path.join(root, file))
def test_ctor(self, tmp_path):
'''Test Segment ctor.'''
with cd(tmp_path):
s1 = Segment(Path("segment.json"))
assert s1.absFilename is not None
assert s1.absDirname is not None
assert s1.properties.templatePath[0] == "./template"
assert len(s1.properties.segmentRefs) == 1
s1.save()
s2 = Segment.load(Path("segment.json"))
assert s1.properties.templatePath == s2.properties.templatePath
assert s1.properties.xformConfig == s2.properties.xformConfig
assert s1.properties.segmentRefs == s2.properties.segmentRefs
assert s1.properties.extraFiles == s2.properties.extraFiles
assert s1.absFilename == s2.absFilename
def loadModules(self, tags=None):
'''Load all xform module code.'''
self.moduleDefs = self.warehouse.getModuleDefinitions(self.dba, tags)
verbose = self.dba.isVerbose()
self.dba.table('fashion.core.module.definition').purge()
for modName, modDef in self.moduleDefs.items():
with cd(modDef.absDirname):
if verbose:
print("Loading module {0}".format(modDef.moduleName))
mod = XformModule(modDef)
if mod.loadModuleCode():
self.modules[modName] = mod
self.dba.table('fashion.core.module.definition').insert(modDef)
else:
# TODO: file not found, etc.
pass
def createSchema(self, kind, schema):
'''
Create a JSON schema file for a model kind.
:param string kind: model kind for schema.
:param JSONobject schema: the schema for model kind.
'''
filename = Path(self.properties.defaultSchemaPath) / \
Path(kind + ".json")
with cd(self.absDirname):
with filename.open(mode="w") as fp:
json.dump(schema, fp, indent=4)
self.properties.schema.append({
"kind": kind,
"filename": str(filename)
})
self.save()
def test_create(self, tmp_path):
'''Test creating a new segment.'''
with cd(tmp_path):
s1 = Segment.create(tmp_path, "testseg")
assert s1.absFilename is not None
assert s1.absDirname is not None
assert s1.absFilename.exists()
p = s1.absDirname
assert p.exists()
modelDir = p / "model"
assert modelDir.exists()
s2 = Segment.load(Path("segment.json"))
assert s1.properties.templatePath == s2.properties.templatePath
assert s1.properties.xformConfig == s2.properties.xformConfig
assert s1.properties.segmentRefs == s2.properties.segmentRefs
assert s1.properties.extraFiles == s2.properties.extraFiles
assert str(s1.absFilename) == str(s2.absFilename)
def findModuleDefinitions(self):
xformModules = []
with cd(self.absDirname / "xform"):
for root, _, files in os.walk("."):
if os.path.basename(root) != '__pycache__':
for file in files:
p = Path(root) / Path(file)
filename = Path("xform") / p
mod = [self.properties.name]
mod.extend(p.parts[0:-1])
mod.append(p.stem)
modName = ".".join(mod)
modDef = {
"moduleName": modName,
"filename": str(filename.as_posix()),
"templatePath": self.properties.templatePath
}
xformModules.append(modDef)
return xformModules
def deleteXform(self, xformName):
'''
Delete an xform from this segment.
:param string xformName: name of xform to delete.
'''
filename = Path(xformName + ".py")
targetFile = Path(self.properties.defaultXformPath) / filename
with cd(self.absDirname):
if targetFile.exists():
targetFile.unlink()
moduleName = xformName
modDefs = [
x for x in self.properties.xformModules if x.moduleName != moduleName]
self.properties.xformModules = modDefs
moduleName = self.properties.name + "." + xformName
modCfgs = [
x for x in self.properties.xformConfig if x.moduleName != moduleName]
self.properties.xformConfig = modCfgs
self.save()
def test_init(self, tmp_path):
logging.basicConfig(level=logging.DEBUG)
with cd(tmp_path):
pf = Portfolio(tmp_path)
assert pf is not None
assert pf.exists() == False