NAME

       git-annex-import - add a tree of files to the repository

SYNOPSIS

       git annex import --from remote branch[:subdir] | [path ...]

DESCRIPTION

       This  command  is  a  way  to  import  a  tree of files from elsewhere into your git-annex
       repository. It can import files from a git-annex special remote, or from a directory.

IMPORTING FROM A SPECIAL REMOTE

       Importing from a special remote  first  downloads  all  new  content  from  it,  and  then
       constructs  a git commit that reflects files that have changed on the special remote since
       the last time git-annex looked at it. Merging that commit into your repository will update
       it to reflect changes made on the special remote.

       This  way,  something  can  be  using  the  special remote for file storage, adding files,
       modifying files, and deleting files, and you can track those changes using git-annex.

       You can combine using git annex import to fetch changes from a  special  remote  with  git
       annex export to send your local changes to the special remote.

       You can only import from special remotes that were configured with importtree=yes when set
       up with git-annex-initremote(1). Only some kinds of special remotes will let you configure
       them this way. A perhaps non-exhastive list is the directory, s3, and adb special remotes.

       To  import  from a special remote, you must specify the name of a branch.  A corresponding
       remote tracking branch will be updated by git annex import. After  that  point,  it's  the
       same  as  if  you had run a git fetch from a regular git remote; you can merge the changes
       into your currently checked out branch.

       For example:

        git annex import master --from myremote
        git annex merge myremote/master

       You could just as well use git merge myremote/master as the second step,  but  using  git-
       annex  merge  avoids  a  couple  of  gotchas. When using adjusted branches, it adjusts the
       branch before merging from it. And it avoids the merge failing on the first merge from  an
       import due to unrelated histories.

       If  you  do use git merge, you can pass --allow-unrelated-histories the first time you git
       merge from an import. Think of this as the remote being a separate git repository with its
       own files. If you first git annex export files to a remote, and then git annex import from
       it, you won't need that option.

       You can import into a subdirectory, using the  "branch:subdir"  syntax.  For  example,  if
       "camera" is a special remote that accesses a camera, and you want to import those into the
       photos directory, rather than to the root of your repository:

        git annex import master:photos --from camera
        git merge camera/master

       The git annex sync --content command (and the git-annex assistant) can  also  be  used  to
       import    from    a    special    remote.    To   do   this,   you   need   to   configure
       "remote.<name>.annex-tracking-branch" to tell it what branch to track. For example:

        git config remote.myremote.annex-tracking-branch master
        git annex sync --content

       If a preferred content expression is configured for the special remote, it will be honored
       when  importing  from  it.  Files that are not preferred content of the remote will not be
       imported from it, but will be left on the remote.

       However, preferred content expressions that relate  to  the  key  can't  be  matched  when
       importing,  because  the content of the file is not known. Importing will fail when such a
       preferred content expression is  set.  This  includes  expressions  containing  "copies=",
       "metadata=",  and  other  things  that  depend  on  the key. Preferred content expressions
       containing "include=", "exclude=" "smallerthan=", "largerthan=" will work.

IMPORTING FROM A DIRECTORY

       When run with a path, git annex import moves files from somewhere outside the git  working
       copy, and adds them to the annex.

       This  is  a  legacy  interface.  It  is  still supported, but please consider switching to
       importing from a directory special remote instead, using the interface documented above.

       Individual files to import can be specified. If  a  directory  is  specified,  the  entire
       directory is imported.

        git annex import /media/camera/DCIM/*

       When  importing  files,  there's  a possibility of importing a duplicate of a file that is
       already known to git-annex -- its content  is  either  present  in  the  local  repository
       already,  or  git-annex knows of another repository that contains it, or it was present in
       the annex before but has been removed now.

       By default, importing a duplicate of a known file will result  in  a  new  filename  being
       added  to  the repository, so the duplicate file is present in the repository twice. (With
       all checksumming backends, including the default SHA256E, only one copy of the  data  will
       be stored.)

       Several  options  can  be  used  to  adjust  handling of duplicate files, see --duplicate,
       --deduplicate,   --skip-duplicates,    --clean-duplicates,    and    --reinject-duplicates
       documentation below.

OPTIONS FOR IMPORTING FROM A DIRECTORY

       --duplicate

              Do not delete files from the import location.

              Running  with  this  option repeatedly can import the same files into different git
              repositories, or branches, or different locations in a git repository.

       --deduplicate
              Only import files that are not duplicates; duplicate files will be deleted from the
              import location.

       --skip-duplicates
              Only  import  files  that  are  not  duplicates. Avoids deleting any files from the
              import location.

       --clean-duplicates
              Does not import any files, but any files found in  the  import  location  that  are
              duplicates are deleted.

       --reinject-duplicates
              Imports files that are not duplicates. Files that are duplicates have their content
              reinjected into the annex (similar to git-annex-reinject(1)).

       --force
              Allow existing files to be overwritten by newly imported files.

              Also, causes .gitignore to not take effect when adding files.

       file matching options
              Many of the git-annex-matching-options(1) can be used to specify files to import.

                   git annex import /dir --include='*.png'

              ## COMMON OPTIONS

       --jobs=N -JN
              Imports multiple files in parallel. This may be faster.  For example: -J4

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

       --json Enable JSON output. This is intended to be parsed by programs that  use  git-annex.
              Each line of output is a JSON object.

       --json-error-messages
              Messages  that  would normally be output to standard error are included in the json
              instead.

CAVEATS

       Note that using --deduplicate or --clean-duplicates with the WORM backend does not look at
       file content, but filename and mtime.

       If  annex.largefiles  is  configured, and does not match a file, git annex import will add
       the non-large file directly to the git repository, instead of to the annex.

SEE ALSO

       git-annex(1)

       git-annex-add(1)

       git-annex-export(1)

       git-annex-preferred-content(1)

AUTHOR

       Joey Hess <id@joeyh.name>

                                                                              git-annex-import(1)