Python Package.load方法代码示例

# 需要导入模块: from exe.engine.package import Package [as 别名]
# 或者: from exe.engine.package.Package import load [as 别名]
    def do_export(self, inputf, outputf):
        if hasattr(self, 'export_' + self.options["export"]):
            LOG.debug("Exporting to type %s, in: %s, out: %s, overwrite: %s" \
            % (self.options["export"], inputf, outputf, str(self.options["overwrite"])))
            if not outputf:
                if self.options["export"] in ('website', 'singlepage'):
                    outputf = inputf.rsplit(".elp")[0]
                else:
                    outputf = inputf + self.extensions[self.options["export"]]
            outputfp = Path(outputf)
            if outputfp.exists() and not self.options["overwrite"]:
                error = _(u'"%s" already exists.\nPlease try again \
with a different filename') % outputf
                raise Exception(error.encode(sys.stdout.encoding))
            else:
                if outputfp.exists() and self.options["overwrite"]:
                    if outputfp.isdir():
                        for filen in outputfp.walkfiles():
                            filen.remove()
                        outputfp.rmdir()
                    else:
                        outputfp.remove()
                pkg = Package.load(inputf)
                LOG.debug("Package %s loaded" % (inputf))
                if not pkg:
                    error = _(u"Invalid input package")
                    raise Exception(error.encode(sys.stdout.encoding))
                self.styles_dir = self.web_dir.joinpath('style', pkg.style)
                LOG.debug("Styles dir: %s" % (self.styles_dir))
                getattr(self, 'export_' + self.options["export"])(pkg, outputf)
                return outputf
        else:
            raise Exception(_(u"Export format not implemented")\
.encode(sys.stdout.encoding))

# 需要导入模块: from exe.engine.package import Package [as 别名]
# 或者: from exe.engine.package.Package import load [as 别名]
    def createPackageFromTemplate(self, templateBase):
        """
        Creates a new package from Template
        """
        log.debug(u"createPackageFromTemplate")
        package = Package.load(templateBase, isTemplate=True)
        package.set_templateFile(str(templateBase.basename().splitext()[0]))
        # Make up an initial unique name
        i = 1
        name = u"newPackage"
        while name in self.loaded:
            name = u"newPackage" + unicode(i)
            i += 1
        
        # Prevent the package from opening on the last node edited
        package.currentNode = package.root
        
        package.name = name
        package.filename = ""

        # We have to make sure the DocType of the package is the one selected
        # in preferences and not the one used to save de template
        package.docType = G.application.config.docType

        if G.application.config.locale.split('_')[0] != 'zh':
            package.lang = G.application.config.locale.split('_')[0]
        else:
            package.lang = G.application.config.locale
            
        package.translatePackage()
        package.isChanged = False
        
        self.loaded[package.name] = package

        return package

# 需要导入模块: from exe.engine.package import Package [as 别名]
# 或者: from exe.engine.package.Package import load [as 别名]
    def doTest(self, ExporterClass):
        """Exports a package with meta data"""
        # Load our test package
        package = Package.load('testPackage.elp')
        # Do the export
        outFilename = Path('scormtest.zip')
        exporter = ExporterClass(self.app.config,
                                 '../exe/webui/style/default', 
                                 outFilename)
        exporter.export(package)
        # Check that it made a nice zip file
        assert outFilename.exists()
        # See if the manifest file was created
        zipped = ZipFile(outFilename)
        filenames = zipped.namelist()
        assert 'imsmanifest.xml' in filenames, filenames
        self._testManifest(zipped.read('imsmanifest.xml'))

        # Test that all the node's html files have been generated
        pagenodes  = Set([p.node for p in exporter.pages])
        othernodes = Set(self._getNodes([], package.root))
        assert pagenodes == othernodes

        for page in exporter.pages:
            self._testPage(page, zipped)

        # Clean up
        zipped.close()

# 需要导入模块: from exe.engine.package import Package [as 别名]
# 或者: from exe.engine.package.Package import load [as 别名]
    def testExport(self):
        # Delete the output dir
        outdir = TempDirPath()
        
        G.application = Application()
        
        G.application.loadConfiguration()
        G.application.preLaunch()
        
        # Load a package
        package = Package.load('testing/testPackage2.elp')
        # Do the export
        style_dir = G.application.config.stylesDir / package.style
        
        exporter = WebsiteExport(G.application.config,
                                 style_dir, 
                                 outdir)
        
        exporter.export(package)
        # Check that it all exists now
        assert outdir.isdir()
        assert (outdir / 'index.html').isfile()
        # Check that the style sheets have been copied
        for filename in style_dir.files():
            assert ((outdir / filename.basename()).exists(),
                    'Style file "%s" not copied' % (outdir / filename.basename()))

        # Check that each node in the package has had a page made
        pagenodes  = Set([p.node for p in exporter.pages])
        othernodes = Set(self._getNodes([], package.root))
        assert pagenodes == othernodes

        for page in exporter.pages:
            self._testPage(page, outdir)

