示例#1
0
 def package(self):
     if not self.app.release_root.exists:
         self.app.release_root.make()
     app = Folder(self.app.path)
     try:
         zip_path = app.zzip()
     except:
         self.fail("Cannot create the archive")    
     vzip_name = self.eval('name')
     vzip_path = self.app.release_root.child(vzip_name)
     self.app.archive = File(vzip_path)
     self.app.archive.delete()
     File(zip_path).move_to(vzip_path)
示例#2
0
    def build_siteinfo(self, deploy_path=None):
        tmp_folder = Folder(settings.TMP_DIR)
        deploy_folder = Folder((deploy_path, settings.DEPLOY_DIR)[not deploy_path])

        if deploy_folder.exists and settings.BACKUP:
            backup_folder = Folder(settings.BACKUPS_DIR).make()
            deploy_folder.backup(backup_folder)

        tmp_folder.delete()
        tmp_folder.make()
        settings.DEPLOY_DIR = deploy_folder.path
        if not deploy_folder.exists:
            deploy_folder.make()
        self.create_siteinfo()
示例#3
0
    def initialize(self, root, template=None, force=False):
        if not template:
            template = "default"
        root_folder = Folder(root)
        template_dir = root_folder.child_folder("templates", template)

        if not template_dir.exists:
            raise ValueError("Cannot find the specified template[%s]." % template_dir)

        if self.site_path.exists:
            files = os.listdir(self.site_path.path)
            PathUtil.filter_hidden_inplace(files)
            if len(files) and not force:
                raise ValueError("The site_path[%s] is not empty." % self.site_path)
            else:
                self.site_path.delete()
        self.site_path.make()
        self.site_path.copy_contents_of(template_dir)
示例#4
0
 def build_siteinfo(self, deploy_path=None):
     tmp_folder = Folder(settings.TMP_DIR)
     deploy_folder = Folder(
                         (deploy_path, settings.DEPLOY_DIR)
                         [not deploy_path])
     
     if deploy_folder.exists and settings.BACKUP:
         backup_folder = Folder(settings.BACKUPS_DIR).make()
         deploy_folder.backup(backup_folder)
     
     tmp_folder.delete()
     tmp_folder.make()
     settings.DEPLOY_DIR = deploy_folder.path
     if not deploy_folder.exists:
         deploy_folder.make()
     add_to_builtins('hydeengine.templatetags.hydetags')
     add_to_builtins('hydeengine.templatetags.aym')
     add_to_builtins('hydeengine.templatetags.typogrify')
     self.create_siteinfo()
示例#5
0
    def initialize(self, root, template=None, force=False):
        if not template:
            template = "default"
        root_folder = Folder(root)
        template_dir = root_folder.child_folder("templates", template)

        if not template_dir.exists:
            raise ValueError("Cannot find the specified template[%s]." %
                             template_dir)

        if self.site_path.exists:
            files = os.listdir(self.site_path.path)
            PathUtil.filter_hidden_inplace(files)
            if len(files) and not force:
                raise ValueError("The site_path[%s] is not empty." %
                                 self.site_path)
            else:
                self.site_path.delete()
        self.site_path.make()
        self.site_path.copy_contents_of(template_dir)
    def initialize_population(population_size_setpoint):
        print("Welcome to auto-ML!")
        # deal with path
        path = "Store"
        test_dir(path)

        folder = Folder(path)
        p = Population(folder, population_size_setpoint)
        print('population initialization succeed!\n')

        return p
示例#7
0
def main(argv):
    
    parser = OptionParser(usage="usage: %prog [options]", version="%prog 0.1a")       
    parser.add_option("-a", "--app", 
                        dest = "app", 
                        help = "The application to build. Required.")
    parser.add_option("-p", "--path", 
                        dest = "path", default = '.', 
                        help = "Conche root path. Default: Current Working Directory. Optional. Default: `%default`")
                        
    (options, args) = parser.parse_args()
    if len(args):
        parser.error("Unexpected arguments encountered.")
    
    if not options.app:
        parser.error("You must specify an application.")

    path = options.path  
    
    if path == ".":
        path = os.getcwdu()
   
    target = Folder(path) 
    if not target.exists:
        target.make()
    source = Folder(PROG_ROOT).child_folder('template')
    target.copy_contents_of(source, incremental=True)
    
    apps = File(target.child('apps.yaml'))
    appsString = apps.read_all()
    appsString = string.Template(appsString).safe_substitute(init_app = options.app)
    apps.write(appsString)
示例#8
0
 def __init__(self, site_path):
     super(Initializer, self).__init__()
     self.site_path = Folder(site_path)
示例#9
0
print("Welcome to analysis system!")
# deal with path
last_path = load_path()
response = None
if last_path != '':
    print("Notice the last store path is: ", last_path)
    while response not in ('y', 'n'):
        response = input("Do you want to use that?(y/n): ").lower()
    if response == 'y':
        last_path = test_dir(last_path)
