URLs prefixes with hg+https://, svn+https://, git+https:// should work: https://github.com/vcs-python/vcspull/blob/v1.13.0a11/tests/fixtures/example.py

These are needed by vcspull for detecting repo type

Ramp up type safety strength

https://mypy.readthedocs.io/en/stable/config_file.html#configuring-warnings
https://mypy.readthedocs.io/en/stable/config_file.html#examples

warn_return_any = True
warn_unused_ignores = True
... more

Using only Python 3 would make this much easier since there's access to Pathlib and type hints

https://git-scm.com/docs/git-config

This isn't needed and it additional overhead

GitRepo

• clone
  • --template
  • --bare
  • --mirror
  • --no-hard-links
  • --recursive-submodules
  • .. etc
• pull

Differences from GitPython:

• libvcs.git.GitRepo vs https://gitpython.readthedocs.io/en/3.1.27/reference.html#git.repo.base.Repo.clone

  • libvcs will attempt to match git(1)'s commands flags closely as possible
  • explicit kwargs to make autocompletion easier

• libvcs.git.GitRepo.progress_call is similar to https://gitpython.readthedocs.io/en/3.1.27/reference.html#git.repo.base.Repo.clone's process

https://git-scm.com/docs/git-add

tox.ini looks abandoned. I'll try to revive it.

https://git-scm.com/docs/git-branch

https://git-scm.com/docs/git-ls-files

#362

vcs-python/vcspull#362

subprocess executes immediately. it should be possible to pass this around and defer to run() or execute()

• subprocess
• to the extent possible, annotate and pass through to the standard library
• the instantiated wrapper class should

  • allow introspection

  • mutability

  • terraria dreamworld:

    • potentially an option to freeze
      • tamper-proof object (is such a thing possible?)
• ...

Hi,

i tried to install the package for development as documented in https://github.com/vcs-python/libvcs/blob/master/docs/developing.md.
Tests are currently failing. Can anyone take a look what's wrong please?

https://git-scm.com/docs/git-mv

re: https://stackoverflow.com/questions/72424748/myst-parser-auto-linking-linkifying-references-to-bug-tracker-issues

I wish I could just use link to #341 as #341 in MyST-Parser. To stay in scope I removed autodoc roles. Here is what it looks like when copy pasting (a lot of work to dredge out the issues):

libvcs 0.13.0 (unreleased)

Breaking changes

• {issue}343: libvcs.cmd.core (including ~libvcs._internal.run.run) have been moved to
  libvcs._internal.run. It will be supported as an unstable, internal API.

• {issue}361: ~libvcs._internal.run.run's params are now a pass-through to
  subprocess.Popen.

  • run(cmd, ...) is now run(args, ...) to match Popen's convention.

What's new

• Commands: Experimental command wrappers added ({issue}346):

  • libvcs.cmd.git.Git

    • libvcs.cmd.git.Git.help
    • libvcs.cmd.git.Git.reset
    • libvcs.cmd.git.Git.checkout
    • libvcs.cmd.git.Git.status
    • libvcs.cmd.git.Git.config via {issue}360

