Posted  by  admin

Download Git Annex For Mac 0.0.1

In a previous post I gave virtual environments as a solution to the problem of dependency and version collision for software built using languages like Python, Ruby, Node.js, and Go.

Example of configuration file (specified by the '-f' option): # Virtual Interface List IF:S0:udp:10001:127.0.0.1:10000 IF:S1:udp:10002:127.0.0.1:10003 # DLCI switching between S0 and S1 VC:S0:200:S1:100 VC:S1 💯 S0:200 In this example, we have 2 virtual interfaces, S0 and S1. The syntax for interface definition is similar to Port Adapters: IF. Download AUR Home; Packages. Annex-git: r13.4482dd2-1: 1: 0.03. Simple appstore for gnome shell extensions. Zom: i3lock-cac03-git: 2bfcb7-2: 2: 0.00: An.

  • The most popular version among the program users is 0.0. This program's bundle is identified as com.branchable.git-annex. The most frequent installer filename for the program is: git-annex.dmg.bz2. You can execute git-annex on Mac OS X 10.5 or later. This free Mac application was originally developed by Joey Hess.
  • By default, git-annex only makes connections to public IP addresses; it will refuse to use HTTP and other servers on localhost or on a private network. This setting can override that behavior, allowing access to particular IP addresses that would normally be blocked. For example '127.0.0.1::1' allows access to localhost (both IPV4 and IPV6).

In this post I give the details and examples of using the Python virtual environment. First I walk through everything using OS X–i.e., using a Mac–and then, briefly, I describe the same procedures using Windows.

  • Python virtual environments on Windows

Python installation (OS X)

Product

Python is, typically, installed side by side on a system at the granularity of major and minor releases. For example, on my OS X system I use the package manager1MacPorts to install new versions of Python. MacPorts installs all its software under the top level directory /opt. Here are all the Python versions currently installed on my OS X system via MacPorts:

OS X comes with Python already installed. I’m still running Mavericks, a.k.a. OS X 10.9.5, and that ships with Python 2.7.5. Usually Apple does not update the system version of Python, and so my system will remain at 2.7.5 (circa 2013) as long as I keep it running Mavericks (also circa 2013).

As you can tell from the directly listing above, I’ve used MacPorts to independently install Python versions 2.7, 3.3, 3.4, and 3.5. Another way to see that is by asking MacPorts to list the Python packages:

I installed each of those using a command like:

or

The various python_select packages come along with any MacPorts Python package. They provide a command you can use to change the default python package to one selected from the various versions you’ve installed via MacPorts. I don’t use python_select because I find using virtual environments to be a better mechanism.

Creating a python virtual environment

The Python port maintainers at MacPorts are pretty good about upgrades, and so the Python 2.7 installed in the /opt tree is likely to be recent. To check that, let’s create a virtual environment for Python 2.7 from MacPorts.

  1. Open a terminal window and create an empty directory somewhere–I called mine “using-python-venv”–and cd into it.

  2. Check the path to the Python binary and the Python version. This will be whatever is the default on your system.

  3. Save a record of all the current environment variables (so we can see what changes when the virtual environment is activated) using this command:

  4. Create the virtual environment deployment directory using this command:[^venvdir]

    Note: the path will be different with Fink or Homebrew. If you are using either of those package managers, you’ll need to locate the Python 2.7 installation directory to be used in the command.

Activating and deactiving the virtual environment

  1. Activate the virtual environment using this “source” command:

    Notice that the command prompt now has a parenthetical prefix that shows the active virtual environment deployment directory.

  2. Save a record of the new environment variables:

  3. Check the python path and version version

  4. Deactivate the virtual environment using the deactivate command:

    Notice that the command prompt changed to no longer shows the virtual environment deployment directory. And if you try the deactivate command again, you’ll get a command not found error.

  5. Diff the original (default) environment against the new environment to see what changed when the Python virtual environment was activated:

    Here’s the diff output looked like on my system; I used the command diff orig.env.txt venv27.env.txt:

    As you can see, activating the virtual environment has an effect. A new environment variable, VIRTUAL_ENV, is created and identifies the location of the Python deployment directory. The $PATH is changed to have the virtual Python environment searched first. And the command line prompt is changed to indicate which Python virtual environment deployment directory is active.

Virtual environment creation in Python 3.3 and later

The virtual environment mechanism is built in to the Python Library in Python version 3.3. and later, in the venv module. The command to create the virtual environment using the venv module would be:

However, on my Mac using the MacPorts distribution of Python 3.3, the virtual environment that is created has no packages whatsoever. Specifically, it does not have setuptools or pip, and both those tools are immensely useful.2

So I continue to use the virtualenv command, even with Python 3.3 and later, when on my Mac.3 The command to create a 3.3 virtual environment that way is:

Activating the 3.3 virtual environment created with virtualenv, and using the pip list command confirms the presence of setuptools and pip (albeit slightly outdated).

Adding packages to the virtual environment

When the virtual environment is active you can install packages an not be concerned about polluting the global Python environment or breaking dependencies for any other project or any application installed on the system.

The first thing I usually do after creating a new virtual environment is to activate it and update setuptools and pip.

And now you can install any other packages you need.

Key Features of virtual environments

With these basic steps I have demonstrated the key characteristics of a virtual environment for a project or application. These characteristics are common to all virtual environments, not just for Python.

Virtual environments have:

  • A local, mutable, deployment directory for the execution environment that is independent of the global (system) environment.

    With Python, this is accomplished with the virtualenv utility or the venv module to create and provision a local deployment directory.

  • An activation mechanism for standing up the virtual environment—for switching an execution context to use the local deployment directory preferentially ahead of the global environment, or masking the global environment.

    With Python virtual environments, this is accomplished using the activate script4 to change the search path to look in the local deployment directory before looking in other locations. The acivate script also generates the deactivate script, changes the CLI prompt to signal that the virtual environment is activate, and adds a special VIRTUAL_ENV environment variable to aid virtual environment support in Python itself and in project or application scripting.

  • A deactivation mechanism for standing down the virtual environment—for switching the execution context back to using the global environment and ignoring the deployment directory.

    As mentioned above, Python virtual environments generate a deactivate script to accomplish this. The script self-deletes when executed.

Next steps

In the next post I’ll discuss how to do upgrades of dependencies to pick up patches without picking up major or minor upgrades, how to test for the correct virtual environment and dependency versions in script (e.g. test scripts, build scripts), and how to provision the virtual environment from a list of known dependencies.

Python virtual environments on Windows

Using Python on Windows is only slightly different, but worth describing. In this post I’ll use the standard command window. In the next post I’ll switch to Powershell.

(Windows) Installing Python

Python install kits are available here: https://www.python.org/downloads/windows/. I’ll be using only the 64-bit installers in these examples.

Python 2 and older Python 3 installers use a root directory as the default install location (e.g. C:Python27 or C:Python33). Starting with Python 3.5, the installer places Python in the Program Files directory. I like that; it’s in keeping with traditional Windows software installation practices. So when I use the older installers, I change the install directory to match the new convention.

Here’s how to install Python 2.7, create a virtual environment, activate it, update it, and deactivate it from a Command window.

  1. Install Python 2.7.11 from the python-2.7.11.amd64.msi installer.

  2. When prompted for the install path, set it to C:Program FilesPython 2.7.

  3. After installing, open a command window using “Run as administrator …” and enter these commands:

  4. Open a new command window (without using “Run as administrator …”) and create a virtual environment inside a new directory using:

  5. Activate the virtual environment using:

  6. Check the version and upgrade setuptools and pip:

  7. Deactivate the virtual environment using:

