Python utils.warn函数代码示例

def readDXF(filename):
    """Read a DXF file and extract the recognized entities.

    `filename`: name of a .DXF file.

    Returns a multiline string with one line for each recognized entity,
    in a format that can directly be used by :func:`convertDXF`.
    
    This function requires the external program `dxfparser` which comes
    with the pyFormex distribution. It currently recognizes entities of
    type 'Arc', 'Line', 'Polyline', 'Vertex'.
    """
    import utils,commands
    print(filename)
    if utils.hasExternal('dxfparser'):
        cmd = 'pyformex-dxfparser %s 2>/dev/null' % filename
        print(cmd)
        sta,out = utils.runCommand(cmd)
        if sta==0:
            return out
        else:
            return ''
    else:
        utils.warn('warn_no_dxfparser')
        return ''

    def verify_plugin_settings(self):
        puts("Verifying settings requested by plugins...")

        missing_settings = False
        missing_setting_error_messages = []
        with indent(2):
            for name, meta in self.required_settings_from_plugins.items():
                if not hasattr(settings, name):
                    error_message = (
                        "%(setting_name)s is missing. It's required by the"
                        "%(plugin_name)s plugin's '%(function_name)s' method."
                    ) % meta
                    puts(colored.red("✗ %(setting_name)s" % meta))
                    missing_setting_error_messages.append(error_message)
                    missing_settings = True
                else:
                    show_valid("%(setting_name)s" % meta)

            if missing_settings:
                puts("")
                warn(
                    "Will is missing settings required by some plugins. "
                    "He's starting up anyway, but you will run into errors"
                    " if you try to use those plugins!"
                )
                self.add_startup_error("\n".join(missing_setting_error_messages))
            else:
                puts("")

def tvnamer(paths):
    """Main tvnamer function, takes an array of paths, does stuff.
    """
    # Warn about move_files function
    if Config['move_files_enable']:
        import warnings
        warnings.warn("The move_files feature is still under development. "
            "Be very careful with it.\n"
            "It has not been heavily tested, and is not recommended for "
            "general use yet.")

    if Config['force_name'] is not None:
        import warnings
        warnings.warn("The --name argument is a temporary solution, and will"
            "be removed at some point in the future. Do no depend on it")

    p("#" * 20)
    p("# Starting tvnamer")

    episodes_found = []

    for cfile in findFiles(paths):
        parser = FileParser(cfile)
        try:
            episode = parser.parse()
        except InvalidFilename, e:
            warn("Invalid filename: %s" % e)
        else:
            if episode.seriesname is None:
                warn("Parsed filename did not contain series name, skipping: %s" % cfile)
            else:
                episodes_found.append(episode)

def syslog(message, tag='cvs_check', priority='local0.warn'):
    """Add the given entry to the syslog file.

    PARAMETERS
        message: The message to file.
        tag: Mark every line in the log with the specified tag.
        priority: Enter the message with the specified priority.
    """
    logger_exe = 'logger'
    if 'GIT_HOOKS_LOGGER' in environ:
        logger_exe = environ['GIT_HOOKS_LOGGER']

    p = Popen([logger_exe, '-t', tag, '-p', priority, message],
              stdout=PIPE, stderr=STDOUT)
    out, _ = p.communicate()
    if p.returncode != 0:
        info = (['Failed to file the following syslog entry:',
                 '  - message: %s' % message,
                 '  - tag: %s' % tag,
                 '  - priority: %s' % priority,
                 '',
                 'logger returned with error code %d:' % p.returncode]
                + out.splitlines())
        warn(*info)

    elif out.rstrip():
        print out.rstrip()

def tvnamer(paths):
    """Main tvnamer function, takes an array of paths, does stuff.
    """
    print "#" * 20
    print "# Starting tvnamer"

    episodes_found = []

    for cfile in findFiles(paths):
        parser = FileParser(cfile)
        try:
            episode = parser.parse()
        except InvalidFilename:
            warn("Invalid filename %s" % cfile)
        else:
            episodes_found.append(episode)

    if len(episodes_found) == 0:
        raise NoValidFilesFoundError()

    print "# Found %d episodes" % len(episodes_found)

    tvdb_instance = Tvdb(
        interactive=not Config['selectfirst'],
        debug = Config['verbose'],
        search_all_languages = Config['search_all_languages'],
        language = Config['language'])

    for episode in episodes_found:
        processFile(tvdb_instance, episode)
        print

    print "#" * 20
    print "# Done"