# 需要导入模块: from exe.engine.package import Package [as 别名]
# 或者: from exe.engine.package.Package import load [as 别名]
 def loadPackage(self, path):
     """
     Load a package from disk, add it to the store and return it
     """
     package = Package.load(path)
     self.loaded[package.name] = package
     return package

# 需要导入模块: from exe.engine.package import Package [as 别名]
# 或者: from exe.engine.package.Package import load [as 别名]
 def _loadPackage(self, client, filename, newLoad=True,
                  destinationPackage=None):
     """Load the package named 'filename'"""
     try:
         encoding = sys.getfilesystemencoding()
         if encoding is None:
             encoding = 'utf-8'
         filename2 = toUnicode(filename, encoding)
         log.debug("filename and path" + filename2)
         # see if the file exists AND is readable by the user
         try:
             open(filename2, 'rb').close()
         except IOError:
             filename2 = toUnicode(filename, 'utf-8')
             try:
                 open(filename2, 'rb').close()
             except IOError:
                 client.alert(_(u'File %s does not exist or is not readable.') % filename2)
                 return None
         package = Package.load(filename2, newLoad, destinationPackage)
         if package is None:
             raise Exception(_("Couldn't load file, please email file to [email protected]"))
     except Exception, exc:
         if log.getEffectiveLevel() == logging.DEBUG:
             client.alert(_(u'Sorry, wrong file format:\n%s') % unicode(exc))
         else:
             client.alert(_(u'Sorry, wrong file format'))
         log.error(u'Error loading package "%s": %s' % (filename2, unicode(exc)))
         log.error(u'Traceback:\n%s' % traceback.format_exc())
         raise

# 需要导入模块: from exe.engine.package import Package [as 别名]
# 或者: from exe.engine.package.Package import load [as 别名]
 def import_xml(self, inputf, outputf):
     if not outputf:
         outputf = inputf.rsplit(".xml")[0]
     xml = open(inputf).read()
     pkg = Package.load(outputf, fromxml=xml)
     if not pkg:
         raise Exception(_(u"Invalid output package '%s'") % outputf)
     pkg.save()
     return outputf

# 需要导入模块: from exe.engine.package import Package [as 别名]
# 或者: from exe.engine.package.Package import load [as 别名]
 def import_xliff(self, inputf, outputf):
     if not outputf:
         outputf = inputf.rsplit(".xlf")[0]
     pkg = Package.load(outputf)
     if not pkg:
         raise Exception(_(u"Invalid output package '%s'") % outputf)
     importer = XliffImport(pkg, inputf)
     importer.parseAndImport(self.options["from-source"])
     pkg.save()
     return outputf

# 需要导入模块: from exe.engine.package import Package [as 别名]
# 或者: from exe.engine.package.Package import load [as 别名]
 def _loadPackage(self, client, filename):
     """Load the package named 'filename'"""
     try:
         encoding = sys.getfilesystemencoding()
         if encoding is None:
             encoding = 'utf-8'
         filename2 = unicode(filename, encoding)
         log.debug("filename and path" + filename2)
         package = Package.load(filename2)
         if package is None:
             filename2 = unicode(filename, 'utf-8')
             package = Package.load(filename2)
             if package is None:
                 raise Exception(_("Couldn't load file, please email file to [email protected]"))
     except Exception, exc:
         if log.getEffectiveLevel() == logging.DEBUG:
             client.alert(_(u'Sorry, wrong file format:\n%s') % unicode(exc))
         else:
             client.alert(_(u'Sorry, wrong file format'))
         log.error(u'Error loading package "%s": %s' % (filename2, unicode(exc)))
         log.error(u'Traceback:\n%s' % traceback.format_exc())
         raise

