def init_repository(url=None):
  """Creates a new Gitless's repository in the cwd.

  Args:
    url: if given the local repository will be a clone of the remote repository
      given by this url.
  """
  cwd = os.getcwd()
  try:
    pygit2.discover_repository(cwd)
    raise GlError('You are already in a Gitless repository')
  except KeyError:  # Expected
    if not url:
      repo = pygit2.init_repository(cwd)
      # We also create an initial root commit
      git.commit(allow_empty=True, m='Initialize repository')
      return repo

    try:
      git.clone(url, cwd)
    except ErrorReturnCode as e:
      raise GlError(stderr(e))

    # We get all remote branches as well and create local equivalents
    repo = Repository()
    remote = repo.remotes['origin']
    for rb in (remote.lookup_branch(bn) for bn in remote.listall_branches()):
      if rb.branch_name == 'master':
        continue
      new_b = repo.create_branch(rb.branch_name, rb.head)
      new_b.upstream = rb
    return repo

 def is_repository(directory):
     """Checks if the repository is a VCS repository"""
     try:
         pygit2.discover_repository(path_join(directory))
         return True
     except KeyError:
         return False

def clone(location):
    """
    Clone a Git repository if it doesn't exist into a temporary directory.

    :param str location: the Git URL to clone
    :rtype: pygit2.Repository
    """
    path = join(config.CLONE_ROOT, _simple_location_name(location))

    log.info('Cloning to path {}'.format(path))

    try:
        log.info('Looking for existing repository')
        repository_path = discover_repository(path)
    except KeyError:
        log.info('No existing repository found, cloning fresh')
        return clone_repository(location, path)
    else:
        log.info('Repository already exists at {}'.format(repository_path))
        repository = Repository(repository_path)

        remote = repository.remotes[0]
        remote.sideband_progress = log.info

        log.info('Fetching to get the latest objects from remote')
        remote.fetch()

        return repository

def analyze(url, api_token):
    github_url = url.strip().replace("http://www.github.com/", "")
    github_url = github_url.strip().replace("https://www.github.com/", "")
    github_url = github_url.strip().replace("http://github.com/", "")
    github_url = github_url.strip().replace("https://github.com/", "")

    print("Start analyzing: %s" % github_url)
    start_time = time.perf_counter()

    g = Github(api_token)
    repo = g.get_repo(github_url)

    stats = open(os.path.join("github", repo.owner.login + "-" + repo.name), "w")
    stats.write("forks;branches;watchers;stars\n")
    stats.write("%d;%d;%d;%d\n"
                % (repo.forks_count, len(list(repo.get_branches())),
                   repo.watchers_count, repo.stargazers_count))
    stats.flush()
    stats.close()

    repo_path = os.path.join(os.getcwd(), "git", repo.owner.login, repo.name)

    # initialize repo
    if os.path.exists(repo_path):
        cloned_repo = Repository(discover_repository(repo_path))
    else:
        cloned_repo = clone_repository(repo.clone_url, repo_path)

    # run churny
    run("churny " + repo_path, os.path.join("overall", repo.owner.login + "-" + repo.name))
    run("churny -m " + repo_path, os.path.join("monthly", repo.owner.login + "-" + repo.name))

    elapsed_time = time.perf_counter() - start_time
    print("Stop analyzing: %s (%d s)" % (github_url, elapsed_time))

    def __init__(self, repo_url, dir_manager, credentials_manager):
        """
        :repo_url: URL of the repository
        :repo_dir: directory where the repository is expected to reside
        """
        self.up2date = False
        self.repo_url = repo_url
        dir_path = dir_manager.get_repo_dir(repo_url)

        my_credentials = credentials_manager.get_credentials(repo_url)

        if not os.path.isfile(dir_path + '/HEAD'):
            try:
                self.repo = pygit2.clone_repository(repo_url, dir_path, bare=True, credentials=my_credentials)
            except pygit2.GitError as e:
                raise GitException("Cloning failed. {}".format(e.message))
        else:
            self.repo = pygit2.Repository(pygit2.discover_repository(dir_path))
            self.up2date = True

            def _remote_credentials(url, username_from_url, allowed_types):
                return credentials_manager.get_credentials(url)

            for remote in self.repo.remotes:
                remote.credentials = _remote_credentials
                transfer_progress = remote.fetch()
                if transfer_progress.received_objects:
                    self.up2date = False

    def init(self):
        if pygit2 is None:
            self.text = glyphs.BRANCH + ' ' + glyphs.WRITE_ONLY
            self.bg = colors.background(colors.RED)
            self.fg = colors.foreground(colors.WHITE)
            return

        try:
            repo_path = pygit2.discover_repository(os.getcwd())
            self.repo = pygit2.Repository(repo_path)
        except Exception:
            self.active = False
            return

        branch_name = self.get_branch_name()

        if not branch_name:
            self.active = False
            return

        git_colors = self.get_working_dir_status_decorations()
        self.bg = colors.background(git_colors[0])
        self.fg = colors.foreground(git_colors[1])

        current_commit_text = self.get_current_commit_decoration_text()
        self.text = (glyphs.BRANCH + ' ' + branch_name + ' ' + current_commit_text).strip()

