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

def blame(filename, args):
    repo, uri, out, opts = args
    filename = filename.strip(" \n")

    if filename[-1] == "/":
        return

    p = create_parser(repo.get_type(), filename)
    p.set_output_device(out)

    def feed(line, p):
        p.feed(line)

    wid = repo.add_watch(BLAME, feed, p)
    try:
        repo.blame(os.path.join(uri, filename), rev=opts.revision, mc=not opts.fast)
    except RepositoryCommandError, e:
        printerr("Error getting blame information of path '%s': %s", (filename, e.error))

def execute_statement(statement, parameters, write_cursor, db, error_message, exception=Exception):
    if isinstance(db, SqliteDatabase):
        import sqlite3.dbapi2
        
        try:
            write_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:
            write_cursor.execute(statement, parameters)
        except _mysql_exceptions.OperationalError as e:
            printerr(error_message + ": %s", (e,))
        except Exception as e:
            raise exception(e)

        elif opt in ("--metrics-noerr", ):
            metrics_noerr = True

    if len (args) <= 0:
        uri = os.getcwd ()
    else:
        uri = args[0]

    config = Config ()
    try:
        if configfile is not None:
            config.load_from_file (configfile)
        else:
            config.load ()
    except ErrorLoadingConfig, e:
        printerr (e.message)
        return 1

    if debug is not None:
        config.debug = debug
    if quiet is not None:
        config.quiet = quiet
    if profile is not None:
        config.profile = profile
    if logfile is not None:
        config.repo_logfile = logfile
    if save_logfile is not None:
        config.save_logfile = save_logfile
    if no_parse is not None:
        config.no_parse = no_parse
    if driver is not None:

    """
    """
    # 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)

    try:
        backend = Backend.create_backend(Config.backend)
    except ImportError, e:
        printerr("Backend ''" + Config.backend + "'' doesn't exist. " + str(e))
        sys.exit(2)
    printdbg("Bicho object created, options and backend initialized")
    backend.run()

    if Config.logtable:
        try:
            ilogger = IssueLogger.create_logger(Config.backend)
        except ImportError, e:
            printerr("Logger ''" + Config.backend + "'' doesn't exist. " + str(e))
            sys.exit(2)
        printdbg("Bicho logger object created")
        ilogger.run()

if __name__ == "__main__":
    main()

 def start(self, new_line_cb, user_data=None):
     if self.logfile is not None:
         try:
             self._read_from_logfile(new_line_cb, user_data)
         except IOError, e:
             printerr(str(e))