def track_module(module):
	dependency_map = {}
	include_stack = collections.OrderedDict()
	included_dirs = set()
	for source, ext, _ in module.source_files():
		dependency_map[source] = (track_file(module, source, included_dirs, include_stack), ext)
	for dep in module.private_required:
		ok = False
		for d in dep.public_includes:
			if d in included_dirs:
				ok = True
				break
		if not ok:
			utils.warn("Module %s: Useless dependency '%s'" % (module.name, dep.name))
	included_dirs = set()
	for header, ext, _ in module.header_files():
		dependency_map[header] = (track_file(module, header, included_dirs, include_stack), ext)
	for dep in module.public_required:
		ok = False
		for d in dep.public_includes:
			if d in included_dirs:
				ok = True
				break
		if not ok:
			utils.warn("Module %s: Dependency '%s' should be private" % (module.name, dep.name))
	return dependency_map

    def __init__(self, *args, **kwargs):
        self.__dict__ = self.__shared_state

        if not getattr(self, 'initialised', False):
            self.initialised = True

            self.timestamp = time.strftime("%Y%m%d%H%M%S")

            cnf = Config()
            if cnf.has_key("Dir::UrgencyLog"):
                # Create the log directory if it doesn't exist
                self.log_dir = cnf["Dir::UrgencyLog"]

                if not os.path.exists(self.log_dir) or not os.access(self.log_dir, os.W_OK):
                    warn("UrgencyLog directory %s does not exist or is not writeable, using /srv/ftp.debian.org/tmp/ instead" % (self.log_dir))
                    self.log_dir = '/srv/ftp.debian.org/tmp/'

                # Open the logfile
                self.log_filename = "%s/.install-urgencies-%s.new" % (self.log_dir, self.timestamp)
                self.log_file = open_file(self.log_filename, 'w')

            else:
                self.log_dir = None
                self.log_filename = None
                self.log_file = None

            self.writes = 0

def Minimize(func, h, points):
    n = len(points)
    if n > 2000:
        #raise ValueError("Too many points for Cross Validation, limit is 2000")
        msg = "Too many points for Cross Validation, limit is 2000, using 0.7 * hRef."
        utils.warn(msg)
        return 0.7*h
    
    allSquaredDistances = DistancesSquared(points)

    min_percent = 0.05
    max_percent = 2.00
    step_percent = 0.10
    h1 = Search(func, allSquaredDistances, n, h, min_percent, max_percent, step_percent)
    if h1 <= min_percent * h or h1 >= max_percent * h:
        # then it is the min or max value checked
        msg = "Cross Validation using "+func.__name__+" failed to minimize, using 0.7 * hRef."
        utils.warn(msg)
        return 0.7*h
#    return h1
    #print h1
    h2 = Search(func, allSquaredDistances, n, h1, 0.89, 1.11, 0.01)
    #print h2
    h3 = Search(func, allSquaredDistances, n, h2, 0.989, 1.011, 0.001)
    return h3

def doMoveFile(cnamer, destDir = None, destFilepath = None, getPathPreview = False):
    """Moves file to destDir, or to destFilepath
    """

    if (destDir is None and destFilepath is None) or (destDir is not None and destFilepath is not None):
        raise ValueError("Specify only destDir or destFilepath")

    if not (Config['move_files_enable'] or Config['link_files_enable']):
        raise ValueError("move_files feature is disabled but doMoveFile was called")

    if Config['move_files_destination'] is None:
        raise ValueError("Config value for move_files_destination cannot be None if move_files_enabled is True")

    try:
        if Config['link_files_enable'] and not Config['move_files_enable']:
            return cnamer.linkPath(
                new_path = destDir,
                new_fullpath = destFilepath,
                always_move = Config['always_move'],
                getPathPreview = getPathPreview,
                force = Config['overwrite_destination_on_move'])
        else:
            return cnamer.newPath(
                new_path = destDir,
                new_fullpath = destFilepath,
                always_move = Config['always_move'],
                getPathPreview = getPathPreview,
                force = Config['overwrite_destination_on_move'],
                linkBack = Config['link_files_enable'])

    except OSError, e:
        warn(e)

def processFile(tvdb_instance, episode):
    """Gets episode name, prompts user for input
    """
    p("#" * 20)
    p("# Processing file: %s" % episode.fullfilename)

    if len(Config['input_filename_replacements']) > 0:
        replaced = applyCustomInputReplacements(episode.fullfilename)
        p("# With custom replacements: %s" % (replaced))

    # Use force_name option. Done after input_filename_replacements so
    # it can be used to skip the replacements easily
    if Config['force_name'] is not None:
        episode.seriesname = Config['force_name']

    p("# Detected series: %s (%s)" % (episode.seriesname, episode.number_string()))

    try:
        episode.populateFromTvdb(tvdb_instance, force_name=Config['force_name'], series_id=Config['series_id'])
    except (DataRetrievalError, ShowNotFound), errormsg:
        if Config['always_rename'] and Config['skip_file_on_error'] is True:
            warn("Skipping file due to error: %s" % errormsg)
            return
        else:
            warn(errormsg)

 def commit(self):
     if self.__cursor:
         self.__cursor.close()
         self.__conn.commit()
         self.__cursor = None
     else:
         utils.warn('Nothing committed!!!')