• Command: Now support -C (which accepts .git dirs, see git's manual) in addition to cwd
  (subprocess-passthrough), {issue}360

Bug fixes

• Fix argument input for git commands, e.g. git config --get color.diff would not properly
  pass-through to subprocess. {issue}360

Internals

• {issue}345 libvcs.utils -> libvcs._internal to make it more obvious the APIs are strictly
  closed.

• StrOrPath -> StrPath

• {issue}336: ~libvcs._internal.subprocess.SubprocessCommand: Encapsulated
  subprocess call in a dataclasses.dataclass for introspecting, modifying, mocking
  and controlling execution.

• Dataclass helper: ~libvcs._internal.dataclasses.SkipDefaultFieldsReprMixin

  Skip default fields in object representations.

  Credit: Pietro Oldrati, 2022-05-08,
  StackOverflow Post

Documentation

• Document libvcs.types

I need a way to add a push URL. At the moment at
https://github.com/vcs-python/libvcs/blob/master/libvcs/git.py#L391
it is already possible to add an URL or overwrite one. But the --push parameter is not supported (see https://git-scm.com/docs/git-remote).
I would like to be able do something like:

repo.set_remote("origin", "some-url", push=True)

I can provide an PR if this is something considered for merge.

Settle on this for vcs-python/vcspull#362

Should be a dict pass-through

https://git-scm.com/docs/git-log

Implement it like this:

pytest_plugins = ("libvcs.testing.fixtures",)

example from https://github.com/chrisjsewell/sphinx-pytest, via sphinx.tests

As well as #1, a factory object for normal vcs URL's

These are MIT licensed python parts. You're welcome to copy them and augment them in your project as you see fit.

However, they're not supported. Maintainers can break these APIs between patch releases without warning (no deprecation policy).

If you find something in here useful, feel free to file an issue that'd you find it helpful to stabilize the API or see it in a project of its own. Also as it's MIT licensed, you can make your own package based on it at any time.

Precondition: #293 is applied.

Expected: If one passes an pipurl with a ...@some-branch the branch should be picked.

Current behavior: It does not checkout the branch, but instead rebases the remote branch into master (or main). Which sometimes fails, dependent if there are conflicts or not. Anyway, the result is wrong.

Solution: Checkout the remote branch before rebase.

readthedocs/sphinx-autoapi#202
https://github.com/aaugustin/websockets/blob/778a1ca6936ac67e7a3fe1bbe585db2eafeaa515/docs/conf.py#L100-L134

Move instances of tmpdir aka py.path.local to tmp_path pathlib.Path from stdlib

companion: vcs-python/vcspull#350

Inspiration: https://wiki.archlinux.org/index.php/VCS_package_guidelines

Other ideas:

• Allow registering regex's on startups (sort of similar to how mimetypes initializes as a singleton. And it also allows adding more types at runtime
• have group regexes catch
• Have vcs detection hint callbacks (and registry). For cases where a vcs is a certain time, a detection callback for having a git/ directory is a sign its a probably git repo. If it has common git-like files, it may be a bare git repo

This allows a directory to be given and a guess of what repo it is

but also its enough to just use the plain old repo object

Default behavior is the same

Executors:

• Default: run() w/ a pass-through to show real time stderr of progress

• subprocess.run pass-through

• SubprocessCommand generates functions in dataclasses you can invoke later

  Rather than immediately running a SubprocessCommand, you can introspect, pickle it, adjust it, etc.

  Git(executor=SubprocessCommand)

• Bring your own

  If you're not satisfied and don't think a PR will do, create your own executor class.

  If you do, you may want to either 1.) override the class's #run() or 2.) pass a run_fn to override it.

https://git-scm.com/docs/git-grep

We need a way to return a list of objects. Should be:

• Simplicity over performance
• Not meant for speed. ~100 objects.
• Iterable as a list through a for loop
• Iterable as a dictionary (pk, obj) via .items()
• Support direct lookups via a pk (e.g. git remote name)
• Support any (fixed) type of list item
• Type annotated

Nice to have:

• Should be comparable to other queryset objects

  Including inner data, if possible

• One file

• Simple

• #318 libvcs.states
• #319

I wrote this in 2013 when I was new to python programming. I am looking back
surprised at myself:

"I wrote that?".

Over the next releases, you will see two things:

• libvcs.cmd: Lite, pythonic, typed wrapper for git, hg, etc.
• libvcs.states: Re-run friendly checkout / update tool for repos, comparable to fabtools.require.git, salt.states.git, ansible.builtin.git

And maybe, libvcs.contrib for pip-style URLs (or it'll become a gist)

The bot created this issue to inform you that pyup.io has been set up on this repo.
Once you have closed it, the bot will open pull requests for updates as soon as they are available.

requires #337

• run() should convert to Popen params for compatibility with SubprocessCommand

• run() should support legacy_params (existing) to deprecate safely

class CommandPopenMixin:
    _run_fn = Subprocess.Popen


class CommandRunMixin:
    _run_fn = Subprocess.run

class Command:
    _run_fn = SubprocessCommand




class Command:
    _run_fn = SubprocessCommand

This turns git command into a subprocess command factory:

class Git(Command):
   ...


git_factory = Git(url='...')
status_cmd = git_factory.status()
status_cmd.run()
status_cmd.Popen()

Subprocess.Popen
Subprocess.run

Expected: If one passes an pipurl with a ...@some-branch the branch should be picked.

Current behavior: It ignores the given branch and uses the default branch (like master or main).

Analysis:

• rev is parsed correctly
• rev is passed to the specialized classes constructor as kwarg, i.e. for Git.
• from there rev is passed to the base class constructor as kwarg.
• In the base class constructor all kwargs are ignored.

Solution:
If a kwargs rev is passed to the base constructor, stored it as an instance variable.

It is convenient for used of the libvcs to (optionally) be able to report progress.

It used to be reported with vcspull, which approach would you recommend to "restore" this behavior ?

I was initially thinking about having a report_progress_callback parameter initially set to None

There are already few packages specialized in handling interaction with these repository:

• https://pypi.python.org/pypi/svn
• https://pypi.python.org/pypi/GitPython/
• https://pypi.python.org/pypi/python-hglib

I wonder if libvcs should make use of them ?

It is also nice to keep libvcs as a light wrapper on top of the executable.

In the FAQ, user could be guided to use these more specialized package once the source are checked out by libvcs ?

https://git-scm.com/docs/git-rm

https://git-scm.com/docs/git-reflog

no_<flag>=True/FalseNone + <flag>=True/False/None to flag=True/False

e.g. no_refresh + refresh -> refresh=True/False/None

Inspiration

https://github.com/cihai/unihan-etl/blob/v0.14.0a0/unihan_etl/expansion.py

We should detect pip, npm, github/gitlab, golang, rust (cargo), gem, etc styles of vcs urls

Since pip URLs are incompatible with plain-old git URLs we need this

Incompatible with git(1): git+ssh, etc. URL, and revs, e.g. @branch-name

Git <- Shell object, wraps subprocess commands and a cwd
GitDriver <- High level tool for setting state, cloning data
Repo <- one class, implements a driver so multiple vcs can be managed via one command

just like libtmux, git/svn/etc should have params that imitate actual shell commands

e.g. for a GitRepo: repo.pull, repo.clone

Git can be used to be a subprocess wrapper around a config and a cwd.

GitDriver invokes Git's commands to in a Repo object.

GitDriver can be used to accept path_hint / something else to see if a working directory is a git directory or not.

GitDriver can also accept a scan function to pull directories that are git repos

Repo registers drivers on startups

This way Repo can iterate through drivers to see if a directory is a certain vcs

And Repo can be a generic object that can connect to a vcs