Python utils.show函数代码示例

def start_supervisor():
    """Start supervisor process."""
    conf = pjoin(cget('service_dir'), 'supervisor', 'config',
        'supervisord.conf')
    pname = cget('supervisor_process_id')
    show(yellow("Starting supervisor with id: %s." % pname))
    return sudo('supervisord --configuration="%s"' % conf)

def ProcessDepFields(depfields,res,rtype,mode='real'):
    if len(depfields.comps.__dict__) == 0:
        return res
    else:
        oldlength = len(depfields.comps.__dict__)
        todelete = []
        for l in depfields.comps.__dict__:
            Resolved = ComputeDepType(res,depfields.comps.__getattribute__(l),rtype.poss)
            #print(show(Resolved))
            if 'not a label' in show(Resolved):  #Is this condition still used?
                pass
            elif Resolved == None:
                pass
            else:
                if mode=='real':
                    res.addfield(l,Resolved.in_poss(rtype.poss).create())
                    todelete.append(l)
                elif mode=='hyp':
                    res.addfield(l,Resolved.create_hypobj())
                    todelete.append(l)
                else:
                    print(mode+' not recognized as option for ProcessDepFields')
        for l in todelete:
            del depfields.comps.__dict__[l]
        if len(depfields.comps.__dict__) < oldlength:
            return ProcessDepFields(depfields,res,rtype,mode)
        else:
            if ttracing('create') or ttracing('create_hypobj'):
                print('Unresolved dependency in '+show(rtype))
            return None

def ensure_language(dbname, lang):
    """Ensures language exists."""
    sql_command = """
    CREATE OR REPLACE FUNCTION create_language_{0}() RETURNS BOOLEAN AS \$\$
        CREATE LANGUAGE {0};
        SELECT TRUE;
    \$\$ LANGUAGE SQL;

    SELECT CASE WHEN NOT
        (
            SELECT  TRUE AS exists
            FROM    pg_language
            WHERE   lanname = '{0}'
            UNION
            SELECT  FALSE AS exists
            ORDER BY exists DESC
            LIMIT 1
        )
    THEN
        create_language_{0}()
    ELSE
        FALSE
    END AS {0}_created;

    DROP FUNCTION create_language_{0}();
    """.format(
        lang
    )
    show(colors.yellow("Ensuring PostgreSQL language exists: %s"), lang)
    call_psql(sql_command, database=dbname)

def start_supervisor(conf=None):
    """Start supervisor process."""
    if not conf:
        conf = pjoin(cget("service_dir"), "supervisor", "config", "supervisord.conf")
    pname = cget("supervisor_process_id")
    show(yellow("Starting supervisor with id: %s." % pname))
    return sudo('supervisord --configuration="%s"' % conf)

def ti_apply(Tf, Targ):
    if isinstance(Tf, FunType) \
        and Targ.subtype_of(Tf.comps.domain):
        return Tf.comps.range
    else:
        if ttracing('ti_apply'):
            print('Not a well-typed function application: '+ show(Tf) + show(Targ))
        return None

def create_virtualenv():
    """Creates the virtualenv."""
    ve_dir = cget("virtualenv_dir")
    bin_path = pjoin(ve_dir, "bin")
    if not dir_exists(bin_path) or not exists(pjoin(bin_path, "activate")):
        show(yellow("Setting up new Virtualenv in: %s"), ve_dir)
        with settings(hide("stdout", "running")):
            run("virtualenv --distribute %s" % ve_dir)

 def __init__(self,T,a):
     self.comps = Rec({'base_type':T, 'obj':a})
     self.witness_cache = []
     self.supertype_cache = []
     self.witness_conditions = [lambda x: show(x) == show(a) and T.query(x),\
                                lambda x: isinstance(a,LazyObj)\
                                          and show(x) == show(a.eval()) and T.in_poss(self.poss).query(x)]
     self.witness_types = []
     self.poss = ''

    def summary(self,*vars):
        """Display a summary of all recorded notes, checks, records."""

        if vars:
            print("Values Used:")
            print("============")
            print()
            show(*vars,depth=1)
            
        var = self.var
        hd = 'Summary of'
        if var is not None:
            hd += ' '+var+' for '
        hd += self.__class__.__name__
        if self.title:
            hd += ': '+str(self.title)
        
        print()
        print(hd)
        print('=' * len(hd))
        print()
        if self._notes:
            print('Notes:')
            print('------')
            for txt in self._notes:
                print('    -',txt)
            print()
            
        if self._checks:
            print('Checks:')
            print('-------')
            width = max([len(l) for f,l,v,d in self._checks])
            for chk in self._checks:
                print(self.fmt_check(chk,width=width+2))
            print()
                
        hd = 'Values'
        if self.var:
            hd += ' of '+self.var
        hd += ':'
        print(hd)
        print('-'*len(hd))
        width = max([len(l) for l,v,d in self._record])
        
        govval = None
        if var:
            govval = self.selector([d[var] for l,v,d in self._record])
        for rec in self._record:
            print(self.fmt_record(rec,var=var,width=width+1,govval=govval,nsigfigs=self.nsigfigs))

        if govval is not None:
            print()
            h = 'Governing Value:'
            print('   ',h)
            print('   ','-'*len(h))
            print('      ','{0} = {1}'.format(var,(sfrounds(govval,self.nsigfigs) if isfloat(govval) else "{0!r}".format(govval))), self.units if self.units is not None else '')