Installing Python 3.3 and later is similar, except that the virtual environment is created using the venv module.

  1. Install Python 3.4.4 from the python-3.4.4.amd64.msi installer.

  2. When prompted for the install path, set it to C:Program FilesPython 3.4.

  3. After installing, open a command window using “Run as administrator …” and enter these commands:

  4. Open a new command window (without using “Run as administrator …”) and create a virtual environment inside a new directory using:

  5. Activate the virtual environment using:

  6. Check the version and upgrade setuptools and pip:

  7. Deactivate the virtual environment using:

Next steps (reiterated)

In the next post I’ll discuss how to do upgrades of dependencies to pick up patches without picking up major or minor upgrades, how to test for the correct virtual environment and dependency versions in script (e.g. test scripts, build scripts), and how to provision the virtual environment from a list of known dependencies.

  1. There are three popular package managers for OS X. MacPorts, HomeBrew, and Fink. All three work well. But I prefer MacPorts or Fink to HomeBrew because both MacPorts and Fink install into alternative directory trees and do not replace or modify the system as originally laid down by Apple. HomeBrew, on the other hand, resets permissions on system files (dangerously giving the current user write authority into privileged locations) and installs into system folders (which can cause issues during operating system upgrades). In short, I view HomeBrew as more intrusive, less stable, and less secure than MacPorts or Fink. ↩

  2. You could still use the venv module and just download the source for setuptools and build it, then use that to download and install pip. I just find the virtualenv utility more expedient. ↩

  3. The situation is different for Windows, as is seen later in this post I use the venv module to create Python 3.3 (or later) virtual environments on Windows. ↩

  4. The activation script is executed via a source command on Unix-like systems, and directly as a batch file or Powershell script on Windows systems. ↩

git-annex - manage files with git, without checking their contents in

git annex command [params ...]

git-annex allows managing files with git, without checking the filecontents into git. While that may seem paradoxical, it is useful whendealing with files larger than git can currently easily handle, whether dueto limitations in memory, checksumming time, or disk space.

Even without file content tracking, being able to manage files with git,move files around and delete files with versioned directory trees, and usebranches and distributed clones, are all very handy reasons to use git. Andannexed files can co-exist in the same git repository with regularlyversioned files, which is convenient for maintaining documents, Makefiles,etc that are associated with annexed files but that benefit from fullrevision control.

