class_docstr: Create a dataset sibling on a GIN site (with content hosting)
  
  GIN (G-Node infrastructure) is a free data management system. It is a
  GitHub-like, web-based repository store and provides fine-grained access
  control to shared data. GIN is built on Git and git-annex, and can natively
  host DataLad datasets, including their data content!
  
  This command uses the main GIN instance at https://gin.g-node.org as the
  default target, but other deployments can be used via the 'api'
  parameter.
  
  An SSH key, properly registered at the GIN instance, is required for data
  upload via DataLad. Data download from public projects is also possible via
  anonymous HTTP.
  
  In order to be able to use this command, a personal access token has to be
  generated on the platform (Account->Your Settings->Applications->Generate
  New Token).
  
  This command can be configured with
  "datalad.create-sibling-ghlike.extra-remote-settings.NETLOC.KEY=VALUE" in
  order to add any local KEY = VALUE configuration to the created sibling in
  the local `.git/config` file. NETLOC is the domain of the Gin instance to
  apply the configuration for.
  This leads to a behavior that is equivalent to calling datalad's
  ``siblings('configure', ...)``||``siblings configure`` command with the
  respective KEY-VALUE pair after creating the sibling.
  The configuration, like any other, could be set at user- or system level, so
  users do not need to add this configuration to every sibling created with
  the service at NETLOC themselves.
  
  .. versionadded:: 0.16
code: def __call__(
      reponame,
      *,
      dataset=None,
      recursive=False,
      recursion_limit=None,
      name="gin",
      existing="error",
      api="https://gin.g-node.org",
      credential=None,
      access_protocol="https-ssh",
      publish_depends=None,
      private=False,
      description=None,
      dry_run=False,
  ):
      for res in _create_sibling(
          platform=_GIN(api, credential, require_token=not dry_run),
          reponame=reponame,
          dataset=dataset,
          recursive=recursive,
          recursion_limit=recursion_limit,
          name=name,
          existing=existing,
          access_protocol=access_protocol,
          publish_depends=publish_depends,
          private=private,
          description=description,
          dry_run=dry_run,
      ):
          if res.get("action") == "configure-sibling" and res.get(
              "annex-ignore"
          ) in ("true", True):
              # when we see that git-annex had disabled access to GIN
              # we will revert it for any dataset with an annex.
              # git-annex's conclusion might solely be based on the
              # fact that it tested prior the first push (failed to
              # obtain a git-annex branch with a UUID) and concluded
              # that there can never be an annex.
              # however, we know for sure that GIN can do it, so we
              # force this to enable correct subsequent data transfer
              ds = Dataset(res["path"])
              if isinstance(ds.repo, AnnexRepo):
                  ds.config.set(
                      f"remote.{name}.annex-ignore",
                      "false",
                      scope="local",
                  )
                  res["annex-ignore"] = "false"
          yield res
  
file_path: datalad/datalad/distributed/create_sibling_gin.py
imports: import logging
  from datalad.distributed.create_sibling_ghlike import _create_sibling
  from datalad.distributed.create_sibling_gogs import _GOGS
  from datalad.distribution.dataset import datasetmethod, Dataset
  from datalad.interface.base import Interface, build_doc, eval_results
  from datalad.support.annexrepo import AnnexRepo
label_desc: Use image node_id 1 for calling the CreateSiblingGin obj's underlying member method code with example usage: obj.__call__(reponame) without return types