Python utils.printerr函数代码示例

def _get_uri_and_repo(path):
    """ Get a URI and repositoryhandler object for a path.

    This function returns a URI as a string, and the repositoryhandler
    object that represents that URI. They are returned together as a tuple.

    Args:
      path: The path to the repository
    """
    # Create repository
    if path is not None:
        try:
            printdbg("Creating repositoryhandler instance")
            repo = create_repository_from_path(path)
            repo.timeout = 120
        except RepositoryUnknownError:
            printerr("Path %s doesn't seem to point to a repository " + \
                     "supported by cvsanaly", (path,))
            sys.exit(1)
        except Exception, e:
            printerr("Unknown error creating repository for path %s (%s)",
                     (path, str(e)))
            sys.exit(1)
        uri = repo.get_uri_for_path(path)
        return (uri, repo)

def main (argv):
    # Short (one letter) options. Those requiring argument followed by :
    short_opts = "hVgqnf:l:s:u:p:d:H:"
    # Long options (all started by --). Those requiring argument followed by =
    long_opts = ["help", "version", "debug", "quiet", "profile", "config-file=", 
                 "repo-logfile=", "save-logfile=", "no-parse", "db-user=", "db-password=",
                 "db-hostname=", "db-database=", "db-driver=", "extensions=",
                 "metrics-all", "metrics-noerr"]

    # Default options
    debug = None
    quiet = None
    profile = None
    configfile = None
    no_parse = None
    user = None
    passwd = None
    hostname = None
    database = None
    driver = None
    logfile = None
    save_logfile = None
    extensions = None
    metrics_all = None
    metrics_noerr = None

    try:
        opts, args = getopt.getopt (argv, short_opts, long_opts)
    except getopt.GetoptError, e:
        printerr (str (e))
        return 1

def execute_statement(statement, parameters, cursor, db, error_message, 
                      exception=Exception):
    """Run a statement. Note that the cursor is *mutable*, and will contain
        the results after running.
    """
        
    if isinstance(db, SqliteDatabase):
        import sqlite3.dbapi2
        
        try:
            return cursor.execute(statement, parameters)
        except sqlite3.dbapi2.OperationalError as e:
            printerr(error_message + ": %s", (e,))
        except Exception as e:
            raise exception(e)

    elif isinstance(db, MysqlDatabase):
        import _mysql_exceptions
    
        try:
            return cursor.execute(statement, parameters)
        except _mysql_exceptions.OperationalError as e:
            printerr(error_message + ": %s", (e,))
        except Exception as e:
            raise exception(e)

 def run_extension (self, name, extension, repo, uri, db):
     printout ("Executing extension %s", (name,))
     try:
         extension.run (repo, uri, db)
     except ExtensionRunError, e:
         printerr ("Error running extension %s: %s", (name, str (e)))
         return False

    def __init__(self, exts, hard_order=False):
        self.exts = {}
        self.hard_order = hard_order
        order = 0

        for ext in exts:
            name = ext
            
            if hard_order:
                name = str(order) + name
                order = order + 1
                
            try:
                self.exts[name] = get_extension(ext)
            except ExtensionUnknownError,e:
                printerr("Error importing extenstion %s: %s", (name, str(e)))                
                raise InvalidExtension(ext)

            # Add dependencies
            if not hard_order:
                for dep in self.exts[ext].deps:
                    if dep not in self.exts.keys():
                        try:
                            self.exts[dep] = get_extension(dep)
                        except:
                            raise InvalidDependency(ext, dep)

    def log_file_is_bzr (logfile):
        retval = False

        try:
            f = open (logfile, 'r')
        except IOError, e:
            printerr (str (e))
            return False

    def run_extension(self, name, extension, change_file,understand_file,stat_file,rank_file,changemetric_file,predict_file,change_type):
        # Trim off the ordering numeral before printing

        try:
            extension.run(change_file,understand_file,stat_file,rank_file,changemetric_file,predict_file,change_type)
        except ExtensionRunError, e:
            printerr("Error running extension %s: %s", (name, str(e)))
            return False