When a file is annexed, its content is moved into a key-value store, anda symlink is made that points to the content. These symlinks are checked intogit and versioned like regular files. You can move them around, deletethem, and so on. Pushing to another git repository will make git-annexthere aware of the annexed file, and it can be used to retrieve itscontent from the key-value store.

  • help

    Display built-in help.

    For help on a specific command, use git annex help command

  • add [path ...]

    Adds files to the annex.

    See git-annex-add(1) for details.

  • get [path ...]

    Makes the content of annexed files available in this repository.

    See git-annex-get(1) for details.

  • drop [path ...]

    Drops the content of annexed files from this repository.

    See git-annex-drop(1) for details.

  • move [path ...] [--from=remote --to=remote]

    Moves the content of files from or to another remote.

    See git-annex-move(1) for details.

  • copy [path ...] [--from=remote --to=remote]

    Copies the content of files from or to another remote.

    See git-annex-copy(1) for details.

  • status [path ...]

    Similar to git status --short, displays the status of the files in theworking tree.

    See git-annex-status(1) for details.

  • unlock [path ...]

    Unlock annexed files for modification.

    See git-annex-unlock(1) for details.

  • edit [path ...]

    This is an alias for the unlock command. May be easier to remember,if you think of this as allowing you to edit an annexed file.

  • lock [path ...]

    Use this to undo an unlock command if you don't want to modifythe files, or have made modifications you want to discard.

    See git-annex-lock(1) for details.

  • sync [remote ...]

    Synchronize local repository with remotes.

    See git-annex-sync(1) for details.

  • mirror [path ...] [--to=remote --from=remote]

    Mirror content of files to/from another repository.

    See git-annex-mirror(1) for details.

  • addurl [url ...]

    Downloads each url to its own file, which is added to the annex.

    See git-annex-addurl(1) for details.

  • rmurl file url

    Record that the file is no longer available at the url.

    See git-annex-rmurl(1) for details.

  • import --from remote branch[:subdir] [path ...]

    Add a tree of files to the repository.

    See git-annex-import(1) for details.

  • importfeed [url ...]

    Imports the contents of podcast feeds into the annex.

    See git-annex-importfeed(1) for details.

  • export treeish --to remote

    Export content to a remote.

    See git-annex-export(1) for details.

  • undo [filename directory] ...

    Undo last change to a file or directory.

    See git-annex-undo(1) for details.

  • multicast

    Multicast file distribution.

    See git-annex-multicast(1) for details.

  • watch

    Watch for changes and autocommit.

    See git-annex-watch(1) for details.

  • assistant

    Automatically sync folders between devices.

    See git-annex-assistant(1) for details.

  • webapp

    Opens a web app, that allows easy setup of a git-annex repository,and control of the git-annex assistant. If the assistant is notalready running, it will be started.

    See git-annex-webapp(1) for details.

  • remotedaemon

    Persistant communication with remotes.

    See git-annex-remotedaemon(1) for details.

  • init [description]

    Until a repository (or one of its remotes) has been initialized,git-annex will refuse to operate on it, to avoid accidentallyusing it in a repository that was not intended to have an annex.

    See git-annex-init(1) for details.

  • describe repository description

    Changes the description of a repository.

    See git-annex-describe(1) for details.

  • initremote name type=value [param=value ...]

    Creates a new special remote, and adds it to .git/config.

    See git-annex-initremote(1) for details.

  • enableremote name [param=value ...]

    Enables use of an existing special remote in the current repository.

    See git-annex-enableremote(1) for details.

  • renameremote

    Renames a special remote.

    See git-annex-renameremote(1) for details.

  • enable-tor

    Sets up tor hidden service.

    See git-annex-enable-tor(1) for details.

  • numcopies [N]

    Configure desired number of copies.

    See git-annex-numcopies(1) for details.

  • mincopies [N]

    Configure minimum number of copies.

    See git-annex-mincopies(1) for details.

  • trust [repository ...]

    Records that a repository is trusted to not unexpectedly losecontent. Use with care.

    See git-annex-trust(1) for details.

  • untrust [repository ...]

    Records that a repository is not trusted and could lose contentat any time.

    See git-annex-untrust(1) for details.

  • semitrust [repository ...]

    Returns a repository to the default semi trusted state.

    See git-annex-semitrust(1) for details.

  • group repository groupname

    Add a repository to a group.

    See git-annex-group(1) for details.

  • ungroup repository groupname

    Removes a repository from a group.

    See git-annex-ungroup(1) for details.

  • wanted repository [expression]

    Get or set preferred content expression.

    See git-annex-wanted(1) for details.

  • groupwanted groupname [expression]

    Get or set groupwanted expression.

    See git-annex-groupwanted(1) for details.

  • required repository [expression]

    Get or set required content expression.

    See git-annex-required(1) for details.

  • schedule repository [expression]

    Get or set scheduled jobs.

    See git-annex-schedule(1) for details.

  • config

    Get and set other configuration stored in git-annex branch.

    See git-annex-config(1) for details.

  • vicfg

    Opens EDITOR on a temp file containing most of the above configurationsettings, as well as a few others, and when it exits, stores any changesmade back to the git-annex branch.

    See git-annex-vicfg(1) for details.

  • adjust

    Switches a repository to use an adjusted branch, which can automaticallyunlock all files, etc.

    See git-annex-adjust(1) for details.

  • direct

    Switches a repository to use direct mode. (deprecated)

    See git-annex-direct(1) for details.

  • indirect

    Switches a repository to use indirect mode. (deprecated)

    See git-annex-indirect(1) for details.

  • fsck [path ...]

    Checks the annex consistency, and warns about or fixes any problems found.This is a good complement to git fsck.

    See git-annex-fsck(1) for details.

  • expire [repository:]time ...

    Expires repositories that have not recently performed an activity(such as a fsck).

    See git-annex-expire(1) for details.

  • unused

    Checks the annex for data that does not correspond to any files presentin any tag or branch, and prints a numbered list of the data.

    See git-annex-unused(1) for details.

  • dropunused [number range ...]

    Drops the data corresponding to the numbers, as listed by the lastgit annex unused

    See git-annex-dropunused(1) for details.

  • addunused [number range ...]

    Adds back files for the content corresponding to the numbers or ranges,as listed by the last git annex unused.

    See git-annex-addunused(1) for details.

  • fix [path ...]

    Fixes up symlinks that have become broken to again point to annexed content.

    See git-annex-fix(1) for details.

  • merge

    Automatically merge changes from remotes.

    See git-annex-merge(1) for details.

  • upgrade

    Upgrades the repository.

    See git-annex-upgrade(1) for details.

  • dead [repository ...] [--key key]

    Indicates that a repository or a single key has been irretrievably lost.

    See git-annex-dead(1) for details.

  • forget

    Causes the git-annex branch to be rewritten, throwing away historicaldata about past locations of files.

    See git-annex-forget(1) for details.

  • filter-branch

    Produces a filtered version of the git-annex branch.

    See git-annex-filter-branch(1) for details.

  • repair

    This can repair many of the problems with git repositories that git fsckdetects, but does not itself fix. It's useful if a repository has becomebadly damaged. One way this can happen is if a repository used by git-annexis on a removable drive that gets unplugged at the wrong time.

    See git-annex-repair(1) for details.

  • p2p

    Configure peer-2-Peer links between repositories.

    See git-annex-p2p(1) for details.

  • find [path ...]

    Outputs a list of annexed files in the specified path. With no path,finds files in the current directory and its subdirectories.

    See git-annex-find(1) for details.

  • whereis [path ...]

    Displays information about where the contents of files are located.

    See git-annex-whereis(1) for details.

  • list [path ...]

    Displays a table of remotes that contain the contents of the specifiedfiles. This is similar to whereis but a more compact display.

    See git-annex-list(1) for details.

  • whereused

    Finds what files use or used a key.

  • log [path ...]

    Displays the location log for the specified file or files,showing each repository they were added to ('+') and removed from ('-').

    See git-annex-log(1) for details.

  • info [directory file remote uuid ...]

    Displays statistics and other information for the specified item,which can be a directory, or a file, or a remote, or the uuid of arepository.

    When no item is specified, displays statistics and informationfor the repository as a whole.

    See git-annex-info(1) for details.

  • version

    Shows the version of git-annex, as well as repository version information.

    See git-annex-version(1) for details.

  • map

    Generate map of repositories.

    See git-annex-map(1) for details.

  • inprogress

    Access files while they're being downloaded.

    See git-annex-inprogress(1) for details.

  • metadata [path ...]

    The content of an annexed file can have any number of metadata fieldsattached to it to describe it. Each metadata field can in turnhave any number of values.

    This command can be used to set metadata, or show the currently setmetadata.

    See git-annex-metadata(1) for details.

  • view [tag ...] [field=value ...] [field=glob ...] [!tag ...] [field!=value ...]

    Uses metadata to build a view branch of the files in the current branch,and checks out the view branch. Only files in the current branch whosemetadata matches all the specified field values and tags will beshown in the view.

    See git-annex-view(1) for details.

  • vpop [N]

    Switches from the currently active view back to the previous view.Or, from the first view back to original branch.

    See git-annex-vpop(1) for details.

  • vfilter [tag ...] [field=value ...] [!tag ...] [field!=value ...]

    Filters the current view to only the files that have thespecified field values and tags.

    See git-annex-vfilter(1) for details.

  • vadd [field=glob ...] [field=value ...] [tag ...]

    Changes the current view, adding an additional level of directoriesto categorize the files.

    See git-annex-vfilter(1) for details.

  • vcycle

    When a view involves nested subdirectories, this cycles the order.

    See git-annex-vcycle(1) for details.

  • migrate [path ...]

    Changes the specified annexed files to use a different key-value backend.

    See git-annex-migrate(1) for details.

  • reinject src dest

    Moves the src file into the annex as the content of the dest file.This can be useful if you have obtained the content of a file fromelsewhere and want to put it in the local annex.

    See git-annex-reinject(1) for details.

  • unannex [path ...]

    Use this to undo an accidental git annex add command. It puts thefile back how it was before the add.

    See git-annex-unannex(1) for details.

  • uninit

    De-initialize git-annex and clean out repository.

    See git-annex-uninit(1) for details.

  • reinit uuid description

    Initialize repository, reusing old UUID.

    See git-annex-reinit(1) for details.

  • pre-commit [path ...]

    This is meant to be called from git's pre-commit hook. git annex initautomatically creates a pre-commit hook using this.

    See git-annex-pre-commit(1) for details.

  • post-receive

    This is meant to be called from git's post-receive hook. git annex initautomatically creates a post-receive hook using this.

    See git-annex-post-receive(1) for details.

  • lookupkey [file ...]

    Looks up key used for file.

    See git-annex-lookupkey(1) for details.

  • calckey [file ...]

    Calculates the key that would be used to refer to a file.

    See git-annex-calckey(1) for details.

  • contentlocation [key ..]

    Looks up location of annexed content for a key.

    See git-annex-contentlocation(1) for details.

  • examinekey [key ...]

    Print information that can be determined purely by looking at the key.

    See git-annex-examinekey(1) for details.

  • matchexpression

    Checks if a preferred content expression matches provided data.

    See git-annex-matchexpression(1) for details.

  • fromkey [key file]

    Manually set up a file in the git repository to link to a specified key.

    See git-annex-fromkey(1) for details.

  • registerurl [key url]

    Registers an url for a key.

    See git-annex-registerurl(1) for details.

  • unregisterurl [key url]

    Unregisters an url for a key.

    See git-annex-unregisterurl(1) for details.

  • setkey key file

    Moves a file into the annex as the content of a key.

    See git-annex-setkey(1) for details.

  • dropkey [key ...]

    Drops annexed content for specified keys.

    See git-annex-dropkey(1) for details.

  • transferkey key [--from=remote --to=remote]

    Transfers a key from or to a remote.

    See git-annex-transferkey(1) for details.

  • transferrer

    Used internally by git-annex to transfer content.

    See git-annex-transferrer(1) for details.

  • transferkeys

    Used internally by old versions of the assistant.

    See git-annex-transferkey(1) for details.

  • setpresentkey key uuid [1 0]

    This plumbing-level command changes git-annex's records about whetherthe specified key's content is present in a remote with the specified uuid.

    See git-annex-setpresentkey(1) for details.

  • readpresentkey key uuid

    Read records of where key is present.

    See git-annex-readpresentkey(1) for details.

  • checkpresentkey key remote

    Check if key is present in remote.

    See git-annex-checkpresentkey(1) for details.

  • rekey [file key ...]

    Change keys used for files.

    See git-annex-rekey(1) for details.

  • resolvemerge

    Resolves a conflicted merge, by adding both conflicting versions of thefile to the tree, using variants of their filename. This is doneautomatically when using git annex sync or git annex merge.

    See git-annex-resolvemerge(1) for details.

  • diffdriver

    This can be used to make git diff use an external diff driver withannexed files.

    See git-annex-diffdriver(1) for details.

  • smudge

    This command lets git-annex be used as a git filter driver, allowingannexed files in the git repository to be unlocked at all times, insteadof being symlinks.

    See git-annex-smudge(1) for details.

  • filter-process

    An alternative implementation of a git filter driver, that is fasterin some situations and slower in others than git-annex smudge.

    See git-annex-filter-process(1) for details.

  • findref [ref]

    Lists files in a git ref. (deprecated)

    See git-annex-findref(1) for details.

  • proxy -- git cmd [options]

    Bypass direct mode guard. (deprecated)

    See git-annex-proxy(1) for details.

  • test

    This runs git-annex's built-in test suite.

    See git-annex-test(1) for details.

  • testremote remote

    This tests a remote by generating some random objects and sending them tothe remote, then redownloading them, removing them from the remote, etc.

    It's safe to run in an existing repository (the repository contents arenot altered), although it may perform expensive data transfers.

    See git-annex-testremote(1) for details.

  • fuzztest

    Generates random changes to files in the current repository,for use in testing the assistant.

    See git-annex-fuzztest(1) for details.

  • benchmark

    This runs git-annex's built-in benchmarks, if it was built withbenchmarking support.

    See git-annex-benchmark(1) for details.