if response == 'n' or last_path == '' or response is None:
    last_path = input("Please choose a new store path: ")
    last_path = test_dir(last_path)

last_path = test_dir(last_path)
folder = Folder(last_path)
data = np.zeros(folder.max_id)
best = []

for file in folder.history:
    # alive file
    if not folder.alive(file):
        dead_file_path = folder.dead_file_path(file)
        arch_proto = read_file(dead_file_path)
        arch = Arch(arch_proto)
        data[arch.id - 1] = arch.accuracy

    # dead file
    else:
        file_path = folder.file_path(file)
        arch_proto = read_file(file_path)
示例#10
0
 def __init__(self, site_path):
     super(Initializer, self).__init__()
     self.site_path = Folder(site_path)
示例#11
0
    def build_siteinfo(self, deploy_path=None):
        tmp_folder = Folder(settings.TMP_DIR)
        deploy_folder = Folder(
            (deploy_path, settings.DEPLOY_DIR)[not deploy_path])

        if deploy_folder.exists and settings.BACKUP:
            backup_folder = Folder(settings.BACKUPS_DIR).make()
            deploy_folder.backup(backup_folder)

        tmp_folder.delete()
        tmp_folder.make()
        settings.DEPLOY_DIR = deploy_folder.path
        if not deploy_folder.exists:
            deploy_folder.make()
        self.create_siteinfo()
示例#12
0
    def serve(self, deploy_path, exit_listner):
        """
        Starts the cherrypy server at the given `deploy_path`.  If exit_listner is 
        provided, calls it when the engine exits.
        
        """
        try:
            import cherrypy
            from cherrypy.lib.static import serve_file
        except ImportError:
            print "Cherry Py is required to run the webserver"
            raise

        setup_env(self.site_path)
        validate_settings()
        deploy_folder = Folder(
            (deploy_path, settings.DEPLOY_DIR)[not deploy_path])
        if not 'site' in settings.CONTEXT:
            generator = Generator(self.site_path)
            generator.create_siteinfo()
        site = settings.CONTEXT['site']
        url_file_mapping = defaultdict(bool)
        # This following bit is for supporting listing pages with arbitrary
        # filenames.
        if settings.GENERATE_CLEAN_URLS:
            for page in site.walk_pages():  # build url to file mapping
                if page.listing and page.file.name_without_extension not in \
                   (settings.LISTING_PAGE_NAMES + [page.node.name]):
                    filename = os.path.join(settings.DEPLOY_DIR, page.name)
                    url = page.url.strip('/')
                    url_file_mapping[url] = filename

        class WebRoot:
            @cherrypy.expose
            def index(self):
                page = site.listing_page
                return serve_file(deploy_folder.child(page.name))

            if settings.GENERATE_CLEAN_URLS:

                @cherrypy.expose
                def default(self, *args):
                    # first, see if the url is in the url_file_mapping
                    # dictionary
                    file = url_file_mapping[os.sep.join(args)]
                    if file:
                        return serve_file(file)
                    # next, try to find a listing page whose filename is the
                    # same as its enclosing folder's name
                    file = os.path.join(deploy_folder.path, os.sep.join(args),
                                        args[-1] + '.html')
                    if os.path.isfile(file):
                        return serve_file(file)
                    # try each filename in LISTING_PAGE_NAMES setting
                    for listing_name in settings.LISTING_PAGE_NAMES:
                        file = os.path.join(deploy_folder.path,
                                            os.sep.join(args),
                                            listing_name + '.html')
                        if os.path.isfile(file):
                            return serve_file(file)
                    # failing that, search for a non-listing page
                    file = os.path.join(deploy_folder.path,
                                        os.sep.join(args[:-1]),
                                        args[-1] + '.html')
                    if os.path.isfile(file):
                        return serve_file(file)
                    # failing that, page not found
                    raise cherrypy.NotFound

        cherrypy.config.update({
            'environment': 'production',
            'log.error_file': 'site.log',
            'log.screen': True,
            'server.socket_host': self.address,
            'server.socket_port': self.port,
        })

        # even if we're still using clean urls, we still need to serve media.
        if settings.GENERATE_CLEAN_URLS:
            conf = {
                '/media': {
                    'tools.staticdir.dir':
                    os.path.join(deploy_folder.path, 'media'),
                    'tools.staticdir.on':
                    True
                }
            }
        else:
            conf = {
                '/': {
                    'tools.staticdir.dir': deploy_folder.path,
                    'tools.staticdir.on': True
                }
            }
        cherrypy.tree.mount(WebRoot(), "/", conf)
        if exit_listner:
            cherrypy.engine.subscribe('exit', exit_listner)
        cherrypy.engine.start()