Repository navigation
Act on listed identities in expansion, lookups, invalidation and fan-outs (GH-1402) - #1414
Conversation
…outs (GH-1402) rm(), chmod(), cat() and du() parsed the names of the entries that their expansion listed, so a key that ends in what looks like a version ID query, such as "a/x?versionId=v1", was taken as that version of "a/x": rm() deleted the version and left the key, chmod() updated the version twice over, cat() read the version, and du() looked the version up. - _expand_paths() expands as expand_path() does and returns, with each name, the path that it names: a path that the caller passes is parsed once, and a listed entry keeps its bucket and key (_entry_path). A recursive glob expands below each match by its key prefix (_find_under) instead of finding below its name. expand_path() returns the same names. - rm() deletes, chmod() updates, cat() reads, and du() looks up those paths, on both filesystems; the asynchronous _cat() and _du() run the typed reads and lookups. - The lookup of an explicit version is cached under (name, "versionId", version_id), so that it no longer shares the string key of a key whose name ends in the same query. info(), exists(), _head_object() and _ls_from_cache() take the cache key from the typed path (_lookup_cache_key). - _invalidate() invalidates a typed path and the directories above it, named as they are listed. Delete batches and the file writers pass the paths they know. invalidate_cache() of a version-qualified path also invalidates the key that ends in its query. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
…H-1402) Self-review repairs: - du() of a path with a version looked up the current object, because the entry of the version names its key alone. _find_paths() returns the requested path for the version and the bucket and key of the other entries, which du(), chmod() and the expansion use. - cat_file() looks up the size of a negative offset or an empty range with info() of the path that it was given again; only the reads of listed paths use the typed lookup. - The typed lookup cores take the version in the path (_path_info(), the typed core of info() renamed from _info() so that it is not taken for an fsspec coroutine, and _head_object()). - expand_path() returns the names of the sorted expansion once without sorting them again. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Review repairs. The expansion and find() typed every path, also those that the caller passed, which changed how they are read and looked up: cat() no longer called cat_file() and exists() and find() no longer called info() for them, an invalid path such as "s3://" raised before anything ran, and cat() read both an explicit version and a listed key of the same name but returned one of them. - _expand_paths(), _find_paths() and _find_under() name the paths that the caller passed by the strings as given, which cat() reads with cat_file(), and rm() and chmod() parse, as before; only the entries that a listing returns name their bucket and key. find() and du() look the path itself up with info() again. - cat() and the async _cat() read each name once, as the first path that it names, since the contents are returned by name. - The tests that cache the lookup of a version, invalidate it, or patch the lookups and the expansion of cat() and chmod() follow the typed cache keys and the private expansion. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
…ne (GH-1402) Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
| ) | ||
| ) | ||
|
|
||
| def _expand_paths( |
There was a problem hiding this comment.
Self-review round one (implementation behavior): FINDINGS, repaired in 868d961, f2a04cb and 733d4a0
Scope: the full diff 6c37452b13b8f732ac4f064fd05118d5fc26545a..572f5fb1. It covers:
pyathena/filesystem/s3.pyands3_async.py;tests/pyathena/util.py;- the new tests.
Passes:
- /code-review. It ran both the PR head and master against the fake store and reproduced its findings.
- A cleanup pass for reuse, simplification, efficiency and the depth of the fix.
- My own trace of every caller of the expansion and of the lookups.
Findings and repairs:
- Typing the paths that the caller passes changed how they are read and looked up. This broke about 37 existing offline tests. Specifically:
cat()no longer calledcat_file(), andexists()andfind()no longer calledinfo(). Tests that patch them failed or hung: the batch, interrupt andon_errortests ofcat, and the cancellation tests of the async_cat.expand_path("s3://")raisedValueErrorinstead of returning[''].- One invalid path made all of
cat(on_error="omit")raise.
Repair (f2a04cb):_expand_paths(),_find_paths()and_find_under()keep a path that the caller passed as the string it was given. Only the entries that a listing returns carry their bucket and key. Socat()reads a caller's path withcat_file(),rm()andchmod()parse it as before, andfind(),du()andexists()look the path itself up withinfo().
- The tests that assert the old string cache key of a version lookup, or mock
_head_objectwith strings, failed:test_listing_of_version_path_looks_up_the_version;test_invalidate_cache_version_drops_object_path;test_copy_skipped_directory_does_not_conflict.
They now use the(name, "versionId", id)keys andS3Patharguments. The cases for each query spelling and trailing slash are kept.
- A regression that I found myself:
du()of a version path looked up the current object, because the entry of a version names its key alone. Repair (868d961):_find_paths()names the requested path for a version. Tested by thedu-versioncase. - When an explicit version and a listed key share a name,
cat()read both objects but returned one of them. Repair:_first_targets()reads each name once, as the first path that it names, which is the path that the caller passed. - The
cat,chmodand interrupt tests patchedexpand_path()orfind(), which the fan-outs no longer call. They now patch_expand_paths()or_find_paths(), and keep their intent: an interrupt after both reads, and the stopped requests. - Cleanup:
- The sync typed core of
info()is renamed_path_info(), so that it is not taken for an fsspec coroutine. - The unused
version_idparameters of_head_object()and_path_info()are removed. expand_path()no longer sorts its names twice.- Docstrings now describe the typed cache keys.
s3_request_targets()sorts a missing version ID.
- The sync typed core of
Deferred, with reasons:
- Summing
du()sizes from the listing: Act on listed identities in expansion, lookups, invalidation and rm/chmod/cat/du (#1381 step 2) #1402 keeps one lookup per entry, because a synthetic directory can replace an object of the same name. - Moving
_entry_path()and_listing_name()ontoS3ObjectandS3Pathwould widen their public API before Make S3Object a dict subclass and return copies of cached entries #1382 and Consolidate the S3 response models and settle the core results and parameter precedence #1383 redesign them. The helpers encode the filesystem's naming rules. - Sharing the result shaping of the sync
cat()and the async_cat(): the gain is small. invalidate_cache()walks the parents of the literal key again. That walk is needed, since a key such asa/dir?versionId=v1/zhas different parents.- The double parse in
S3PathPairing.delete_paths()is left for step 3 (Act on listed identities in pairing and copy/mv/get (#1381 step 3) #1403), which reworks the pairing.
Validation:
just lintpasses.- The 11 new tests pass. With the source at 6c37452, 10 fail; the
du-versioncase is new. - Each of these mutations fails only its test:
- caching a version under its string;
- invalidating a deleted path by parsing it;
- expanding glob matches by name;
- naming a found version by its entry;
- not clearing the contents of an interrupted
cat().
- The full
tests/pyathena/filesystem/suite against AWS was run in parts, because two background runs were stopped while the machine was low on memory:- the test files other than
test_s3.py: 750 passed, 3 skipped; TestS3File,TestCompressedBufferand the fsspec conformance tests: 370 passed;TestS3FileSystem: 696 passed, 3 skipped.
- the test files other than
| return file | ||
|
|
||
| @staticmethod | ||
| def _lookup_cache_key(path: S3Path) -> str | tuple[str, str, str]: |
There was a problem hiding this comment.
Self-review round two (claims, callers, evidence): CLEAN after the PR body was rewritten for the repairs
Scope:
- the full diff
6c37452b13b8f732ac4f064fd05118d5fc26545a..733d4a0c1265c7409ee50682726e2ef458293daf; - the PR body, the commit messages and the docstrings.
Claims checked:
- The before-state of
rm,chmod,catanddu. With the source at 6c37452, the fan-out cases fail on the operations, keys and version IDs that the PR body lists. - "
expand_path()returns the same names." It now returnslist(dict.fromkeys(...))of the expansion, which is sorted by name. That equals the previoussorted(set(...)). A name that names two paths still appears once. - "The paths that the caller passes still work as path strings."
cat()reads them withcat_file().rm()andchmod()parse them at their use.find(),du()andexists()look the path itself up withinfo(). The existing batch, interrupt andon_errortests ofcatandchmodpass through those seams again, after their patches moved to the private expansion. - "
invalidate_cache()keeps its behavior for strings."- For a version string, the lookup of that version is evicted under its typed key. Before, it was evicted under the four string spellings.
- The object path and the parents are evicted as before.
- The key that ends in the query is evicted as well.
- The rewritten
test_invalidate_cache_version_drops_object_pathcovers every spelling and trailing-slash case of the old test.
- The docstrings of
info(),_get_cached_lookup()and_cache_lookup()described the old string keys. They were corrected in 733d4a0.
Existing callers:
expand_path(),find(),info(),exists(),cat_file()andinvalidate_cache()keep their signatures and outputs._head_object(),_ls_from_cache(),_delete_*()and_chmod_object()are private.- The benchmark harness calls
AioS3FileSystem._info(), the fsspec coroutine, which is unchanged. That is why the sync core is named_path_info().
AWS operator:
- The fan-outs send the same requests as before, except that they now target the listed keys.
du()looks up each entry once, as before, through the same listing caches.- A recursive glob lists the same prefixes below its matches.
- No request is added.
Evidence:
Independent review repairs: - A recursive glob that matches nothing raises FileNotFoundError again, as fsspec's expansion of no paths does, so that rm() deletes nothing. - The expansion below the matches of a recursive glob receives the prefix, and a caller's detail option is accepted. - invalidate_cache() invalidates the name as it is spelled, as before, so that a bucket path with a trailing slash evicts the listing of the common prefix "/", and a key that ends in a version ID query and has no key before it is evicted; a version also evicts its typed lookup. - The async _du() looks up the found entries one at a time again, so a cancellation sends no further lookup. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
| return sorted(out) | ||
| return sorted(out, key=lambda item: item[0]) | ||
|
|
||
| def _expand_unversioned( |
There was a problem hiding this comment.
Independent review (relayed result, Codex): FINDINGS (6), all verified and repaired in f5706ca
Reviewer and run:
- Reviewer: Codex CLI
codex exec, modelgpt-6-astra, reasoning effortmax, read-only sandbox. Session01a1e50b-0ac4-70d3-8cf4-f5d211288ece. - Scope: a detached snapshot of 733d4a0, reviewing
6c37452b13b8f732ac4f064fd05118d5fc26545a..733d4a0c. - The prompt gave the intended contract of Act on listed identities in expansion, lookups, invalidation and rm/chmod/cat/du (#1381 step 2) #1402, but not the PR, the commit messages or earlier findings. The snapshot and the PR worktree were unchanged afterwards.
- This was a static review: the reviewer ran no tests.
Coverage, in the reviewer's words: "sync/async fan-outs; fsspec 2026.9.0 expansion semantics; version-aware and parameterized cache lookups; deletion/writer invalidation; batching, errors and cancellation; changed docstrings and tests."
Findings (all P2), with the repairs:
- Unmatched recursive globs no longer abort deletion. With an existing
bucket/a,rm(["bucket/a", "bucket/missing*"], recursive=True)deleteda, whereas fsspec raisesFileNotFoundErrorbefore deleting.
Repair:_expand_unversioned()raises as fsspec's expansion of no paths does. As on master, the expansion of the paths with a version ID still continues when another path matched. - Async
dukept issuing requests after cancellation. The whole traversal ran in one thread call, so cancelling during the first HeadObject still looked up every remaining entry.
Repair: the async_du()again awaits each lookup on its own, in a thread of the filesystem. - Query-only literal keys escaped public invalidation.
invalidate_cache("bucket/?versionId=v1")left the lookup of the key?versionId=v1cached, because the parsed path has no key.
Repair: see 4. - A trailing bucket slash no longer invalidated its listed spelling.
invalidate_cache("bucket/")parsed both spellings to the bucket and left the listing of the common prefix/(("bucket/", "/")) cached.
Repair, for 3 and 4:invalidate_cache()walks the names as they are spelled again, as master does (_invalidate_name()). A version also evicts its typed lookup (_evict_lookup()), and then the path without the version. - The recursive glob expansion dropped
prefix.expand_path("bucket/a/*", recursive=True, prefix="keep")includeda/keepdir/drop.txt.
Repair:_find_under()receives the prefix below the matches. - Forwarding
detailraisedTypeError.expand_path("bucket/a/*", detail=False)failed.
Repair: the expansion consumes the caller'sdetail.
Tests (offline fake store):
test_rm_of_unmatched_recursive_glob_deletes_nothing(1)test_du_cancellation_sends_no_further_lookupintest_s3_async.py(2)test_invalidate_cache_evicts_the_name_as_given: thebucket/?versionId=v1case (3) and thebucket/case (4)test_expand_path_passes_options_as_fsspec: theprefix-below-matchescase (5) and thedetailcase (6)
With the source at 733d4a0, 6 of these 7 tests fail. The a/x?versionId=v1 case of the invalidation test passes there. It stays, because it is the only test that the key ending in the query of a version path is evicted.
Validation at f5706ca:
just lintpasses.- The
tests/pyathena/filesystem/suite against AWS, run locally in parts:- the files other than
test_s3.py: 1023 passed, 3 skipped; TestS3FileSystem: 702 passed, 3 skipped;TestS3FileandTestCompressedBuffer: 98 passed.
- the files other than
An independent follow-up review of the repair follows.
…GH-1402) Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
| self._evict_lookup(self._lookup_cache_key(path)) | ||
| self._invalidate_name(path.name) | ||
|
|
||
| def _invalidate_name(self, name: str) -> None: |
There was a problem hiding this comment.
Self-review of the independent-review repair (rounds one and two): one simplification applied in d145334; otherwise CLEAN
Scope: 733d4a0c1265c7409ee50682726e2ef458293daf..d145334b1e86e0e62d89d2f49ad473ce6d80749a, the PR body, and the commit messages.
Round one (behavior and implementation):
- Expansion. As on master, the paths with a version ID are expanded first. The rest is expanded with fsspec's semantics:
- An unmatched recursive glob raises. With
maxdepth=1it does not, as in fsspec. - When only paths without a version ID were given and nothing matches,
FileNotFoundErrornames those paths, as fsspec's expansion did on master. detailandassume_literalare consumed from a copy of the keyword arguments.prefixandrefreshare the only options thatfind()reads besidesmaxdepth,withdirsanddetail, and both reach_find_under().
- An unmatched recursive glob raises. With
- Invalidation.
_invalidate_name()evicts, per name, the same keys as master's walk: the lookup, the lookup with parameters, and both listings.- For a version, it additionally evicts the typed lookup and walks the parents of both the path without the version and the path as spelled.
- The second walk only adds evictions, such as those of the directories of a key like
a/dir?versionId=v1/z. _invalidate()for typed paths is unchanged in what it evicts.
- Async
du._du()follows fsspec's_du(): onefind, then one awaited lookup per entry. Each lookup runs through_thread_pool.run(), which the other async methods use for cancellation. - Simplification:
_du_sizes()was left with one caller, so it is inlined intodu()(d145334). Thedutests pass.
Round two (claims, callers, AWS operator):
- The PR body now describes:
- the expansion options;
- the raise for an unmatched recursive glob;
- the per-entry awaits of the async
_du(); - the string walk of
invalidate_cache(); - the new tests and the test counts.
Theinvalidate_cache()docstring was already accurate.
- Callers:
rm([... "missing*"], recursive=True)raises again before deleting, as on master.expand_path(..., detail=...)andexpand_path(..., prefix=...)behave as on master.- No public signature changed.
- AWS operator: the repairs only remove requests. An unmatched recursive glob deletes nothing, and a cancelled async
du()sends no further HeadObject. The prefix narrows the listing below the matches as on master. - Evidence: local runs against AWS only; CI has not run yet (Draft). An independent follow-up review of this repair is next.
Independent review repair: as on master, invalidate_cache() of a version-qualified path also evicts the entries of the keys that end in the query in each spelling that names the version, such as the listing of the directory bucket/a/dir?versionID=v1 for bucket/a/dir?versionId=v1. The async _du() docstring says that a cancellation stops the lookups of the entries, not the traversal of find(). Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
| # keys that end in the query in each spelling that names the | ||
| # version, and the object path without the version. | ||
| self._evict_lookup((base, _VERSION_CACHE_KEY, version_id)) | ||
| for query in ("versionId", "versionID", "versionid", "version_id"): |
There was a problem hiding this comment.
Independent follow-up review (relayed result, Codex): FINDINGS (2). 1 was verified and repaired in 99c1b79; 2 is pre-existing
Reviewer and run:
- Reviewer: Codex CLI
codex exec, modelgpt-6-astra, reasoning effortmax, read-only sandbox. Session01a1e523-01a5-7a53-a45d-2df1722bfd9d. - Scope: a detached snapshot of d145334, reviewing
733d4a0c1265c7409ee50682726e2ef458293daf..d145334b, with the surrounding code and master (6c37452) as the reference behavior. - The prompt stated the intended behavior, but not the PR or the earlier findings. The snapshot and the PR worktree were unchanged afterwards.
- This was a static review: the reviewer ran no tests.
Coverage, in the reviewer's words: "expansion options/errors and version ordering, affected callers, master cache evictions, sync/async du, docstrings, and new-test contracts."
Findings:
- P2: alternate query spellings retained stale listings. With
("bucket/a/dir?versionID=v1", "/")cached,invalidate_cache("s3://bucket/a/dir?versionId=v1")left that listing in place. Master evicts the entries of all four accepted spellings of the query.
Verified: a regression, already present before the first repair, because 733d4a0 invalidated only the spelling given.
Repair: for a version,invalidate_cache()invalidates the names that end in the query in each spelling (versionId,versionID,versionidandversion_id), as master does, and then the path without the version. The docstring says so.
Test: the("bucket/a/dir?versionID=v1", "/")case oftest_invalidate_cache_evicts_the_name_as_given. It fails with the source at d145334. - P2: a cancellation still permits requests during discovery. If
_du("s3://bucket/missing")is cancelled while its listing is pending,_find_paths()still looks up the path itself afterwards.
Pre-existing, not changed by this PR. On master, the async_find()runs the whole sync_find()in one_thread_pool.run()call, which fsspec's_du()awaited. So a cancellation during discovery did not stop the lookup that the traversal makes after its listing there either.
This PR only changes the lookups of the found entries, which again stop at a cancellation. The broader claim was mine, in the review prompt.
Correction: the_du()docstring now says that a cancellation sends no further lookup of an entry. Making the traversal offind()stop between its own requests would be a change to the async_find(), outside Act on listed identities in expansion, lookups, invalidation and rm/chmod/cat/du (#1381 step 2) #1402.
Validation at 99c1b79:
just lintpasses.TestS3FileSystem: 703 passed, 3 skipped.test_s3_async.py,TestS3FileandTestCompressedBuffer: 328 passed, 3 skipped.- The rest of the filesystem suite is unaffected by this repair, since nothing there depends on
invalidate_cache(). It passed at f5706ca: 1023 passed, 3 skipped.
Self-review of this repair:
- Behavior: only
invalidate_cache()of a version-qualified string changed. It evicts at least what master evicts; walking the parents of the alternate spellings evicts nothing extra unless the version ID contains/. - Claims: the PR body's description of
invalidate_cache()is updated to name each spelling.
A further independent follow-up of this repair follows.
| # keys that end in the query in each spelling that names the | ||
| # version, and the object path without the version. | ||
| self._evict_lookup((base, _VERSION_CACHE_KEY, version_id)) | ||
| for query in ("versionId", "versionID", "versionid", "version_id"): |
There was a problem hiding this comment.
Independent follow-up review of the query-spelling repair (relayed result, Codex): CLEAN
Reviewer and run:
- Reviewer: Codex CLI
codex exec, modelgpt-6-astra, reasoning effortmax, read-only sandbox. Session01a1e52f-8635-7361-af1d-64275cd3be42. - Scope: a detached snapshot of 99c1b79, reviewing
d145334b1e86e0e62d89d2f49ad473ce6d80749a..99c1b79a4968b0101780b78a5551c096b0f159df, with master's_invalidate_path()(6c37452) as the reference. - The snapshot and the PR worktree were unchanged afterwards.
- This was a static review: the reviewer ran no tests.
Coverage, in the reviewer's words: "Cache eviction versus master: roots, buckets, trailing slashes, empty segments, all four version-query spellings, literal query-suffixed names, ancestors, listing caches, and parameterized/typed version lookups."
The reviewer also checked:
- The
_du()cancellation wording: it "accurately describes stopping subsequent entry lookups; an already-running worker may finish". - The new test case: it "protects alternate-spelling directory-listing invalidation, a distinct contract", and by inspection fails without the fix. The local run confirmed that failure.
The independent review is complete. The PR moves to Ready for CI.
WHAT
rm(),chmod(),cat()anddu()now act on the keys that a listing returns, also when a key ends in what looks like a version ID query. The paths that the caller passes still work as path strings, as before.Behavior before this change (6c37452)
The examples use the keys
a/xanda/x?versionId=v1. Each fan-out parsed the listed namebucket/a/x?versionId=v1as versionv1ofa/x, on both filesystems:rm("bucket/a", recursive=True)deleteda/xand versionv1ofa/x, and left the keya/x?versionId=v1.chmod("bucket/a", "private", recursive=True)sent PutObjectAcl fora/xtwice, once withVersionId=v1, and never for the literal key.cat("bucket/a/*")returned versionv1ofa/xunder the name of the literal key.du("bucket/a")looked up versionv1ofa/xinstead of the literal key.expand_path(..., recursive=True)of a glob expanded below each match by its name. A match such asbucket/a/dir?versionId=v1was looked up as a version, and the keys below it were left out.The lookup of an explicit version was cached under the string
bucket/key?versionId=v, which is also the name of a key that ends in that query._invalidate_path()split a version off the string of a deleted path. So deleting the keya/dir?versionId=v1/zleft the listing ofbucket/a/dir?versionId=v1in the cache.Changes
_expand_paths()expands asexpand_path()does, and returns each name with the path it names:_entry_path()).A recursive glob expands below each match by the match's key prefix (
_find_under()), with the caller'sprefix. As in fsspec, a recursive glob that matches nothing raisesFileNotFoundError, and a caller'sdetailoption is accepted._find_paths()does the same forfind(), and names a version path by the path as given.expand_path()returns the same names.rm()and the async_rm(), through_delete_paths(),_delete_objects()and_delete_batches();chmod();cat()and the async_cat(), which read a string withcat_file()and a listed path with_cat_object(). A name that names two paths, such as an explicit version and a listed key with the same query, is read once, as the path that the caller passed, because the contents are returned by name;du()and the async_du(), which look up the path itself withinfo()and each listed entry by its bucket and key (_target_info()). Each entry is still looked up once, and the async_du()awaits each lookup on its own, as fsspec does. Summing the listing sizes would be a separate optimization.(name, "versionId", version_id), which no name equals (_lookup_cache_key())._head_object(),_ls_from_cache()and the typed core ofinfo()(_path_info()) take their cache key from anS3Path.version_awarepins a version;nullversion is not cached;_invalidate()evicts a typed path, its version, and the directories above it as they are listed.invalidate_cache()keeps its behavior for strings: it walks the names as they are spelled. A version-qualified string evicts the typed lookup of the version, the path without the version, and the names that end in its query in each spelling (versionId,versionID,versionid,version_id), as before.This is step 2 of 4 of #1381 (plan in this comment). The remaining steps:
copy,mvandgetfollow in Act on listed identities in pairing and copy/mv/get (#1381 step 3) #1403.mv()still deletes its sources by their names until then.putand the documentation follow in Type generated put destinations and document path addressing limits (#1381 step 4) #1404.WHY
Closes #1402.
TEST
Tested commit: 99c1b79 for
TestS3FileSystem,test_s3_async.py,TestS3FileandTestCompressedBuffer. The rest of the filesystem suite was run on f5706ca; later commits only inline the sizes ofdu()and changeinvalidate_cache().just lintpasses.test_fan_outs_act_on_listed_keys: 5 sync cases (rm,chmod,cat,du,duof a version path) and 3 async cases (_rm,_cat,_du);test_expand_path_expands_below_listed_matches;test_lookups_keep_versions_apart_from_listed_keys, in both directions;test_deletion_invalidates_listed_directories.du-of-a-version-path case pins behavior that 6c37452 already had.test_rm_of_unmatched_recursive_glob_deletes_nothing;test_expand_path_passes_options_as_fsspec(prefixbelow the matches,detail);test_invalidate_cache_evicts_the_name_as_given(bucket/?versionId=v1,bucket/, a directory named by another spelling of the query, and the keya/x?versionId=v1, which 733d4a0 already evicted);test_du_cancellation_sends_no_further_lookup(async).test_listing_of_version_path_looks_up_the_version;test_invalidate_cache_version_drops_object_path;test_copy_skipped_directory_does_not_conflict;test_cat_interrupted_while_assembling_keeps_no_contents;chmodtests that stop running requests.tests/pyathena/filesystem/suite against AWS, run locally in parts:test_s3.py, with the fsspec conformance tests: 1023 passed, 3 skipped;TestS3FileSystem: 703 passed, 3 skipped;test_s3_async.py,TestS3FileandTestCompressedBuffer: 328 passed, 3 skipped.Two background runs of the whole suite were stopped by the session while the machine was low on memory.
🤖 Generated with Claude Code