def _get_extensions_manager(extensions, hard_order=False):
    try:
        printdbg("Starting ExtensionsManager")
        emg = ExtensionsManager(extensions,
                                hard_order=hard_order)
        return emg
    except InvalidExtension, e:
        printerr("Invalid extension %s", (e.name,))
        sys.exit(1)

    def run_extension(self, name, extension, repo, uri, db):
        # Trim off the ordering numeral before printing
        if self.hard_order:
            name = name[1:]

        printout("Executing extension %s", (name,))
        try:
            extension.run(repo, uri, db)
        except ExtensionRunError, e:
            printerr("Error running extension %s: %s", (name, str(e)))
            return False

 def backout_extension(self, name, extension, repo, uri, db):
     # Trim off the ordering numeral before printing
     if self.hard_order:
         name = name[1:]
         
     printout("Backing out extension %s", (name,))
     
     try:
         extension.backout(repo, uri, db)
     except (ExtensionRunError, ExtensionBackoutError), e:
         printerr("Error backing out extension %s: %s", (name, str(e)))
         return False

def main():
    """
    """
    # Note: Default values for options are defined in
    # configuration module
    usage = 'Usage: %prog [options]'

    try:
        Config.set_config_options(usage)
    except (ErrorLoadingConfig, InvalidConfig), e:
        printerr(str(e))
        sys.exit(2)

def create_parser_from_repository (repo):
    if repo.get_type () == 'cvs':
        p = CVSParser ()
    elif repo.get_type () == 'svn':
        p = SVNParser ()
    elif repo.get_type () == 'git':
        p = GitParser ()
    elif repo.get_type () == 'bzr':
        p = BzrParser ()
    else:
        printerr ("Error: Unsupported repository type: %s", (repo.get_type (),))
        return None

    return p

def main():
    """
    """
    # Note: Default values for options are defined in
    # configuration module
    usage = 'Usage: %prog [options]'

    # This s
    logging.basicConfig(level=logging.INFO,format='%(asctime)s %(message)s')

    try:
        Config.set_config_options(usage)
    except (ErrorLoadingConfig, InvalidConfig), e:
        printerr(str(e))
        sys.exit(2)

 def __init__(self, db, repo, uri, connection):
     self.db = db
     self.repo = repo
     self.uri = uri
     self.connection = connection
     
     cursor = self.connection.cursor()
     
     try:
         self.repo_id = get_repo_id(self.uri, cursor, self.db)
     except RepoNotFound:
         # Repository not found, probably already backed out
         printerr("Repository not found, is it in the database?")
         self.repo_id = None
     finally:
         cursor.close()

def main(argv):
    # Short (one letter) options. Those requiring argument followed by :
    short_opts = "hVgqbnf:l:s:u:p:d:H:"
    # Long options (all started by --). Those requiring argument followed by =
    long_opts = ["help", "version", "debug", "quiet", "profile",
                 "config-file=", "repo-logfile=", "save-logfile=",
                 "no-parse", "db-user=", "db-password=", "db-hostname=",
                 "db-database=", "db-driver=", "extensions=", "hard-order",
                 "metrics-all", "metrics-noerr", "no-content", "branch=",
                 "backout", "low-memory", "count-types=", "analyze-merges",
                 "hb-ignore-comments", "bugfixregexes=", "bugfixregexes-case=",
                 "dot-dir="]

    # Default options
    debug = None
    quiet = None
    profile = None
    configfile = None
    no_parse = None
    user = None
    passwd = None
    hostname = None
    database = None
    driver = None
    logfile = None
    save_logfile = None
    extensions = None
    metrics_all = None
    metrics_noerr = None
    hard_order = None
    low_memory = None
    no_content = None
    branch = None
    backout = None
    count_types = None
    analyze_merges = None
    hb_ignore_comments = None
    bug_fix_regexes = None
    bug_fix_regexes_case_sensitive = None
    dot_dir = None

    try:
        opts, args = getopt.getopt(argv, short_opts, long_opts)
    except getopt.GetoptError, e:
        printerr(str(e))
        return 1