def dendrifier_for_path(dirname, _ceiling_dir_for_testing='', report_to_stdout=False):
    try:
        repo = git.discover_repository(dirname, False, _ceiling_dir_for_testing)
    except KeyError:
        raise ValueError('could not find git repo starting from {}'.format(dirname))
    kwargs = {'report': dendrify.ReportToStdout()} if report_to_stdout else {}
    return dendrify.Dendrifier(repo, **kwargs)

    def GitableDir(path):

        """

        A directory in which you can do Git things -- i.e. a git
        repository or a subdirectory of a checked_out repository.

        Parameters:
          path (string): A path name.  \"~\"-expansion will be performed.

        Returns:
          Tuple (supplied path name, absolute path name) upon success

        Raises:
          argparse.ArgumentTypeError if no Git repository is found
        
        """
        
        realpath=os.path.abspath(os.path.expanduser(path))
        if not os.path.isdir(realpath):
            err_str = "'{}' does not exist or is not a directory".format(path)
            raise argparse.ArgumentTypeError(err_str)
        try:
            repo_path=pygit2.discover_repository(realpath)
            return(path,repo_path)
        except KeyError, e:
            err_str = "No Git repo found in {} or its parent dirs".format(e.args[0])
            raise argparse.ArgumentTypeError(err_str)

 def from_cwd(cls):
     """Get the Repository object implied by the current directory."""
     try:
         repo_path = pygit2.discover_repository(os.getcwd())
     except KeyError:
         raise NotARepository("current directory not part of a repository")
     return cls(repo_path)

    def __init__(self):
        try:
            self.repo_dir = git.discover_repository('.')
        except KeyError:
            raise NotInRepoError()

        self.repo = git.Repository(self.repo_dir)
        self.commit = self.repo.head.target.hex
        self.basedir = self.repo.workdir

def _discover_repository(where, *, follow_links=False):
    try:
        repo_path = pygit2.discover_repository(str(where), follow_links)
    except KeyError:
        # KeyError is GIT_ENOTFOUND, which in this case means this doesn't
        # appear to be a repository
        raise NoSuchRepository
    else:
        return Path(repo_path)

def get_repo(path):
    path = os.path.abspath(path)
    os.chdir(path)
    try:
        repo_path = pygit2.discover_repository(path)
        return pygit2.Repository(repo_path)
    except KeyError:
        print("Cannot find a repository in '{}'.".format(path))
        exit(1)

 def _vcs_root(self, path):
     """Find the root of the deepest repository containing path."""
     # Assume that nothing funny is going on; in particular, that we aren't
     # dealing with a bare repo.
     gitdir = _pygit2.discover_repository(path)
     self._pygit_repository = _pygit2.Repository(gitdir)
     dirname,tip = os.path.split(gitdir)
     if tip == '':  # split('x/y/z/.git/') == ('x/y/z/.git', '')
         dirname,tip = os.path.split(dirname)
     assert tip == '.git', tip
     return dirname

    def __init__(self, context, repo_path=None):
        self.context = context
        rp = IStorageInfo(context).path

        try:
            self.repo = Repository(discover_repository(rp))
        except KeyError:
            # discover_repository may have failed.
            raise PathNotFoundError('repository does not exist at path')

        self.checkout()  # defaults to HEAD.

def set_repository(value):
    from pygit2 import discover_repository, Repository
    global _repository
    if value is None:
        _repository = None
        return
    try:
        path = discover_repository(value)
    except KeyError:
        raise GitError('no repository found in "{}"'.format(value))
    _repository = Repository(path)

  def __init__(self):
    """Create a Repository out of the current working repository."""
    try:
      path = pygit2.discover_repository(os.getcwd())
    except KeyError:
      raise NotInRepoError('You are not in a Gitless\'s repository')

    self.git_repo = pygit2.Repository(path)
    self.remotes = RemoteCollection(self.git_repo.remotes, self)
    self.path = self.git_repo.path
    self.root = self.path[:-6]  # strip trailing /.git/
    self.config = self.git_repo.config

  def do_git(self, update = False):
    # TODO: Write support for [email protected] or [email protected]
    if (not (os.path.exists(self.path))):
      repo = pygit2.clone_repository(self.url[4:], self.path)
    else:
      repo = pygit2.Repository(pygit2.discover_repository(self.path))

    if (update):
      repo.remotes[0].fetch()
      repo.create_reference('refs/remotes/origin/master', 'refs/heads/master', True)
      repo.checkout_head()
    return repo

    def add_snapshot(self, path):
        try:
            repo = git.discover_repository(path)
        except KeyError:
            pass
        else:
            raise KeyError("path `{0}' already belongs to a git repository: {1}".format(path, repo))

        # TODO warning message: shared repo
        stat = subprocess.call(["git", "clone", "--shared", self.repo.workdir, path])
        assert stat == 0
        self.snapshots.append(os.path.realpath(path))

 def __init__(self, path):
     """
     Initialize the Repository instance in the given path. The directory
     under path has to contain .git.
     @type path: str
     @raise NotAGitRepoError: The given path is not a git directory.
     """
     self.path = path
     try:
         gitdir = pygit2.discover_repository(path)
         self.repo = pygit2.Repository(gitdir)
     except KeyError:
         raise NotAGitRepoError("Not a git repository: %s" % path)

def clone_or_update_repo(github_repo, account, target_path):
    if not os.path.exists(target_path + '/.git/'):
        try:
            return pygit2.clone_repository(github_repo.clone_url, target_path,
                                           credentials=account.credentials)
        except pygit2.GitError as e:
            raise GitException("Cloning failed. {}".format(e.message))
    else:
        repo = pygit2.Repository(pygit2.discover_repository(target_path))
        for remote in repo.remotes:
            remote.credentials = _credential_lambda(account)
            transfer_progress = remote.fetch()
        return repo