In addition to all the commands listed above, more commands can be added togit-annex by dropping commands named like 'git-annex-foo' into a directoryin the PATH.

Like other git commands, git-annex is configured via .git/config.These settings, as well as relevant git config settings, arethe ones git-annex uses.

(Some of these settings can also be set, across all clones of therepository, using git-annex-config. See its man page for a list.)

  • annex.uuid

    A unique UUID for this repository (automatically set).

  • annex.backend

    Name of the default key-value backend to use when adding new filesto the repository.

    This is overridden by annex annex.backend configuration in the.gitattributes files, and by the --backend option.

    (This used to be named annex.backends, and that will still be usedif set.)

  • annex.securehashesonly

    Set to true to indicate that the repository should only usecryptographically secure hashes (SHA2, SHA3) and not insecurehashes (MD5, SHA1) for content.

    When this is set, the contents of files using cryptographicallyinsecure hashes will not be allowed to be added to the repository.

    Also, git-annex fsck will complain about any files present inthe repository that use insecure hashes. And,git-annex import --no-content will refuse to import filesfrom special remotes using insecure hashes.

    To configure the behavior in new clones of the repository,this can be set using git-annex-config.

  • annex.maxextensionlength

    Maximum length, in bytes, of what is considered a filename extension whenadding a file to a backend that preserves filename extensions. Thedefault length is 4, which allows extensions like 'jpeg'. The dot beforethe extension is not counted part of its length. At most two extensionsat the end of a filename will be preserved, e.g. .gz or .tar.gz .

  • annex.diskreserve

    Amount of disk space to reserve. Disk space is checked when transferringcontent to avoid running out, and additional free space can be reservedvia this option, to make space for more important content (such as gitcommit logs). Can be specified with any commonly used units, for example,'0.5 gb', '500M', or '100 KiloBytes'

    The default reserve is 1 megabyte.

  • annex.skipunknown

    Set to true to make commands like 'git-annex get' silently skip overitems that are listed in the command line, but are not checked into git.

    Set to false to make it an error for commands like 'git-annex get'to be asked to operate on files that are not checked into git.

    The default is currently true, but is planned to change to false in arelease in 2022.

    Note that, when annex.skipunknown is false, a command like 'git-annex get .'will fail if no files in the current directory are checked into git,but a command like 'git-annex get' will not fail, because the currentdirectory is not listed, but is implicit. Commands like 'git-annex get foo/'will fail if no files in the directory are checked into git, but ifat least one file is, it will ignore other files that are not. This isall the same as the behavior of 'git-ls files --error-unmatch'.

    Also note that git-annex skips files that are checked into git, but arenot annexed files, this setting does not affect that.

  • annex.largefiles

    Used to configure which files are large enough to be added to the annex.It is an expression that matches the large files, eg'include=*.mp3 or largerthan=500kb'See git-annex-matching-expression(1) for details on the syntax.

    Overrides any annex.largefiles attributes in .gitattributes files.

    To configure a default annex.largefiles for all clones of the repository,this can be set in git-annex-config(1).

    This configures the behavior of both git-annex and git when addingfiles to the repository. By default, git-annex add adds all filesto the annex (except dotfiles), and git add adds files to git(unless they were added to the annex previously).When annex.largefiles is configured, bothgit annex add and git add will add matching large files to theannex, and the other files to git.

    Other git-annex commands also honor annex.largefiles, includinggit annex import, git annex addurl, git annex importfeedand the assistant.

  • annex.dotfiles

    Normally, dotfiles are assumed to be files like .gitignore,whose content should always be part of the git repository, sothey will not be added to the annex. Setting annex.dotfiles to truemakes dotfiles be added to the annex the same as any other file.

    To annex only some dotfiles, set this and configure annex.largefilesto match the ones you want. For example, to match only dotfiles endingin '.big'

    git config annex.largefiles '(include=..big or include=/..big) or (exclude=. and exclude=/.)' git config annex.dotfiles true

    To configure a default annex.dotfiles for all clones of the repository,this can be set in git-annex-config(1).

  • annex.gitaddtoannex

    Setting this to false will prevent git add from addingfiles to the annex, despite the annex.largefiles configuration.

  • annex.addsmallfiles

    Controls whether small files (not matching annex.largefiles)should be checked into git by git annex add. Defaults to true;set to false to instead make small files be skipped.

  • annex.addunlocked

    Commands like git-annex add default to adding files to the repositoryin locked form. This can make them add the files in unlocked form,the same as if git-annex-unlock(1) were run on the files.

    This can be set to 'true' to add everything unlocked, or it can be a morecomplicated expression that matches files by name, size, or content. Seegit-annex-matching-expression(1) for details.

    To configure a default annex.addunlocked for all clones of the repository,this can be set in git-annex-config(1).

    (Using git add always adds files in unlocked form and it is notaffected by this setting.)

    When a repository has core.symlinks set to false, or has an adjustedunlocked branch checked out, this setting is ignored, and files arealways added to the repository in unlocked form.

  • annex.numcopies

    This is a deprecated setting. You should instead use thegit annex numcopies command to configure how many copies of filesare kept across all repositories, or the annex.numcopies .gitattributessetting.

    This config setting is only looked at when git annex numcopies hasnever been configured, and when there's no annex.numcopies setting in the.gitattributes file.

    Note that setting numcopies to 0 is very unsafe.

  • annex.genmetadata

    Set this to true to make git-annex automatically generate some metadatawhen adding files to the repository.

    In particular, it stores year, month, and day metadata, from the file'smodification date.

    When importfeed is used, it stores additional metadata from the feed,such as the author, title, etc.

  • annex.used-refspec

    This controls which refs git-annex unused considers to be used.See REFSPEC FORMAT in git-annex-unused(1) for details.

  • annex.jobs

    Configure the number of concurrent jobs to run. Default is 1.

    Only git-annex commands that support the --jobs option willuse this.

    Setting this to 'cpus' will run one job per CPU core.

    When the --batch option is used, this configuration is ignored.

  • annex.adjustedbranchrefresh

    When git-annex-adjust(1) is used to set up an adjusted branchthat needs to be refreshed after getting or dropping files, this configcontrols how frequently the branch is refreshed.

    Refreshing the branch takes some time, so doing it after every filecan be too slow. (It also can generate a lot of dangling git objects.)The default value is 0 (or false), which does notrefresh the branch. Setting 1 (or true) will refresh only once,after git-annex has made other changes. Setting 2 refreshes after everyfile, 3 after every other file, and so on; setting 100 refreshes afterevery 99 files.

    (If git-annex gets faster in the future, refresh rates will increaseproportional to the speed improvements.)

  • annex.queuesize

    git-annex builds a queue of git commands, in order to combine similarcommands for speed. By default the size of the queue is limited to10240 commands; this can be used to change the size. If you have plentyof memory and are working with very large numbers of files, increasingthe queue size can speed it up.

  • annex.bloomcapacity

    The git annex unused and git annex sync --content commands usea bloom filter to determine what files are present in eg, the work tree.The default bloom filter is sized to handleup to 500000 files. If your repository is larger than that,you should increase this value. Larger values willmake git-annex unused and git annex sync --content consume more memory;run git annex info for memory usage numbers.

  • annex.bloomaccuracy

    Adjusts the accuracy of the bloom filter used bygit annex unused and git annex sync --content.The default accuracy is 10000000 -- 1 unused file out of 10000000will be missed by git annex unused. Increasing the accuracy will makegit annex unused consume more memory; run git annex infofor memory usage numbers.

  • annex.sshcaching

    By default, git-annex caches ssh connections using ssh'sControlMaster and ControlPersist settings(if built using a new enough ssh). To disable this, set to false.

  • annex.adviceNoSshCaching

    When git-annex is unable to use ssh connection caching, or has beenconfigured not to, and concurrency is enabled, it will warn thatthis might result in multiple ssh processes prompting for passwordsat the same time. To disable that warning, eg if you have configured sshconnection caching yourself, or have ssh agent caching passwords,set this to false.

  • annex.alwayscommit

    By default, git-annex automatically commits data to the git-annex branchafter each command is run. If you have a seriesof commands that you want to make a single commit, you canrun the commands with -c annex.alwayscommit=false. You can latercommit the data by running git annex merge (or by automatic merges)or git annex sync.

  • annex.commitmessage

    When git-annex updates the git-annex branch, it usually makes upits own commit message (eg 'update'), since users rarely look at orcare about changes to that branch. If you do care, you canspecify this setting by running commands with-c annex.commitmessage=whatever

    This works well in combination with annex.alwayscommit=false,to gather up a set of changes and commit them with a message you specify.

  • annex.allowsign

    By default git-annex avoids gpg signing commits that it makes whenthey're not the purpose of a command, but only a side effect.That default avoids lots of gpg password prompts whencommit.gpgSign is set. A command like git annex sync or git annex mergewill gpg sign its commit, but a command like git annex get,that updates the git-annex branch, will not. The assistant also avoidssigning commits.

    Setting annex.allowsign to true lets all commits be signed, ascontrolled by commit.gpgSign and other git configuration.

  • annex.merge-annex-branches

    By default, git-annex branches that have been pulled from remotesare automatically merged into the local git-annex branch, so thatgit-annex has the most up-to-date possible knowledge.

    To avoid that merging, set this to 'false'. This can be usefulparticularly when you don't have write permission to the repository.

  • annex.private

    When this is set to true, no information about the repository will berecorded in the git-annex branch.

    For example, to make a repository without any mention of it everappearing in the git-annex branch:

    git init myprivate cd myprivaterepo git config annex.private true git annex init

  • annex.hardlink

    Set this to true to make file contents be hard linked between therepository and its remotes when possible, instead of a more expensive copy.

    Use with caution -- This can invalidate numcopies counting, sincewith hard links, fewer copies of a file can exist. So, it is a goodidea to mark a repository using this setting as untrusted.

    When a repository is set up using git clone --shared, git-annex initwill automatically set annex.hardlink and mark the repository asuntrusted.

    When annex.thin is also set, setting annex.hardlink has no effect.

  • annex.thin

    Set this to true to make unlocked files be a hard link to their contentin the annex, rather than a second copy. This can save considerabledisk space, but when a modification is made to a file, you will lose thelocal (and possibly only) copy of the old version. So, enable with care.

    After setting (or unsetting) this, you should run git annex fix tofix up the annexed files in the work tree to be hard links (or copies).

    Note that this has no effect when the filesystem does not support hard links.And when multiple files in the work tree have the same content, onlyone of them gets hard linked to the annex.

  • annex.supportunlocked

    By default git-annex supports unlocked files as well as locked files,so this defaults to true. If set to false, git-annex will only supportlocked files. That will avoid doing the work needed to support unlockedfiles.

    Note that setting this to false does not prevent a repository fromhaving unlocked files added to it, and in that case the content of thefiles will not be accessible until they are locked.

    After changing this config, you need to re-run git-annex init for itto take effect.

  • annex.resolvemerge

    Set to false to prevent merge conflicts in the checked out branchbeing automatically resolved by the git-annex assitant,git-annex sync, git-annex merge,and the git-annex post-receive hook.

    To configure the behavior in all clones of the repository,this can be set in git-annex-config(1).

  • annex.synccontent

    Set to true to make git-annex sync default to syncing annexed content.

    To configure the behavior in all clones of the repository,this can be set in git-annex-config(1).

  • annex.synconlyannex

    Set to true to make git-annex sync default to only sincing the git-annexbranch and annexed content.

    To configure the behavior in all clones of the repository,this can be set in git-annex-config(1).

  • annex.debug

    Set to true to enable debug logging by default.

  • annex.debugfilter

    Set to configure which debug messages to display (when debug messagedisplay has been enabled by annex.debug or --debug). The value is oneor more module names, separated by commas.

  • annex.version

    The current version of the git-annex repository. This ismaintained by git-annex and should never be manually changed.

  • annex.autoupgraderepository

    When an old git-annex repository version has become deprecated,git-annex will normally automatically upgrade the repository tothe new version.

    If this is set to false, git-annex won't automatically upgrade therepository. Instead it will exit with an error message. You can rungit annex upgrade yourself when you are ready to upgrade therepository.

  • annex.crippledfilesystem

    Set to true if the repository is on a crippled filesystem, such as FAT,which does not support symbolic links, or hard links, or unix permissions.This is automatically probed by 'git annex init'.

  • annex.pidlock

    Normally, git-annex uses fine-grained lock files to allow multipleprocesses to run concurrently without getting in each others' way.That works great, unless you are using git-annex on a filesystem thatdoes not support POSIX fcntl locks. This is sometimes the case whenusing NFS or Lustre filesystems.

    To support such situations, you can set annex.pidlock to true, and itwill fall back to a single top-level pid file lock.

    Although, often, you'd really be better off fixing your networkedfilesystem configuration to support POSIX locks.. And, some networkedfilesystems are so inconsistent that one node can't reliably tell whenthe other node is holding a pid lock. Caveat emptor.

  • annex.pidlocktimeout

    git-annex will wait up to this many seconds for the pid lockfile to go away, and will then abort if it cannot continue. Default: 300

    When using pid lock files, it's possible for a stale lock file to getleft behind by previous run of git-annex that crashed or was interrupted.This is mostly avoided, but can occur especially when using a networkfile system. This timeout prevents git-annex waiting forever in such asituation.

  • annex.cachecreds

    When 'true' (the default), git-annex will cache credentials used toaccess special remotes in files in .git/annex/creds/that only you can read. To disable that caching, set to 'false',and credentials will only be read from the environment, or ifthey have been embedded in encrypted form in the git repository, willbe extracted and decrypted each time git-annex needs to access theremote.

  • annex.secure-erase-command

    This can be set to a command that should be run whenever git-annexremoves the content of a file from the repository.

    In the command line, %file is replaced with the file that should beerased.

    For example, to use the wipe command, set it to wipe -f %file.

  • annex.freezecontent-command, annex.thawcontent-command

    Usually the write permission bits are unset to protect annexed objectsfrom being modified or deleted. The freezecontent-command is run aftergit-annex has removed the write bit. The thawcontent-command should undoits effect, and is run before git-annex restores the write bit.

    In the command line, %path is replaced with the file or directory tooperate on.

  • annex.tune.objecthash1, annex.tune.objecthashlower, annex.tune.branchhash1

    These can be passed to git annex init to tune the repository.They cannot be safely changed in a running repository and should never beset in global git configuration.For details, see https://git-annex.branchable.com/tuning/.