def post_receive_one(ref_name, old_rev, new_rev, refs, submitter_email):
    """post-receive treatment for one reference.

    PARAMETERS
        ref_name: The name of the reference.
        old_rev: The SHA1 of the reference before the update.
        new_rev: The SHA1 of the reference after the update.
        refs: A dictionary containing all references, as described
            in git_show_ref.
        submitter_email: Same as AbstractUpdate.__init__.
    """
    debug('post_receive_one(ref_name=%s\n'
          '                        old_rev=%s\n'
          '                        new_rev=%s)'
          % (ref_name, old_rev, new_rev))

    update = new_update(ref_name, old_rev, new_rev, refs, submitter_email)
    if update is None:
        # We emit a warning, rather than trigger an assertion, because
        # it gives the script a chance to process any other reference
        # that was updated, but not processed yet.
        warn("post-receive: Unsupported reference update: %s (ignored)."
             % ref_name,
             "              old_rev = %s" % old_rev,
             "              new_rev = %s" % new_rev)
        return
    update.send_email_notifications()

    def __no_cvs_check_user_override(self):
        """Return True iff pre-commit-checks are turned off by user override...

        ... via the ~/.no_cvs_check file.

        This function also performs all necessary debug traces, warnings,
        etc.
        """
        no_cvs_check_fullpath = expanduser('~/.no_cvs_check')
        # Make sure the tilde expansion worked.  Since we are only using
        # "~" rather than "~username", the expansion should really never
        # fail...
        assert (not no_cvs_check_fullpath.startswith('~'))

        if not isfile(no_cvs_check_fullpath):
            return False

        # The no_cvs_check file exists.  Verify its age.
        age = time.time() - getmtime(no_cvs_check_fullpath)
        one_day_in_seconds = 24 * 60 * 60

        if (age > one_day_in_seconds):
            warn('%s is too old and will be ignored.' % no_cvs_check_fullpath)
            return False

        debug('%s found - pre-commit checks disabled' % no_cvs_check_fullpath)
        syslog('Pre-commit checks disabled for %(rev)s on %(repo)s by user'
               ' %(user)s using %(no_cvs_check_fullpath)s'
               % {'rev': self.new_rev,
                  'repo': self.email_info.project_name,
                  'user': get_user_name(),
                  'no_cvs_check_fullpath': no_cvs_check_fullpath,
                  })
        return True

def check(modules):
	checked = []
	module_names = {}
	main_module = 0
	for module in modules:
		try:
			if module.name in module_names:
				raise CheckError("redefined")
			module_names[module.name] = module
			_check_module(module, checked)
			checked.append(module)
		except config.BaseError as e:
			raise CheckError("Module %s: %s" % (module.name, str(e)))
		if module.is_main:
			main_module += 1
	if main_module == 0:
		utils.warn("Main module missing")
	for module in modules:
		def check_dep(lst):
			for r in lst:
				if r.is_main:
					utils.warn("Main module %s: Should be the root module (required by %s)" % (r.name, module.name))
		check_dep(module.public_required)
		check_dep(module.private_required)
	for module in modules:
		check_include_loop(module, [])
	return True

    def get(self, request, *args, **kwargs):
        # get base
        base = kwargs['base']
        base_model = get_object_or_404(Base, name=base)

        # exec id
        exec_id = kwargs['id']

        # get exec from database
        try:
            exec_model = base_model.apys.get(name=exec_id)
        except Apy.DoesNotExist:
            warn(channel_name_for_user(request), "404 on %s" % request.META['PATH_INFO'])
            return HttpResponseNotFound("404 on %s"     % request.META['PATH_INFO'])

        user = channel_name_for_user(request)
        debug(user, "%s-Request received, URI %s" % (request.method, request.path))

        apy_data = serializers.serialize("json", [exec_model], fields=('base_id', 'name'))
        struct = json.loads(apy_data)
        apy_data = json.dumps(struct[0])
        rpc_request_data = {}
        rpc_request_data.update({'model': apy_data, 
                'base_name': base_model.name,
            })
        get_dict = copy.deepcopy(request.GET)
        post_dict = copy.deepcopy(request.POST)
        for key in ["json", "shared_key"]:
            if request.method == "GET":
                if get_dict.has_key(key): del get_dict[key]
            if request.method == "POST":
                if post_dict.has_key(key): del get_dict[key]
        rpc_request_data.update({'request': 
                { 
                'method': request.method,
                'GET': get_dict.dict(),
                'POST': post_dict.dict(),
                #'session': request.session.session_key,
                'user': {'username': request.user.username},
                'REMOTE_ADDR': request.META.get('REMOTE_ADDR')
                }
            })
        logger.debug("REQUEST-data: %s" % rpc_request_data)
        try:
            # _do on remote
            start = int(round(time.time() * 1000))
            response_data = call_rpc_client(json.dumps(rpc_request_data), 
                generate_vhost_configuration(base_model.user.username, base_model.name), 
                base_model.name, 
                base_model.executor.password)
            end = int(round(time.time() * 1000))
            ms=str(end-start)

            logger.info("RESPONSE-time: %sms" %  str(ms))
            logger.debug("RESPONSE-data: %s" % response_data[:120])
            data = json.loads(response_data)
        except Exception, e:
            logger.exception(e)
            raise HttpResponseServerError(e)