safer 4.12.3__tar.gz → 5.1.0__tar.gz

{safer-4.12.3 → safer-5.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: safer
-Version: 4.12.3
+Version: 5.1.0
 Summary: 🧿 A safer writer for files and streams 🧿
 Home-page: https://github.com/rec/safer
 License: MIT

{safer-4.12.3 → safer-5.1.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "safer"
-version = "4.12.3"
+version = "5.1.0"
 description = "🧿 A safer writer for files and streams 🧿"
 authors = ["Tom Ritchford <tom@swirly.com>"]
 license = "MIT"
@@ -42,6 +42,8 @@ line-length = 88
 [tool.ruff.format]
 quote-style = "single"
 
+
+[tool.mypy]
 [build-system]
 requires = ["poetry-core"]
 build-backend = "poetry.core.masonry.api"

{safer-4.12.3 → safer-5.1.0}/safer/__init__.py

@@ -1,5 +1,4 @@
-"""
-# 🧿 `safer`: A safer writer 🧿
+"""# 🧿 `safer`: A safer writer 🧿
 
 Avoid partial writes or corruption!
 
@@ -42,6 +41,10 @@ https://pypi.org/project/atomicwrites/
 It also has a useful `dry_run` setting to let you test your code without
 actually overwriting the target file.
 
+NOTE: Just like plain old `open`, if a file that is already opened for writing
+is opened again before the first write has completed, the results are
+unpredictable: so don't do it!
+
 * `safer.writer()` wraps an existing writer, socket or stream and writes a
   whole response or nothing
 
@@ -67,7 +70,6 @@ writes the data to a temporary file on disk, which is moved over using
 does not work on Windows.  (In fact, it's unclear if any of this works on
 Windows, but that certainly won't.  Windows developer solicted!)
 
-
 ### Example: `safer.writer()`
 
 `safer.writer()` wraps an existing stream - a writer, socket, or callback -
@@ -143,7 +145,10 @@ With `safer`
         for item in items:
             print(item)
         # Either the whole file is written, or nothing
+
 """
+from __future__ import annotations
+
 import contextlib
 import functools
 import io
@@ -159,15 +164,15 @@ __all__ = 'writer', 'open', 'closer', 'dump', 'printer'
 
 
 def writer(
-    stream: t.Union[t.Callable, None, t.IO, Path, str] = None,
-    is_binary: t.Optional[bool] = None,
+    stream: t.Callable | None | t.IO | Path | str = None,
+    is_binary: bool | None = None,
     close_on_exit: bool = False,
     temp_file: bool = False,
     chunk_size: int = 0x100000,
     delete_failures: bool = True,
-    dry_run: t.Union[bool, t.Callable] = False,
+    dry_run: bool | t.Callable = False,
     enabled: bool = True,
-) -> t.Union[t.Callable, t.IO]:
+) -> t.Callable | t.IO:
     """
     Write safely to file streams, sockets and callables.
 
@@ -228,78 +233,84 @@ def writer(
     if not enabled:
         return stream
 
-    write: t.Optional[t.Callable]
+    write: t.Callable | None
 
-    if callable(dry_run):
-        write, dry_run = dry_run, True
+    if close_on_exit and stream in (sys.stdout, sys.stderr):
+        raise ValueError('You cannot close stdout or stderr')
 
-    elif dry_run:
-        write = len
+    if dry_run:
+        close_on_exit = False
 
-    elif close_on_exit and hasattr(stream, 'write'):
-        if temp_file and BUG_MESSAGE:
-            raise NotImplementedError(BUG_MESSAGE)
+    try:
+        if callable(dry_run):
+            write, dry_run = dry_run, True
 
-        def write(v):
-            with stream:
-                stream.write(v)
+        elif dry_run:
+            write = len
 
-    else:
-        write = getattr(stream, 'write', None)
+        elif close_on_exit and hasattr(stream, 'write'):
+            if temp_file and BUG_MESSAGE:
+                raise NotImplementedError(BUG_MESSAGE)
 
-    send = getattr(stream, 'send', None)
-    mode = getattr(stream, 'mode', None)
+            def write(v):
+                with stream:
+                    stream.write(v)
 
-    if dry_run:
-        close_on_exit = False
+        else:
+            write = getattr(stream, 'write', None)
 
-    if close_on_exit and stream in (sys.stdout, sys.stderr):
-        raise ValueError('You cannot close stdout or stderr')
+        send = getattr(stream, 'send', None)
+        mode = getattr(stream, 'mode', None)
 
-    if write and mode:
-        if not set('w+a').intersection(mode):
-            raise ValueError('Stream mode "%s" is not a write mode' % mode)
+        if write and mode:
+            if not set('w+a').intersection(mode):
+                raise ValueError(f'Stream mode "{mode}" is not a write mode')
 
-        binary_mode = 'b' in mode
-        if is_binary is not None and is_binary is not binary_mode:
-            raise ValueError('is_binary is inconsistent with the file stream')
+            binary_mode = 'b' in mode
+            if is_binary is not None and is_binary is not binary_mode:
+                raise ValueError('is_binary is inconsistent with the file stream')
 
-        is_binary = binary_mode
+            is_binary = binary_mode
 
-    elif dry_run:
-        pass
+        elif dry_run:
+            pass
 
-    elif send and hasattr(stream, 'recv'):  # It looks like a socket:
-        if not (is_binary is None or is_binary is True):
-            raise ValueError('is_binary=False is inconsistent with a socket')
+        elif send and hasattr(stream, 'recv'):  # It looks like a socket:
+            if not (is_binary is None or is_binary is True):
+                raise ValueError('is_binary=False is inconsistent with a socket')
 
-        write = send
-        is_binary = True
+            write = send
+            is_binary = True
 
-    elif callable(stream):
-        write = stream
+        elif callable(stream):
+            write = stream
 
-    else:
-        raise ValueError('Stream is not a file, a socket, or callable')
-
-    closer: _StreamCloser
-
-    if temp_file:
-        closer = _FileStreamCloser(
-            write,
-            close_on_exit,
-            is_binary,
-            temp_file,
-            chunk_size,
-            delete_failures,
-        )
-    else:
-        closer = _MemoryStreamCloser(write, close_on_exit, is_binary)
+        else:
+            raise ValueError('Stream is not a file, a socket, or callable')
+
+        closer: _StreamCloser
+
+        if temp_file:
+            closer = _FileStreamCloser(
+                write,
+                close_on_exit,
+                is_binary,
+                temp_file,
+                chunk_size,
+                delete_failures,
+            )
+        else:
+            closer = _MemoryStreamCloser(write, close_on_exit, is_binary)
+
+        if send is write:
+            closer.fp.send = write
 
-    if send is write:
-        closer.fp.send = write
+        return closer.fp
 
-    return closer.fp
+    except Exception:
+        if close_on_exit:
+            getattr(stream, 'close', lambda: None)()
+        raise
 
 
 # There's an edge case in #23 I can't yet fix, so I fail
@@ -308,18 +319,18 @@ BUG_MESSAGE = 'Sorry, safer.writer fails if temp_file (#23)'
 
 
 def open(
-    name: t.Union[Path, str],
+    name: Path | str,
     mode: str = 'r',
     buffering: int = -1,
-    encoding: t.Optional[str] = None,
-    errors: t.Optional[str] = None,
-    newline: t.Optional[str] = None,
+    encoding: str | None = None,
+    errors: str | None = None,
+    newline: str | None = None,
     closefd: bool = True,
-    opener: t.Optional[t.Callable] = None,
+    opener: t.Callable | None = None,
     make_parents: bool = False,
     delete_failures: bool = True,
     temp_file: bool = False,
-    dry_run: t.Union[bool, t.Callable] = False,
+    dry_run: bool | t.Callable = False,
     enabled: bool = True,
 ) -> t.IO:
     """
@@ -382,7 +393,7 @@ def open(
         name = str(name)
 
     if not isinstance(name, str):
-        raise TypeError('`name` must be string, not %s' % type(name).__name__)
+        raise TypeError(f'`name` must be string, not {type(name).__name__}')
 
     name = os.path.realpath(name)
     parent = os.path.dirname(os.path.abspath(name))
@@ -428,7 +439,7 @@ def open(
             raise ValueError("binary mode doesn't take an errors argument")
 
     if 'x' in mode and os.path.exists(name):
-        raise FileExistsError("File exists: '%s'" % name)
+        raise FileExistsError(f"File exists: '{name}'")
 
     if buffering == -1:
         buffering = io.DEFAULT_BUFFER_SIZE
@@ -444,8 +455,8 @@ def open(
 
 
 def closer(
-    stream: t.IO, is_binary: t.Optional[bool] = None, close_on_exit: bool = True, **kwds
-) -> t.Union[t.Callable, t.IO]:
+    stream: t.IO, is_binary: bool | None = None, close_on_exit: bool = True, **kwds
+) -> t.Callable | t.IO:
     """
     Like `safer.writer()` but with `close_on_exit=True` by default
 
@@ -457,7 +468,7 @@ def closer(
 
 def dump(
     obj,
-    stream: t.Union[t.Callable, None, t.IO, Path, str] = None,
+    stream: t.Callable | None | t.IO | Path | str = None,
     dump: t.Any = None,
     **kwargs,
 ) -> t.Any:
@@ -530,8 +541,8 @@ def _get_dumper(dump: t.Any) -> t.Callable:
 
 @contextlib.contextmanager
 def printer(
-    name: t.Union[Path, str], mode: str = 'w', *args, **kwargs
-) -> t.Generator[t.Callable, None, None]:
+    name: Path | str, mode: str = 'w', *args, **kwargs
+) -> t.Iterator[t.Callable]:
     """
     A context manager that yields a function that prints to the opened file,
     only writing to the original file at the exit of the context,
@@ -657,14 +668,16 @@ class _FileRenameCloser(_FileCloser):
         self.target_file = target_file
         self.dry_run = dry_run
         self.is_binary = is_binary
+        if temp_file is True:
+            parent, file = os.path.split(target_file)
+            temp_file = os.path.join(parent, f'.{file}.tmp-safer')
+
         super().__init__(temp_file, delete_failures, parent)
 
     def _success(self):
         if not self.dry_run:
             if os.path.exists(self.target_file):
                 shutil.copymode(self.target_file, self.temp_file)
-            else:
-                os.chmod(self.temp_file, 0o100644)
             os.replace(self.temp_file, self.target_file)
 
         elif callable(self.dry_run):