def listdir(self, dirname):
"""Returns a list of entries contained within a directory."""
if not self.isdir(dirname):
raise errors.NotFoundError(None, None, "Could not find directory")
entries = os.listdir(compat.as_str_any(dirname))
entries = [compat.as_str_any(item) for item in entries]
return entries
def stat(self, filename):
"""Returns file statistics for a given path."""
# NOTE: Size of the file is given by .st_size as returned from
# os.stat(), but we convert to .length
try:
file_length = os.stat(compat.as_bytes(filename)).st_size
except OSError:
raise errors.NotFoundError(None, None, "Could not find file")
return StatData(file_length)
def stat(self, filename):
"""Returns file statistics for a given path."""
# NOTE: Size of the file is given by ContentLength from S3,
# but we convert to .length
client = boto3.client("s3", endpoint_url=self._s3_endpoint)
bucket, path = self.bucket_and_path(filename)
try:
obj = client.head_object(Bucket=bucket, Key=path)
return StatData(obj["ContentLength"])
except botocore.exceptions.ClientError as exc:
if exc.response["Error"]["Code"] == "404":
raise errors.NotFoundError(None, None, "Could not find file")
else:
raise
def read(self, filename, binary_mode=False, size=None, continue_from=None):
"""Reads contents of a file to a string.
Args:
filename: string, a path
binary_mode: bool, read as binary if True, otherwise text
size: int, number of bytes or characters to read, otherwise
read all the contents of the file (from the continuation
marker, if present).
continue_from: An opaque value returned from a prior invocation of
`read(...)` marking the last read position, so that reading
may continue from there. Otherwise read from the beginning.
Returns:
A tuple of `(data, continuation_token)` where `data' provides either
bytes read from the file (if `binary_mode == true`) or the decoded
string representation thereof (otherwise), and `continuation_token`
is an opaque value that can be passed to the next invocation of
`read(...) ' in order to continue from the last read position.
"""
fs, path = self._fs_path(filename)
mode = "rb" if binary_mode else "r"
encoding = None if binary_mode else "utf8"
if not exists(filename):
raise errors.NotFoundError(
None, None, "Not Found: " + compat.as_text(filename))
with fs.open(path, mode, encoding=encoding) as f:
if continue_from is not None:
if not f.seekable():
raise errors.InvalidArgumentError(
None,
None,
"{} is not seekable".format(filename),
)
offset = continue_from.get("opaque_offset", None)
if offset is not None:
f.seek(offset)
data = f.read(size)
# The new offset may not be `offset + len(data)`, due to decoding
# and newline translation.
# So, just measure it in whatever terms the underlying stream uses.
continuation_token = ({
"opaque_offset": f.tell()
} if f.seekable() else {})
return (data, continuation_token)
def func_wrapper(self, *args, **kwargs):
try:
return func(self, *args, **kwargs)
except FileNotFoundError as e:
raise errors.NotFoundError(None, None, str(e))