Remotes are configured using these settings in .git/config.

  • remote.<name>.annex-cost

    When determining which repository totransfer annexed files from or to, ones with lower costs are preferred.The default cost is 100 for local repositories, and 200 for remoterepositories.

  • remote.<name>.annex-cost-command

    If set, the command is run, and the number it outputs is used as the cost.This allows varying the cost based on e.g., the current network.

  • remote.<name>.annex-start-command

    A command to run when git-annex begins to use the remote. This canbe used to, for example, mount the directory containing the remote.

    The command may be run repeatedly when multiple git-annex processesare running concurrently.

  • remote.<name>.annex-stop-command

    A command to run when git-annex is done using the remote.

    The command will only be run once all running git-annex processesare finished using the remote.

  • remote.<name>.annex-shell

    Specify an alternative git-annex-shell executable on the remoteinstead of looking for 'git-annex-shell' on the PATH.

    This is useful if the git-annex-shell program is outside the PATHor has a non-standard name.

  • remote.<name>.annex-ignore

    If set to true, prevents git-annexfrom storing file contents on this remote by default.(You can still request it be used by the --from and --to options.)

    This is, for example, useful if the remote is located somewherewithout git-annex-shell. (For example, if it's on GitHub).Or, it could be used if the network connection between tworepositories is too slow to be used normally.

    This does not prevent git-annex sync (or the git-annex assistant) fromsyncing the git repository to the remote.

  • remote.<name>.annex-ignore-command

    If set, the command is run, and if it exits nonzero, that's the sameas setting annex-ignore to true. This allows controlling behavior basedon e.g., the current network.

  • remote.<name>.annex-sync

    If set to false, prevents git-annex sync (and the git-annex assistant)from syncing with this remote by default. However, git annex sync <name>can still be used to sync with the remote.

  • remote.<name>.annex-sync-command

    If set, the command is run, and if it exits nonzero, that's the sameas setting annex-sync to false. This allows controlling behavior basedon e.g., the current network.

  • remote.<name>.annex-pull

    If set to false, prevents git-annex sync (and the git-annex assistantetc) from ever pulling (or fetching) from the remote.

  • remote.<name>.annex-push

    If set to false, prevents git-annex sync (and the git-annex assistantetc) from ever pushing to the remote.

  • remote.<name>.annex-readonly

    If set to true, prevents git-annex from making changes to a remote.This both prevents git-annex sync from pushing changes, and preventsstoring or removing files from read-only remote.

  • remote.<name>.annex-verify, annex.verify

    By default, git-annex will verify the checksums of objects downloadedfrom remotes. If you trust a remote and don't want the overheadof these checksums, you can set this to false.

    Note that even when this is set to false, git-annex does verificationin some edge cases, where it's likely the case than anobject was downloaded incorrectly, or when needed for security.

  • remote.<name>.annex-tracking-branch

    This is for use with special remotes that support exports and imports.

    When set to eg, 'master', this tells git-annex that you want thespecial remote to track that branch.

    When set to eg, 'master:subdir', the special remote tracks onlythe subdirectory of that branch.

    git-annex sync --content will import changes from the remote andmerge them into the annex-tracking-branch. They also export changesmade to the branch to the remote.

  • remote.<name>.annex-export-tracking

    Deprecated name for remote.<name>.annex-tracking-branch. Will still be usedif it's configured and remote.<name>.annex-tracking-branch is not.

  • remote.<name>.annexUrl

    Can be used to specify a different url than the regular remote.<name>.urlfor git-annex to use when talking with the remote. Similar to the pushUrlused by git-push.

  • remote.<name>.annex-uuid

    git-annex caches UUIDs of remote repositories here.

  • remote.<name>.annex-config-uuid

    Used for some special remotes, points to a different special remoteconfiguration to use.

  • remote.<name>.annex-retry, annex.retry

    Number of times a transfer that fails can be retried. (default 0)

  • remote.<name>.annex-forward-retry, annex.forward-retry

    If a transfer made some forward progress before failing,this allows it to be retried even when annex.retry does not.The value is the maximum number of times to do that. (default 5)

    When both annex.retry and this are set, the maximum number ofretries is the larger of the two.

  • remote.<name>.annex-retry-delay, annex.retry-delay

    Number of seconds to delay before the first retry of a transfer.When making multiple retries of the same transfer, the delaydoubles after each retry. (default 1)

  • remote.<name>.annex-bwlimit, annex.bwlimit

    This can be used to limit how much bandwidth is used for a transferfrom or to a remote.

    For example, to limit transfers to 1 mebibyte per second:git config annex.bwlimit '1MiB'

    This will work with many remotes, including git remotes, but notfor remotes where the transfer is run by a separate program thangit-annex.

  • remote.<name>.annex-stalldetecton, annex.stalldetection

    Configuring this lets stalled or too-slow transfers be detected, anddealt with, so rather than getting stuck, git-annex will cancel thestalled operation. The transfer will be considered to have failed, sosettings like annex.retry will control what it does next.

    By default, git-annex detects transfers that have probably stalled,and suggests configuring this. If it is incorrectly detectingstalls, setting this to 'false' will avoid that.

    Set to 'true' to enable automatic stall detection. If a remote does notupdate its progress consistently, no automatic stall detection will bedone. And it may take a while for git-annex to decide a remote is reallystalled when using automatic stall detection, since it needs to beconservative about what looks like a stall.

    For more fine control over what constitutes a stall, set to a value inthe form '$amount/$timeperiod' to specify how much data git-annex shouldexpect to see flowing, minimum, over a given period of time.

    For example, to detect outright stalls where no data has been transferredafter 30 seconds: git config annex.stalldetection '1KB/30s'

    Or, if you have a remote on a USB drive that is normally capable ofseveral megabytes per second, but has bad sectors where it getsstuck for a long time, you could use:git config remote.usbdrive.annex-stalldetection '1MB/1m'

    This is not enabled by default, because it can make git-annex usemore resources. To be able to cancel stalls, git-annex has to runtransfers in separate processes (one per concurrent job). So itmay need to open more connections to a remote than usual, orthe communication with those processes may make it a bit slower.

  • remote.<name>.annex-checkuuid

    This only affects remotes that have their url pointing to a directory onthe same system. git-annex normally checks the uuid of suchremotes each time it's run, which lets it transparently deal withdifferent drives being mounted to the location at different times.

    Setting annex-checkuuid to false will prevent it from checking the uuidat startup (although the uuid is still verified before making anychanges to the remote repository). This may be useful to set to preventunncessary spin-up or automounting of a drive.

  • remote.<name>.annex-trustlevel

    Configures a local trust level for the remote. This overrides the valueconfigured by the trust and untrust commands. The value can be any of'trusted', 'semitrusted' or 'untrusted'.

  • remote.<name>.annex-availability

    Can be used to tell git-annex whether a remote is LocallyAvailableor GloballyAvailable. Normally, git-annex determines this automatically.

  • remote.<name>.annex-speculate-present

    Set to 'true' to make git-annex speculate that this remote may contain thecontent of any file, even though its normal location tracking does notindicate that it does. This will cause git-annex to try to get all filecontents from the remote. Can be useful in setting up a caching remote.

  • remote.<name>.annex-private

    When this is set to true, no information about the remote will berecorded in the git-annex branch. This is mostly useful for specialremotes, and is set when using git-annex-initremote(1) with the--private option.

  • remote.<name>.annex-bare

    Can be used to tell git-annex if a remote is a bare repositoryor not. Normally, git-annex determines this automatically.

  • remote.<name>.annex-ssh-options

    Options to use when using ssh to talk to this remote.

  • remote.<name>.annex-rsync-options

    Options to use when using rsyncto or from this remote. For example, to force IPv6, and limitthe bandwidth to 100Kbyte/s, set it to -6 --bwlimit 100

    Note that git-annex-shell has a whitelist of allowed rsync options,and others will not be be passed to the remote rsync. So using someoptions may break the communication between the local and remote rsyncs.

  • remote.<name>.annex-rsync-upload-options

    Options to use when using rsync to upload a file to a remote.

    These options are passed after other applicable rsync options,so can be used to override them. For example, to limit upload bandwidthto 10Kbyte/s, set --bwlimit 10.

  • remote.<name>.annex-rsync-download-options

    Options to use when using rsync to download a file from a remote.

    These options are passed after other applicable rsync options,so can be used to override them.

  • remote.<name>.annex-rsync-transport

    The remote shell to use to connect to the rsync remote. Possiblevalues are ssh (the default) and rsh, together with theirarguments, for instance ssh -p 2222 -c blowfish; Note that theremote hostname should not appear there, see rsync(1) for details.When the transport used is ssh, connections are automatically cachedunless annex.sshcaching is unset.

  • remote.<name>.annex-bup-split-options

    Options to pass to bup split when storing content in this remote.For example, to limit the bandwidth to 100Kbyte/s, set it to --bwlimit 100k(There is no corresponding option for bup join.)

  • remote.<name>.annex-gnupg-options

    Options to pass to GnuPG when it's encrypting data. For instance, touse the AES cipher with a 256 bits key and disable compression, set itto --cipher-algo AES256 --compress-algo none. (These options takeprecedence over the default GnuPG configuration, which is otherwiseused.)

  • remote.<name>.annex-gnupg-decrypt-options

    Options to pass to GnuPG when it's decrypting data. (These options takeprecedence over the default GnuPG configuration, which is otherwiseused.)

  • annex.ssh-options, annex.rsync-options,annex.rsync-upload-options, annex.rsync-download-options,annex.bup-split-options, annex.gnupg-options,annex.gnupg-decrypt-options

    Default options to use if a remote does not have more specific optionsas described above.

  • remote.<name>.annex-rsyncurl

    Used by rsync special remotes, this configuresthe location of the rsync repository to use. Normally this is automaticallyset up by git annex initremote, but you can change it if needed.

  • remote.<name>.annex-buprepo

    Used by bup special remotes, this configuresthe location of the bup repository to use. Normally this is automaticallyset up by git annex initremote, but you can change it if needed.

  • remote.<name>.annex-borgrepo

    Used by borg special remotes, this configuresthe location of the borg repository to use. Normally this is automaticallyset up by git annex initremote, but you can change it if needed.

  • remote.<name>.annex-ddarrepo

    Used by ddar special remotes, this configuresthe location of the ddar repository to use. Normally this is automaticallyset up by git annex initremote, but you can change it if needed.

  • remote.<name>.annex-directory

    Used by directory special remotes, this configuresthe location of the directory where annexed files are stored for thisremote. Normally this is automatically set up by git annex initremote,but you can change it if needed.

  • remote.<name>.annex-adb

    Used to identify remotes on Android devices accessed via adb.Normally this is automatically set up by git annex initremote.

  • remote.<name>.annex-androiddirectory

    Used by adb special remotes, this is the directory on the Androiddevice where files are stored for this remote. Normally this isautomatically set up by git annex initremote, but you can changeit if needed.

  • remote.<name>.annex-androidserial

    Used by adb special remotes, this is the serial number of the Androiddevice used by the remote. Normally this is automatically set up bygit annex initremote, but you can change it if needed, eg whenupgrading to a new Android device.

  • remote.<name>.annex-s3

    Used to identify Amazon S3 special remotes.Normally this is automatically set up by git annex initremote.

  • remote.<name>.annex-glacier

    Used to identify Amazon Glacier special remotes.Normally this is automatically set up by git annex initremote.

  • remote.<name>.annex-webdav

    Used to identify webdav special remotes.Normally this is automatically set up by git annex initremote.

  • remote.<name>.annex-tahoe

    Used to identify tahoe special remotes.Points to the configuration directory for tahoe.

  • remote.<name>.annex-gcrypt

    Used to identify gcrypt special remotes.Normally this is automatically set up by git annex initremote.

    It is set to 'true' if this is a gcrypt remote.If the gcrypt remote is accessible over ssh and has git-annex-shellavailable to manage it, it's set to 'shell'.

  • remote.<name>.annex-git-lfs

    Used to identify git-lfs special remotes.Normally this is automatically set up by git annex initremote.

    It is set to 'true' if this is a git-lfs remote.

  • remote.<name>.annex-httpalso

    Used to identify httpalso special remotes.Normally this is automatically set up by git annex initremote.

  • remote.<name>.annex-externaltype

    Used external special remotes to record the type of the remote.

    Eg, if this is set to 'foo', git-annex will run a 'git-annex-remote-foo'program to communicate with the external special remote.

    If this is set to 'readonly', then git-annex will not run any externalspecial remote program, but will try to access things stored in theremote using http. That only works for some external special remotes,so consult the documentation of the one you are using.

  • remote.<name>.annex-hooktype

    Used by hook special remotes to record the type of the remote.

  • annex.web-options

    Options to pass to curl when git-annex uses it to download urls(rather than the default built-in url downloader).

    For example, to force IPv4 only, set it to '-4'.Or to make curl use your ~/.netrc file, set it to '--netrc'.

    Setting this option makes git-annex use curl, but onlywhen annex.security.allowed-ip-addresses is configured in aspecific way. See its documentation.

  • annex.youtube-dl-options

    Options to pass to youtube-dl when using it to find the url to downloadfor a video.

    Some options may break git-annex's integration with youtube-dl. Forexample, the --output option could cause it to store files somewheregit-annex won't find them. Avoid setting here or in the youtube-dl configfile any options that cause youtube-dl to download more than one file,or to store the file anywhere other than the current working directory.

  • annex.youtube-dl-command

    Command to run for youtube-dl. Default is 'youtube-dl'.

  • annex.aria-torrent-options

    Options to pass to aria2c when using it to download a torrent.

  • annex.http-headers

    HTTP headers to send when downloading from the web. Multiple lines ofthis option can be set, one per header.

  • annex.http-headers-command

    If set, the command is run and each line of its output is used as a HTTPheader. This overrides annex.http-headers.

  • annex.security.allowed-url-schemes

    List of URL schemes that git-annex is allowed to download content from.The default is 'http https ftp'.

    Think very carefully before changing this; there are securityimplications. For example, if it's changed to allow 'file' URLs, thenanyone who can get a commit into your git-annex repository couldgit-annex addurl a pointer to a private file located outside thatrepository, possibly causing it to be copied into your repositoryand transferred on to other remotes, exposing its content.

    Some special remotes support their own domain-specific URLschemes; those are not affected by this configuration setting.

  • annex.security.allowed-ip-addresses

    By default, git-annex only makes connections to public IP addresses;it will refuse to use HTTP and other servers on localhost or on aprivate network.

    This setting can override that behavior, allowing access to particularIP addresses that would normally be blocked. For example '127.0.0.1 ::1'allows access to localhost (both IPV4 and IPV6).To allow access to all IP addresses, use 'all'

    Think very carefully before changing this; there are securityimplications. Anyone who can get a commit into your git-annex repositorycould git annex addurl an url on a private server, possiblycausing it to be downloaded into your repository and transferred toother remotes, exposing its content.

    Note that, since the interfaces of curl and youtube-dl do not allowthese IP address restrictions to be enforced, curl and youtube-dl willnever be used unless annex.security.allowed-ip-addresses=all.

    To allow accessing local or private IP addresses on only specific ports,use the syntax '[addr]:port'. For example,'[127.0.0.1]:80 [127.0.0.1]:443 [::1]:80 [::1]:443' allowslocalhost on the http ports only.

  • annex.security.allowed-http-addresses

    Old name for annex.security.allowed-ip-addresses.If set, this is treated the same as havingannex.security.allowed-ip-addresses set.

  • annex.security.allow-unverified-downloads

    For security reasons, git-annex refuses to download content frommost special remotes when it cannot check a hash to verifythat the correct content was downloaded. This particularly impactsdownloading the content of URL or WORM keys, which lack hashes.

    The best way to avoid problems due to this is to migrate filesaway from such keys, before their content reaches a special remote.See git-annex-migrate(1).

    When the content is only available from a special remote, you canuse this configuration to force git-annex to download it.But you do so at your own risk, and it's very important you read andunderstand the information below first!

    Downloading unverified content from encrypted special remotes isprevented, because the special remote could send some other encryptedcontent than what you expect, causing git-annex to decrypt data that younever checked into git-annex, and risking exposing the decrypteddata to any non-encrypted remotes you send content to.

    Downloading unverified content from (non-encrypted)external special remotes is prevented, because they could followhttp redirects to web servers on localhost or on a private network,or in some cases to a file:/// url.

    If you decide to bypass this security check, the best thing to do isto only set it temporarily while running the command that gets the file.The value to set the config to is 'ACKTHPPT'.For example:

    git -c annex.security.allow-unverified-downloads=ACKTHPPT annex get myfile

    It would be a good idea to check that it downloaded the file you expected,too.

  • remote.<name>.annex-security-allow-unverified-downloads

    Per-remote configuration of annex.security.allow-unverified-downloads.

  • annex.delayadd

    Makes the watch and assistant commands delay for the specified number ofseconds before adding a newly created file to the annex. Normally thisis not needed, because they already wait for all writers of the fileto close it.

    Note that this only delays adding files created while the daemon isrunning. Changes made when it is not running will be added immediatelythe next time it is started up.

  • annex.expireunused

    Controls what the assistant does about unused file contentsthat are stored in the repository.

    The default is false, which causesall old and unused file contents to be retained, unless the assistantis able to move them to some other repository (such as a backup repository).

    Can be set to a time specification, like '7d' or '1m', and thenfile contents that have been known to be unused for a week or amonth will be deleted.

  • annex.fscknudge

    When set to false, prevents the webapp from reminding you when usingrepositories that lack consistency checks.

  • annex.autoupgrade

    When set to ask (the default), the webapp will check for new versionsand prompt if they should be upgraded to. When set to true, automaticallyupgrades without prompting (on some supported platforms). When set tofalse, disables any upgrade checking.

    Note that upgrade checking is only done when git-annex is installedfrom one of the prebuilt images from its website. This does notbypass e.g., a Linux distribution's own upgrade handling code.

    This setting also controls whether to restart the git-annex assistantwhen the git-annex binary is detected to have changed. That is usefulno matter how you installed git-annex.

  • annex.autocommit

    Set to false to prevent the git-annex assistant and git-annex syncfrom automatically committing changes to files in the repository.

    To configure the behavior in all clones of the repository,this can be set in git-annex-config(1).

  • annex.startupscan

    Set to false to prevent the git-annex assistant from scanning therepository for new and changed files on startup. This will prevent itfrom noticing changes that were made while it was not running, but can bea useful performance tweak for a large repository.

  • annex.listen

    Configures which address the webapp listens on. The default is localhost.Can be either an IP address, or a hostname that resolves to the desiredaddress.

The key-value backend used when adding a new file to the annex can beconfigured on a per-file-type basis via .gitattributes files. In the file,the annex.backend attribute can be set to the name of the backend touse. For example, this here's how to use the WORM backend by default,but the SHA256E backend for ogg files:

There is a annex.largefiles attribute, which is used to configure whichfiles are large enough to be added to the annex. Since attributes cannotcontain spaces, it is difficult to use for more complex annex.largefilessettings. Setting annex.largefiles in git-annex-config(1) is an easierway to configure it across all clones of the repository.See git-annex-matching-expression(1) for details on the syntax.

The numcopies and mincopies settings can also be configured on aper-file-type basis via the annex.numcopies and annex.mincopiesattributes in .gitattributes files. This overrides other settings.For example, this makes two copies be needed for wav files and 3 copiesfor flac files:

Note that setting numcopies or mincopies to 0 is very unsafe.

These settings are honored by git-annex whenever it's operating on amatching file. However, when using --all, --unused, or --key to specifykeys to operate on, git-annex is operating on keys and not files, so willnot honor the settings from .gitattributes. For this reason, the git annexnumcopies and git annex mincopies commands are useful to configure aglobal default.

Also note that when using views, only the toplevel .gitattributes file ispreserved in the view, so other settings in other files won't have anyeffect.

git-annex, when called as a git subcommand, may return exit codes 0 or 1for success or failures, or, more rarely, 127 or 128 for certain veryspecific failures. git-annex itself should return 0 on success and 1 onfailure, unless the --time-limit=time option is hit, in which case itreturns with exit code 101.

Download Git Annex For Mac 0.0.1 Crack

These environment variables are used by git-annex when set:

  • GIT_WORK_TREE, GIT_DIR

    Handled the same as they are by git, see git(1)

  • GIT_SSH, GIT_SSH_COMMAND

    Handled similarly to the same as described in git(1).The one difference is that git-annex will sometimes pass an additional'-n' parameter to these, as the first parameter, to prevent ssh fromreading from stdin. Since that can break existing uses of theseenvironment variables that don't expect the extra parameter, you willneed to set GIT_ANNEX_USE_GIT_SSH=1 to make git-annex supportthese.

    Note that setting either of these environment variables preventsgit-annex from automatically enabling ssh connection caching(see annex.sshcaching), so it will slow down some operations withremotes over ssh. It's up to you to enable ssh connection cachingif you need it; see ssh's documentation.

    Also, annex.ssh-options and remote.<name>.annex-ssh-optionswon't have any effect when these envionment variables are set.

    Usually it's better to configure any desired options through your~/.ssh/config file, or by setting annex.ssh-options.

  • GIT_ANNEX_VECTOR_CLOCK

    Normally git-annex timestamps lines in the log files committed to thegit-annex branch. Setting this environment variable to a numberwill make git-annex use that (or a larger number)rather than the current number of seconds since the UNIX epoch.Note that decimal seconds are supported.

    This is only provided for advanced users who either have a better way totell which commit is current than the local clock, or who need to avoidembedding timestamps for policy reasons.

  • Some special remotes use additional environment variablesfor authentication etc. For example, AWS_ACCESS_KEY_IDand GIT_ANNEX_P2P_AUTHTOKEN. See special remote documentation.

These files are used by git-annex:

.git/annex/objects/ in your git repository contains the annexed filecontents that are currently available. Annexed files in your gitrepository symlink to that content.

.git/annex/ in your git repository contains other run-time informationused by git-annex.

~/.config/git-annex/autostart is a list of git repositoriesto start the git-annex assistant in.

.git/hooks/pre-commit-annex in your git repository will be run whenevera commit is made to the HEAD branch, either by git commit, git-annexsync, or the git-annex assistant.

.git/hooks/post-update-annex in your git repository will be runwhenever the git-annex branch is updated. You can make this hook rungit update-server-info when publishing a git-annex repository by http.

Download Git Annex For Mac 0.0.1 Torrent

More git-annex documentation is available on its web site,https://git-annex.branchable.com/

If git-annex is installed from a package, a copy of its documentationshould be included, in, for example, /usr/share/doc/git-annex/.

Joey Hess [email protected]

Download Git Annex For Mac 0.0.1 File

Warning: Automatically converted into a man page by mdwn2man. Edit with care.