def merge_dep_types(f1,f2):
    if isinstance(f1,Type) and isinstance(f1,Type):
        return f1.merge(f2)
    elif isinstance(f1,Fun) and isinstance(f2,Fun):
        var = gensym('v')
        return Fun(var, f1.domain_type.merge(f2.domain_type),
                   merge_dep_types(f1.body.subst(f1.var,var),f2.body.subst(f2.var,var)))
    else:
        if ttracing('merge_dep_types'):
            print(show(f1)+' and '+show(f2)+' cannot be merged.')
        return None

def shutdown():
    """Requests supervisor process and all controlled services shutdown."""
    ve_dir = cget("virtualenv_dir")
    activate = pjoin(ve_dir, "bin", "activate")
    show(yellow("Shutting supervisor down."))
    with prefix("source %s" % activate):
        with settings(hide("stderr", "stdout", "running"), warn_only=True):
            res = run_supevisordctl("shutdown all")
            if res.return_code != 2:
                msg = "Could not shutdown supervisor, process does not exists."
                show(yellow(msg))

def subtype_of_dep_types(f1,f2):
    if isinstance(f1,Type) and isinstance(f2,Type):
        return f1.subtype_of(f2)
    elif isinstance(f1,Fun):
        f1inst = f1.app(f1.domain_type.create_hypobj())
        return subtype_of_dep_types(f1inst,f2)
    elif isinstance(f2,Fun):
        f2inst = f2.app(f2.domain_type.create_hypobj())
        return subtype_of_dep_types(f1,f2inst)
    else:
        if ttracing('subtype_of_dep_types'):
            print(show(f1)+ ' and '+show(f2)+' cannot be compared for subtyping.')
        return None

def configure():
    """Configures the doc module.

    Creates doc_dir and copies documentation sources there.
    Formats and uploads scripts for building the documentation.
    Finally, loads django-sphinxdoc project from a fixture.

    Project fixture can be found in deployment/files/doc/fixture.json.

    """
    # Add extra context variables used by sphinx-doc and apidoc
    excluded = cget('autodoc_excluded_apps')
    excluded = ' '.join(excluded) if excluded else ''
    cset("autodoc_excluded_apps", excluded, force=True)
    cset("project_display_name_slug", slugify(cget('project_display_name')))

    # Asure the doc folder exists
    user = cget('user')
    ddir = cget('doc_dir')
    source_doc_dir = pjoin(cget("project_dir"), "code", "docs")
    create_target_directories([ddir], "755", user)

    # Delete the content of the folder if exist
    with settings(hide("running", "stdout", "stderr")):
        output = sudo('ls -A {doc_dir}'.format(doc_dir=ddir))
        if len(output) > 0:
            sudo("rm -r {doc_dir}/*".format(doc_dir=ddir))

    # Copy files to doc dir
    with settings(hide("running", "stdout")):
        run("cp -r {source}/* {dest}".format(source=source_doc_dir, dest=ddir))
    ensure_permissions(ddir, user=user, group=user, recursive=True)

    context = dict(env["ctx"])

    # Upload formatted build script
    scripts = ['make_apidoc.sh']
    local_dir = local_files_dir("doc")
    show(yellow("Uploading doc scripts: {0}.".format(' '.join(scripts))))
    for script_name in scripts:
        source = pjoin(local_dir, script_name)
        destination = pjoin(cget("script_dir"), script_name)
        upload_template_with_perms(source, destination, context, mode="755")

    # Upload formatted conf.py file
    show(yellow("Uploading formatted conf.py file."))
    conf_file = "conf_formatted.py"
    source = pjoin(cget("local_root"), "docs", 'source', conf_file)
    destination = pjoin(ddir, 'source', conf_file)
    upload_template_with_perms(source, destination, context, mode="755")

 def nu(self,assgn):
     if self.fixed_nu is None:
         res = PType_n(andpred,[self.comps.left,self.comps.right],assgn) # Meet types are treated neurologically as neurological PTypes not neurological Meet types
         res.name = show(self)+'_n'
         return res
     else:
         return self.fixed_nu

 def appc_m(self,arg,M):
     if self.validate_arg_m(arg,M):
         return self.app(arg)
     else:
         if ttracing('appc_m'):
             print (self.show()+'('+show(arg)+'): badly typed function application')
         return None            

def occupancies_ref(ks,q):
    def remove(xs,x):
        xs_new = xs[:]
        xs_new.remove(x)
        return xs_new
    Z = float(sum(falling_fac(q,n)*esp(ks,n) for n in range(q+1)))
    print "Z:",Z
    return [(q*k*sum(show(falling_fac(q-1,n)*esp(remove(ks,k),n)) for n in range(q)))/Z for k in ks]