| Created | 2026-10-21 |
|---|---|
| Last-Modified | 2026-11-17 |
| SPDX-FileCopyrightText | 2026-present Arthit Suriyawongkul |
| SPDX-FileType | DOCUMENTATION |
| SPDX-License-Identifier | CC0-1.0 |
See also: Command line for loom project, loom model and
loom generate,
Python API: remote targets for generate(), generate_git_sbom() and
generate_git_project_sbom(),
AI model formats for what is read from each model file,
Building a project (--allow-build) for why a downloaded
repository is never built.
Give loom project, loom model or loom generate the http or https URL
of a Git repository, or of one of its web pages, and Pitloom fetches the
repository shallowly into a temporary directory, reads the Python project in it
(or, for loom model and for loom generate on a folder with models and no
project, an AI model file; see Model files) and writes the
SBOM. The directory is removed afterwards (one that cannot be fully removed,
such as a file still held open on Windows, is one WARNING:, not an error:
the SBOM is already written), and a message that would name it says
<checkout> instead, so two runs print the same text. It needs the git
program.
loom project https://gitlab.com/group/project # the default branch
loom project https://github.com/owner/repo/tree/v1.2/src # a tag and a folder
loom project https://codeberg.org/owner/repo/src/branch/main/svc/api
loom generate https://labs.etsi.org/rep/ocf/capif/-/tree/staging/services/register -o sbom.json
loom model https://github.com/owner/repo/blob/main/models/m.keras # one model filePrefer the repository's clone URL (the one the host's Clone button
shows): it names the default branch and is never misread. To read one branch,
tag, commit or folder, paste the address of that page instead; the INFO: lines
say what was read. The repository is the part of the path before the page marker, so a
URL prefix (/rep on ETSI's GitLab) and GitLab subgroups work. A branch name
may contain / (feature/x): the split between branch and folder is taken
from the server's own branches and tags, longest match first.
| Platform | Page URL read | Names |
|---|---|---|
| GitLab | …/-/tree/<ref>/<folder>, …/-/blob/<ref>/<file>, …/-/raw/<ref>/<file> |
branch, tag, commit; folder, file |
| GitHub | …/tree/<ref>/<folder>, …/blob/<ref>/<file>, …/raw/<ref>/<file> |
branch, tag, commit; folder, file |
| Gitea, Forgejo, Codeberg | …/src/branch/<ref>/…, …/src/tag/<ref>/…, …/src/commit/<sha>/…, …/raw/branch/<ref>/<file>, …/raw/tag/<ref>/<file>, …/raw/commit/<sha>/<file> |
branch, tag, commit; folder, file |
| Bitbucket Cloud | …/src/<ref>/<folder>, …/raw/<ref>/<file>, …/branch/<ref>, …/commits/branch/<ref>, …/commits/tag/<ref>, …/commits/<sha> |
branch, tag, commit; folder, file |
| SourceHut | …/tree/<ref>/item/<folder>, …/log/<ref> |
branch, tag; folder |
Gitiles (Gerrit's code browser, *.googlesource.com) |
…/+/refs/heads/<ref>/<folder>, …/+/refs/tags/<ref>/<folder>, …/+/<ref>/<folder> |
branch, tag; folder |
| cgit (kernel.org, Launchpad) | …/tree/<folder>?h=<ref>, …/log/?h=<ref>, …/commit/?id=<sha> |
branch, tag, commit; folder |
| Azure DevOps | …/_git/<repo>?path=/<folder>&version=GB<branch> (GT tag, GC commit) |
branch, tag, commit; folder |
| Hugging Face Space or dataset | huggingface.co/spaces/<org>/<name>, …/datasets/<org>/<name>, with …/tree/<ref>/<folder> or …/blob/<ref>/<file> |
branch, tag, commit; folder |
- A page URL naming a file (
bloborraw) reads the folder that holds it, unless the file is an AI model: then it is the model that is read (see Model files). A file page whose path is a folder reads that folder, and a folder page whose path is a file (Bitbucket, SourceHut, Forgejo and Gitiles write both alike) reads the folder holding the file. - Where the ref is in the query (cgit, Azure DevOps) it is exact: it is not
split from the folder, and a
?h=or?id=after a cgit page name is the ref whatever the folder is called (src,tree), unless the path holds a GitLab (-) or Gitea (src/commit|branch|tag) marker, which makes the query stray. An Azure DevOpsversionthat does not start withGB,GTorGCnames no ref: the default branch is read and anINFO:says so. - A commit must be given with its full 40 (or 64) hex digits; a server cannot be asked for an abbreviated id.
- A query or fragment (
?ref_type=heads,#readme) is ignored. - A tag and a branch with one name: a
src/tagpage takes the tag, any other page the branch. - A URL ending in
.gitis always a repository. GitLab's/-/marker is read first, so a group calledsrcortreeis no problem there; elsewhere, for a group or project calledsrc,treeorblobafter the second path segment, Pitloom tries the page reading first and then, when the server says the repository is not found, the whole URL as the repository. - A Hugging Face model address (
huggingface.co/<org>/<name>, alsohf.coandwww.forms) is not a Git repository for Pitloom:loom modelreads it, andloom projectrefuses it with a message namingloom model. A Space or dataset (huggingface.co/spaces/...,.../datasets/...) is a Git repository and is fetched like any other (Git LFS files stay pointers; see below). A Space with nopyproject.toml,setup.cfgorsetup.pyhas no Python project to read, andloom projectsays so (namingloom modelwhen the folder holds files that may be models). - Not read as a file:
raw.githubusercontent.comis a file host, not a repository page, but its URL is taken as a repository: the whole URL is cloned and fails (git.clone-failed). Use thegithub.combloborrawpage of the file instead. A Hugging Face/resolve/file link of a model (huggingface.co/<org>/<name>/resolve/main/<file>) is read as the Hub model<org>/<name>: the file part is dropped and no model file is read. The/resolve/link of a Space or a dataset is taken as a repository and fails asraw.githubusercontent.comdoes: give the repository address. - A PyPI address is not a Git URL:
pypi.org,www.pypi.org, any other*.pypi.orghost andpypi.python.orgare never cloned.loom wheel,loom projectandloom generateread a project or release page there (https://pypi.org/project/<name>/; see SBOM from a PyPI URL), andloom modeland the library's Git functions refuse one with a message naming the right call (pypi-url-unusable). A link to a file onfiles.pythonhosted.orgis a PyPI URL too: never cloned, and refused byloom wheelandloom projectwith the release page to give instead. - A host is written in plain ASCII (an international name in its
xn--form): a host with a non-ASCII character or a percent-encoding is refused before git runs (url-unsafe/host-spelling), since git would resolve it to a host the URL's text does not spell; so is a host holding a character no host name holds (=,!,;, white space, a leading-or.), the shape of an option or of a setting smuggled into git's command line, and a name in brackets ([v1.x]), which would lose its brackets and name a DNS host. In brackets only an IPv6 address passes ([::1],[::ffff:1.2.3.4]); one with a zone id ([fe80::1%25eth0]) is refused too. - Refused with a message (see below): hosts that need a login,
ssh://,git://,file://and scp-styleuser@host:pathaddresses.
Fetched with loom from a real server, on 2026-10-21 and 2026-10-23 (the live tests in
tests/extract/remote/test_git_platforms_live.py repeat these when run with
network access):
| Platform | Server | Forms fetched |
|---|---|---|
| GitLab | gitlab.com |
bare URL (redirected to .git), /-/tree/ page |
| Forgejo | codeberg.org |
bare URL, /src/branch/ page, file page, /src/tag/ page |
| Gerrit | review.opendev.org |
bare URL |
| Gitiles | pigweed.googlesource.com |
/+/refs/heads/<branch>/<folder> page |
| cgit | git.kernel.org |
bare URL, /tree/<folder>?h=<branch> page |
| Azure DevOps | dev.azure.com |
bare URL, ?path=<folder>&version=GB<branch> page |
| Hugging Face Space | huggingface.co/spaces/... |
bare URL, /tree/<branch> page |
| Gitea | gitea.com |
/src/branch/<branch>/<folder> page |
| GitHub | github.com |
bare URL, /tree/ page |
Also fetched by hand on 2026-10-23, and not repeated by the live tests (they keep one or two cases per platform, so an unrelated host's outage cannot block a release):
- Bitbucket Cloud (
bitbucket.org, 2026-10-23,zzzeek/sqlalchemy): the bare URL and/src/<branch>/<folder>are in the live tests; a file page,/branch/<ref>and/commits/tag/<ref>were fetched by hand. A repository that does not exist answers like one that needs a sign-in. Bitbucket serves a path below the repository as the default branch, so Pitloom reads these page forms itself (/branch/x,/commits/<sha>) rather than let a URL it did not recognise fetch the default branch without a word. - SourceHut (
git.sr.ht, 2026-10-23,~sircmpwn/scm.sr.ht): the bare URL is in the live tests;/tree/<ref>/item/<folder>, a file page and/log/<ref>were fetched by hand. - Azure DevOps (2026-10-23,
mseng/PipelineTools): the server answers--filter=blob:limitwith HTTP 400. Pitloom asks again without the filter (anINFO:says so), also for a tag or commit page; a size cap, where one is set (see below), still bounds the transfer. - GNU Savannah: the web pages (
/cgit/…,/gitweb/…) redirect to hosts that answered 502 when tried; only the clone URL was fetched. - Gogs: not tried live (the public demo,
try.gogs.io, holds no repository with commits). Its page form,…/src/<ref>/<folder>, is the one Bitbucket uses and is parsed. - Self-hosted GitLab with a URL prefix:
labs.etsi.org/rep(ETSI),code.europa.eu,gitlab.opencode.de,forge.apps.education.fr,framagit.organdgitlab.cern.chwere fetched by hand likegitlab.com; so wascode.overheid.nl(Forgejo). A Gitea under a prefix was not found to try; the repository is the path before the marker, so a prefix does not matter to the parser.
What a platform answers differs: every GitLab sends a redirect from
group/project to group/project.git, which Pitloom follows; Forgejo, Gitea,
GitHub and Bitbucket serve the bare URL as it is.
Beyond live servers, the whole path (redirect, branch, folder, tag, commit,
.git, refusals) runs in the test suite against a local Git server over smart
HTTP (git http-backend) that answers like GitLab does.
A URL can name an AI model instead of a project: a blob or raw page of a
model file (also a src/<ref>/<file> page of Forgejo, Codeberg or Bitbucket,
and a SourceHut blob page), or a tree page (or the repository itself) of a
folder that holds one. The SBOM is then the model SBOM loom model writes for a local file,
whatever the format (CRFsuite, fastText, GGUF, HDF5, Keras, NumPy, ONNX,
PyTorch, PT2, Safetensors). Which command reads which URL:
| Command | A model file URL | A folder URL (or the repository) |
|---|---|---|
loom generate <url> (and generate()) |
the model | the project if the folder has one, else its one model file |
loom model <url> |
the model | its one model file, even beside a project |
loom project <url> |
the folder's project | the project; a folder with models and no project is refused (git.no-project), naming loom model and loom generate |
- A model file URL wins over a project in the same folder. A file URL whose
name no model file has (
blob/.../pyproject.toml,README.md) and that is not a model, or is missing or a link, reads the folder as before, with oneINFO:;loom modelrefuses it. A file named as a model (.gguf,.onnx,.bin, ...) that is not one (empty, or of no supported format) is refused by both, asloom model <file>refuses it locally. - A folder is read non-recursively: only the named folder, and for the
repository itself only the files at its root. A model in a subfolder needs
that folder's URL or the file's. A folder of more than 1000 files whose
names could be models is not read (one
over-capWARNING:) and is refused (more than 1000 files that could be AI models, none read;model-ambiguous/over-cap). - One model per SBOM. A folder with several model files is an error
(
model-ambiguous): oneINFO:per file names them, sorted, and you give the URL of one file. A folder with neither project nor model is an error (project-or-model-not-found; the error code isgit.no-projectonly when the repository has subprojects, which the message names; an empty or README-only repository givesproject-or-model-not-foundwith nogit.*code).loom model <url>on such a folder saysnot an AI model file of a supported format(model-wrong-format) instead, as for a local path that is not a model. A named file with a model suffix that is not in the repository, or is a link (not followed), isgit.path-not-found(No file '<path>' in the repository at that branch. [input-not-found]); forloom model, any named file is.loom project <url>on a folder with models and no project saysERROR: loom project: ... No pyproject.toml, setup.cfg, or setup.py found in <url>; it holds files that may be AI models ... [project-not-found/model-files]. - A name is read as the repository spells it, and stays inside the clone.
An encoded slash between plain names (
models%2Fm.keras) is a path inside the folder (heremodels/m.keras). A URL segment that decodes (%2F) to a part.or.., an empty part, a backslash, a NUL or.git(any case, trailing dots or spaces,git~1, an NTFS stream such as.git::$DATA) is refused (Invalid path in URL,git.url-invalid), and a name that does not match a file on disk letter for letter is "not found" on every operating system, also where the file system ignores case..gitmodules,.gitattributes,.gitignore,.githubandfoo.gitstay valid names. A link named in ablobURL is not followed and has its own line underinput-not-found. A named FIFO or other special file is refused, never opened. - A file is a model by its content, not its name: a GGUF file named
m.datis recognised as GGUF when its URL is given, and listed without metadata (the GGUF reader is not run on a download: next item). A folder's candidates are chosen by the suffixes the scan knows, then confirmed by their content. - Some readers are not run on a download. The readers
of fastText, HDF5 and ONNX files open the file with a C/C++ library, the
PyTorch (
.pt,.pth) reader parses a pickle, and the GGUF reader runs a parsing loop that a crafted file can make very slow or very large: a hostile file could crash, hang or exhaust them in memory. A model of one of these formats that a model SBOM from a Git URL describes, or that the build file list of a project from a Git URL holds, is listed with its name, format and hash only, and oneINFO:per SBOM says so. Keras, Safetensors (with its Rust library, read in full on purpose), NumPy, CRFsuite and PT2 files are read in full. To read the others from a repository you trust, pass--trust-model-files(librarytrust_model_files=True, Action inputtrust-model-files): it lifts only this gate, and the repository's own[tool.pitloom]is still ignored. Cloning the repository (with Git LFS, when it stores the model there) and runningloom model <file>orloom project <dir>on the copy reads them too, but also trusts the repository's configuration and build file list. The gate covers a folder read as a project too (loom project, orloom generateon a folder withpyproject.toml,setup.cfgorsetup.py); a local project directory is not gated. - Git LFS pointers are refused. A model file that is a pointer (LFS is off
for the clone) is an error that gives the pointer's
oidand size and says to clone with Git LFS and run on the file. In a folder, pointers beside a model are counted in oneWARNING:; a folder of pointers only is refused as the first of them, with no warning. - The SBOM names the file by its own name, and every message by its path in
the repository: no temporary path is in the output, so two runs of one URL
and commit give the same SBOM for a fixed creation time.
loom model <url>writes<file name>.spdx3.jsonto-oor the current directory, never into the checkout. --offlineis an error forloom model <url>too: nothing is fetched.- Only a Git repository is read this way. A Hugging Face model (not Space or dataset) address is read through the Hub, which reads the model card and repository metadata and never opens a weights file: see AI model formats.
- A downloaded repository is untrusted. Its own
[tool.pitloom]settings are ignored (INFO: Git source: the repository's own [tool.pitloom] settings are ignored (untrusted) ... [config-unsafe];--config FILEis yours and applies), and--allow-buildis reported as having no effect. A discovery failure shows only the exception type ("text not shown for a downloaded repository"), and a line of the repository's requirements file is replaced by<a line of the downloaded repository, not shown>. - The repository's own build-time code is not run while its files are
listed. In a clone, these settings are ignored, with one
WARNING:naming the file and the settings (config-unsafe/build-code): Hatchling metadata hooks (pyproject.tomlandhatch.toml), setuptoolscmdclassand anattr:version Pitloom cannot read statically, and PDM hooks (pdm_build.py,custom-hook,run-setuptools). The[global]section ofsetup.cfgis not applied either (globalis named among the settings). Discovery does not import repository code through the working directory ('', relative and in-clonesys.pathentries are removed while it runs). Hatchling build hooks, aversionofsource = "code"alone, PDMsource = "call", a Flit dynamic version,setup.py(read as a syntax tree), a Poetry build script and in-tree backends do not run the repository's code either. A local project is not changed: it still runs its own hooks, as a build would. - Credentials in the URL (
https://user:token@host/...) never reachgit's command line, which any user of the machine can read, nor the clone's.git/config: Pitloom takes them out of the URL and hands them togitthrough a credential helper of its own, for that host alone, in the environment of the calls that contact the server. For such a URL every credential helper and ask-pass program of yours (a keychain, Git Credential Manager,gh,~/.git-credentials) is switched off: none is asked, and nothing is stored in one. A URL without credentials is fetched asgit clonefetches it, with your own helpers or.netrc, the better place for a credential.gitnever prompts on the terminal (a private repository it cannot sign in to fails at once), and theGIT_TRACE*andGIT_CURL_VERBOSEvariables of the calling environment, which can write whatgitsends, are not passed on. A secret in the URL's query or fragment (?token=,?access_token=,#token=) is never given togit: the query and fragment are dropped before the clone URL is built (INFO: ... (query and fragment ignored)), sogitcannot sign in with one either. This is how the URL you give is fetched and shown (masked) in messages; it is not a rewrite of the SBOM: a URL field of the SBOM that holds a credential is warned of, or refused in therefusemode, as on every target (Credentials in URLs).- A plain
http://URL with credentials is fetched with them, andWARNING: URL=<url>: credentials are sent in clear over http; use https [credentials-unsafe/http-clear]says so once. - Credentials holding a line break (
%0A,%0D) are not sent: the URL is fetched without them, withWARNING: URL=<url>: credentials holding a line break are not sent to git [credentials-unsafe/git-line-break]. - A URL whose user information
gitwould read differently from Pitloom (an empty host after the@, for one) is refused beforegitruns:ERROR: loom project: URL='https://***:***@/o/r': user information cannot be taken out of the git command line; not fetched [credentials-unsafe/git-userinfo]. So is a user name or password holding a NUL (%00), which cannot be handed togit. A malformed host or port is refused as an invalid URL (git.url-invalid). Other control characters (a tab, an escape) are sent as typed.
- A plain
- The clone is shallow, asks the server to leave out blobs over 10 MiB that the
checkout does not need (a server without partial clone sends them) and never
follows a redirect on its own: Pitloom follows the Git server's redirect itself, one hop at a time
(at most 5, 60 s for all probes), and a caller can check each hop first
(
check_url=in the Python API; Lumina uses it as its address guard). githas 10 minutes for all its calls together and 8 MiB of output (and of error text) per call. Ctrl-C stopsgitand what it started.gitruns with only the http(s) transports, git-lfs off (a repository's LFS settings could name another host; LFS files are not downloaded) and withoutGIT_DIR-style variables of the calling environment, nor those that run another program or turn a check off (GIT_EXEC_PATH,GIT_SSH,GIT_SSH_COMMAND,GIT_SSH_VARIANT,GIT_PROXY_COMMAND,GIT_TEMPLATE_DIR,GIT_SSL_NO_VERIFY,GIT_CONFIG,GIT_REDIRECT_STDIN/STDOUT/STDERR). Your own configuration is read asgit clonereads it (HOME,GIT_CONFIG_GLOBAL,GIT_CONFIG_SYSTEM,GIT_CONFIG_NOSYSTEMare kept), and so are your ask-pass programs (GIT_ASKPASS,SSH_ASKPASS,core.askPass) unless the URL carries credentials.- Git LFS files are pointers. LFS is off, so a file kept in LFS is a small
pointer file in the checkout, and Pitloom never fetches its content. The SBOM
lists it with the pointer's
oidas its SHA-256 (no SHA-512; the hash comment says the content was not read, and the file's provenance isMethod: lfs_pointer), so the hash is the same aftergit lfs pull. The stated size is only recorded in that comment. A pointer named like an AI model (.onnx,.gguf, ...) is listed as a file only, with no AI package; a pointer named by its own URL is an error (see Model files). No content type, licence or copyright comes from the pointer text. OneWARNING:per SBOM names the first pointer (and, for more than one, the count):clone with git lfs, then run on the directory. Runloom projecton that directory for the content. Most model repositories on Hugging Face, and many on GitLab and Codeberg, keep their weights in LFS. - 512 MiB of disk by default. The fetch is stopped once the checkout
takes more disk than
--max-download-bytes BYTES([tool.pitloom] max-download-bytesfrom--config, librarymax_download_bytes=; the setting that caps a PyPI download):ERROR: loom <command>: the repository is larger than the <limit>-byte max-download-bytes cap; git clone was stopped, error codegit.too-large, message codeover-cap, and no SBOM. The 10 MiB filter leaves out only large blobs the checkout does not need; a large file in the checked-out tree (a model of 12 MiB, say) is fetched and counts. Raise the cap for one run when you trust the repository. - A cloned project's build file list (Hatchling
force-include, setuptoolspackage-dir,packages.find.whereorpackage-datawith an absolute or..path, say) keeps only files inside the repository. Such an entry is dropped before the files are discovered, oneWARNING:per entry as written (file-unreadable/outside-repository), and a file found outside after discovery is only counted, in one more line; so a host file is never listed, hashed or read. The same holds for afile:directive,license-files,packages/py_modulesand Poetrypackages/include/excludenaming a path outside the clone. Files under the clone's own.gitare never read or listed. A local project is not changed. - Not every build file list is checked before discovery: MANIFEST.in, PDM, Poetry and Flit entries are still walked, and a file outside the repository is dropped afterwards (and counted).
- A symbolic link in the checkout that leads out of it or into its
.git, and every link to a folder, is removed before the project is read (anINFO:counts them), so a host file is never read or hashed. File discovery in a clone stops after 60 seconds (over-capWARNING:, file list not read). Blocks offetch_git_projectthat overlap each keep their own confinement. - A relative
--id-registryis relative to where you runloom, not to the checkout. --offlineforbids the fetch: it is an error, not a fallback, forloom project,loom modelandloom generatealike (URL=<url>: network access is forbidden (offline mode); nothing fetched,offline-unusable, the code a PyPI URL or a Hugging Face model refuses with too).- A clone that cannot reach the server (a name that does not resolve, a
refused, reset or timed-out connection, a TLS failure, an HTTP 5xx answer)
ends
git <command> failed: <git's reason>; nothing fetched(download-network-failed); one that runs out of time,git <command> did not finish within <seconds> seconds; stopped(download-timeout): the codes a PyPI or Hugging Face request that fails the same way carries. Any other git failure (a repository, branch or sign-in the server refused) carries no code; its message is git's own. Network failures are told from other git failures by git's ownfatal:anderror:lines (git runs withLC_ALL=C), never by a name, URL or server text inside them. - An empty repository is an error that says so.
- The output file is named from the project (or the model file), as for a
local one, and written to the current directory.
-o -writes the SBOM to stdout.
Every URL that is changed, refused or not followed is said, never silently:
| Level | Message | When |
|---|---|---|
INFO: |
Git source: <url> redirected to <url> |
the server redirected: both URLs |
INFO: |
Git source: <url> names repository <url>, branch <ref>, folder <path> |
the URL named more than a repository (or was cleaned) |
INFO: |
Git source: <url> is not a repository; trying <url> |
a group called src/tree/blob: the whole URL is tried |
INFO: |
Git source: <path> is a folder, not a file; reading it |
a file page whose path is a folder |
INFO: |
Git source: <path> is a file, not a folder |
a folder page whose path is a file: the file is read as the one the URL named (a model file, or else its folder) |
INFO: |
FILE=<file>: not an AI model file; reading its folder |
the file URL named a file whose name no model has, and that is not a model or is missing (loom generate) |
INFO: |
FILE=<file>: no Python project; reading this AI model file |
loom generate on a folder with no project and one model |
INFO: |
FILE=<file>: the one AI model file; reading it |
loom model on a folder with one model |
INFO: |
FILE=<file>: one of several AI model files, then ERROR: <url>: several AI model files (N files); name one file |
a folder holds several models (one line per file; model-ambiguous) |
INFO: |
AI models from a Git URL in these formats are listed without metadata, their reader not being run on a downloaded file: <formats>; pass --trust-model-files for a repository you trust |
a model in a format whose reader is not run on a download |
ERROR: |
<url>: no Python project (pyproject.toml, setup.cfg or setup.py) and no AI model file of a supported format; name a project folder or a model file |
neither a project nor a model (project-or-model-not-found) |
ERROR: |
<file>: header is a Git LFS pointer, content not fetched (oid sha256:<oid>, size <size>); clone with git lfs, then run on the file |
the named model file is an LFS pointer |
INFO: |
Git source: the server rejected the blob filter; fetching without it |
the server cannot leave out large blobs (Azure DevOps) |
INFO: |
Git source: could not check <url> for a redirect (<reason>); asking git directly |
the redirect probe failed |
INFO: |
Git source: $ git ... |
each git call; a URL's credentials are not among its arguments |
WARNING: |
Git source: <url> redirected to <url>, which is not followed: <why> |
a redirect to another scheme, or to a page that is not a repository |
INFO: |
Git source: <n> symbolic link(s) leading out of the repository, into its .git directory or to a folder were not followed |
such links were removed |
WARNING: |
Git source: <reason> |
any refusal, as well as its ERROR:: an ssh, git, file or scp-style address, --offline, too many redirects, a redirect the caller's check refuses, an unknown ref or folder, a failed git call |
WARNING: |
FILE=<file>: build-time code of the downloaded repository is not run; <settings> ignored [config-unsafe/build-code] |
a cloned project's build settings would run the repository's own code (once per SBOM) |
WARNING: |
FILE=<entry>: outside the downloaded repository; not read [file-unreadable/outside-repository] |
a build file list entry, as written, names a path outside the repository (one line per entry) |
WARNING: |
DIR=<dir>: larger than the 60-second file-discovery cap; file list not read [over-cap] |
file discovery in a clone ran over its time cap |
WARNING: |
listed files outside the downloaded repository<count>; not read [file-unreadable/outside-repository] |
files found outside after discovery (counted, not named) |
ERROR: |
Invalid path in URL: <url> (git.url-invalid) |
a branch or path part that decodes to ./.., an empty part, a backslash, a NUL or .git |
WARNING: |
Build: <url>: --allow-build has no effect for a remote repository ... |
a build flag |
ERROR: |
<frame>: ... |
the run could not finish (the frame names the command) |
A URL or ref in a message is shown without credentials (https://***:***@host,
***:***@host:path for an scp-style address, and the value of each query or
fragment parameter named like a secret, as listed in
Credentials in URLs:
?private_token=***, and an access token's shape anywhere: ghp_***)
and with control characters escaped. Another secret in a parameter with
another name is not recognised. What a server or git says
is reduced to one line (its fatal:, error: and remote: lines), so it
cannot add a tagged line of its own.
If the repository has no Python project at its root but has some in folders, the error names them (up to five) and asks for the URL of one of them.