What is `.cache/uv/git-v0/db/bee914b2cfb37cee`?

[stdedos]

Question

Hello there,

as I was doing some wide grep search in my computer for a term, I saw a lot of results for my term in .cache/uv/git-v0/db/bee914b2cfb37cee

and these results

~/.cache/uv/git-v0/db/bee914b2cfb37cee$ (master #) git status
On branch master

No commits yet

nothing to commit (create/copy files and use "git add" to track)
~/.cache/uv/git-v0/db/bee914b2cfb37cee$ (master #) ls -lah
total 12K
drwxrwxr-x 3 stdedos stdedos 4,0K Νοε  14 09:46 .
drwxrwxr-x 7 stdedos stdedos 4,0K Νοε  14 10:13 ..
drwxrwxr-x 7 stdedos stdedos 4,0K Φεβ  18 10:45 .git

Is there ... a tl;dr description one can give me, without me reading Rust code? (which ... btw I haven't learned so far? 🫣)

Platform

No response

Version

No response

[woodruffw]

Hi @stdedos, it's one of uv's cache buckets. You can see the other ones here, in the CacheBucket enum:

uv/crates/uv-cache/src/lib.rs

Lines 1179 to 1202 in 585dac1

	impl CacheBucket {
	fn to_str(self) -> &'static str {
	match self {
	// Note that when bumping this, you'll also need to bump it
	// in `crates/uv/tests/it/cache_prune.rs`.
	Self::SourceDistributions => "sdists-v9",
	Self::FlatIndex => "flat-index-v2",
	Self::Git => "git-v0",
	Self::Interpreter => "interpreter-v4",
	// Note that when bumping this, you'll also need to bump it
	// in `crates/uv/tests/it/cache_clean.rs`.
	Self::Simple => "simple-v20",
	// Note that when bumping this, you'll also need to bump it
	// in `crates/uv/tests/it/cache_prune.rs`.
	Self::Wheels => "wheels-v6",
	// Note that when bumping this, you'll also need to bump
	// `ARCHIVE_VERSION` in `crates/uv-cache/src/lib.rs`.
	Self::Archive => "archive-v0",
	Self::Builds => "builds-v0",
	Self::Environments => "environments-v2",
	Self::Python => "python-v0",
	Self::Binaries => "binaries-v0",
	}
	}

This bucket gets populated when Git dependencies are resolved, and contains entries similar to the other cache buckets: source artifacts retrieved from the remote resource (a git repo in this case), as well as metadata and wheel build artifacts.

(If you do want to dig into the Rust code, the bulk of that cache population/use happens in SourceDistributionBuilder::git.)

[stdedos]

It's ... weird

uv/crates/uv-distribution/src/source/mod.rs

Lines 109 to 253 in 585dac1

	pub(crate) async fn download_and_build(
	&self,
	source: &BuildableSource<'_>,
	tags: &Tags,
	hashes: HashPolicy<'_>,
	client: &ManagedClient<'_>,
	) -> Result<BuiltWheelMetadata, Error> {
	let built_wheel_metadata = match &source {
	BuildableSource::Dist(SourceDist::Registry(dist)) => {
	// For registry source distributions, shard by package, then version, for
	// convenience in debugging.
	let cache_shard = self.build_context.cache().shard(
	CacheBucket::SourceDistributions,
	WheelCache::Index(&dist.index)
	.wheel_dir(dist.name.as_ref())
	.join(dist.version.to_string()),
	);
	let url = dist.file.url.to_url()?;
	// If the URL is a file URL, use the local path directly.
	if url.scheme() == "file" {
	let path = url
	.to_file_path()
	.map_err(|()| Error::NonFileUrl(url.clone()))?;
	return self
	.archive(
	source,
	&PathSourceUrl {
	url: &url,
	path: Cow::Owned(path),
	ext: dist.ext,
	},
	&cache_shard,
	tags,
	hashes,
	)
	.boxed_local()
	.await;
	}
	self.url(
	source,
	&url,
	Some(&dist.index),
	&cache_shard,
	None,
	dist.ext,
	tags,
	hashes,
	client,
	)
	.boxed_local()
	.await?
	}
	BuildableSource::Dist(SourceDist::DirectUrl(dist)) => {
	// For direct URLs, cache directly under the hash of the URL itself.
	let cache_shard = self.build_context.cache().shard(
	CacheBucket::SourceDistributions,
	WheelCache::Url(&dist.url).root(),
	);
	self.url(
	source,
	&dist.url,
	None,
	&cache_shard,
	dist.subdirectory.as_deref(),
	dist.ext,
	tags,
	hashes,
	client,
	)
	.boxed_local()
	.await?
	}
	BuildableSource::Dist(SourceDist::Git(dist)) => {
	self.git(source, &GitSourceUrl::from(dist), tags, hashes, client)
	.boxed_local()
	.await?
	}
	BuildableSource::Dist(SourceDist::Directory(dist)) => {
	self.source_tree(source, &DirectorySourceUrl::from(dist), tags, hashes)
	.boxed_local()
	.await?
	}
	BuildableSource::Dist(SourceDist::Path(dist)) => {
	let cache_shard = self.build_context.cache().shard(
	CacheBucket::SourceDistributions,
	WheelCache::Path(&dist.url).root(),
	);
	self.archive(
	source,
	&PathSourceUrl::from(dist),
	&cache_shard,
	tags,
	hashes,
	)
	.boxed_local()
	.await?
	}
	BuildableSource::Url(SourceUrl::Direct(resource)) => {
	// For direct URLs, cache directly under the hash of the URL itself.
	let cache_shard = self.build_context.cache().shard(
	CacheBucket::SourceDistributions,
	WheelCache::Url(resource.url).root(),
	);
	self.url(
	source,
	resource.url,
	None,
	&cache_shard,
	resource.subdirectory,
	resource.ext,
	tags,
	hashes,
	client,
	)
	.boxed_local()
	.await?
	}
	BuildableSource::Url(SourceUrl::Git(resource)) => {
	self.git(source, resource, tags, hashes, client)
	.boxed_local()
	.await?
	}
	BuildableSource::Url(SourceUrl::Directory(resource)) => {
	self.source_tree(source, resource, tags, hashes)
	.boxed_local()
	.await?
	}
	BuildableSource::Url(SourceUrl::Path(resource)) => {
	let cache_shard = self.build_context.cache().shard(
	CacheBucket::SourceDistributions,
	WheelCache::Path(resource.url).root(),
	);
	self.archive(source, resource, &cache_shard, tags, hashes)
	.boxed_local()
	.await?
	}
	};
	Ok(built_wheel_metadata)
	}

I see

            BuildableSource::Dist(SourceDist::DirectUrl(dist)) => {
                // For direct URLs, cache directly under the hash of the URL itself.

but then I see a .git - which signifies a git-repo.

---

Idk - tl;dr this discussion started as: I see only bee914b2cfb37cee, bee914b2cfb37cee/.git/ - but grep matches available text inside the .git folder. it might've been nicer if, the (assuming) git-repo cloned had a name, instead of a hash.

ofc that's not possible for direct URLs - like the example I can read above - but if the git repo name was ... somewhat unique?

It's also weird that the repo is copied - but NOT checked out. Or it has only an initialized git repo - but not even a root commit (?)

---

AS ALWAYS, thank you for taking the time to share knowledge 😊 ❤️