# 需要导入模块: from exe.engine.package import Package [as 别名]
# 或者: from exe.engine.package.Package import load [as 别名]
    def launch(self):
        """
        launches the webbrowser
        """

        if self.packagePath:
            try:
                package = Package.load(self.packagePath)
                self.webServer.root.package = package
                launchBrowser(self.config, package.name)
            except:
                self.webServer.root.packagePath = None
                launchBrowser(self.config, "")
        else:
            launchBrowser(self.config, "")

# 需要导入模块: from exe.engine.package import Package [as 别名]
# 或者: from exe.engine.package.Package import load [as 别名]
 def __importIdevice(self, filename):
     """
     import the idevices which are not existed in current package from another package
     """
     newPackage = Package.load(filename)
     for idevice in newPackage.idevices:
         isExisted = False
         for currentIdevice in self.ideviceStore.generic:
             if idevice.title == currentIdevice.title:
                 isExisted = True
                 break
         if not isExisted:
             newIdevice = idevice.clone()
             self.ideviceStore.addIdevice(newIdevice)
     self.ideviceStore.save()

# 需要导入模块: from exe.engine.package import Package [as 别名]
# 或者: from exe.engine.package.Package import load [as 别名]
 def doTest(self, ExporterClass):
     """Exports a package with meta data"""
     package = Package.load('testPackage.elp')
     outFilename = Path('scormtest.zip')
     exporter = ExporterClass(self.app.config,
                              '../exe/webui/style/default', 
                              outFilename)
     exporter.export(package)
     assert outFilename.exists()
     zipped = ZipFile(outFilename)
     filenames = zipped.namelist()
     assert 'imsmanifest.xml' in filenames, filenames
     self._testManifest(zipped.read('imsmanifest.xml'))
     pagenodes  = Set([p.node for p in exporter.pages])
     othernodes = Set(self._getNodes([], package.root))
     assert pagenodes == othernodes
     for page in exporter.pages:
         self._testPage(page, zipped)
     zipped.close()

# 需要导入模块: from exe.engine.package import Package [as 别名]
# 或者: from exe.engine.package.Package import load [as 别名]
 def testExport(self):
     outdir = TempDirPath()
     package = Package.load('testPackage.elp')
     exporter = WebsiteExport('../exe/webui/style/default', 
                              outdir,
                              '../exe/webui/images', 
                              '../exe/webui/scripts',
                              '../exe/webui/templates')
     exporter.export(package)
     assert outdir.isdir()
     assert (outdir / 'index.html').isfile()
     for filename in Path('../exe/webui/style/default').files():
         assert ((outdir / filename.basename()).exists(),
                 'Style file "%s" not copied' % (outdir / filename.basename()))
     pagenodes  = Set([p.node for p in exporter.pages])
     othernodes = Set(self._getNodes([], package.root))
     assert pagenodes == othernodes
     for page in exporter.pages:
         self._testPage(page, outdir)

# 需要导入模块: from exe.engine.package import Package [as 别名]
# 或者: from exe.engine.package.Package import load [as 别名]
    def _testSaveAndLoad(self):
        packageStore = PackageStore()
        package = packageStore.createPackage()
        # Check that it has been given a default name
        self.assertEquals(package.name, "newPackage")
        package.author = "UoA"
        package.description = "Nice test package"
        Config._getConfigPathOptions = lambda s: ["exe.conf"]
        config = Config()
        filePath = config.dataDir / "package1.elp"
        package.save(filePath)

        package1 = Package.load(filePath)
        self.assert_(package1)
        self.assertEquals(package1.author, "UoA")
        self.assertEquals(package1.description, "Nice test package")
        # Package name should have been set when it was saved
        self.assertEquals(package.name, "package1")
        self.assertEquals(package1.name, "package1")

# 需要导入模块: from exe.engine.package import Package [as 别名]
# 或者: from exe.engine.package.Package import load [as 别名]
 def testSaveAndLoad(self):
     packageStore = PackageStore()
     package = packageStore.createPackage()
     # Check that it has been given a default name
     self.assertEquals(package.name, "newPackage")
     package.author = "UoA"
     package.description = "Nice test package"
     Config._getConfigPathOptions = lambda s: ['exe.conf']
     config  = Config()
     SuperTestCase.update_config_parser(config.configParser)
     config.loadSettings()
             
     filePath = config.dataDir/'package1.elp'
     package.save(filePath)
     
     package1 = Package.load(filePath)
     self.assert_(package1)
     self.assertEquals(package1.author, "UoA")
     self.assertEquals(package1.description, "Nice test package")
     # Package name should have been set when it was saved
     self.assertEquals(package.name, "package1")
     self.assertEquals(package1.name, "package1")