Always use f-strings

always use f-strings in pure python blocks. Spacing is also changed
to better match black.

Author: WyattBlue

av/__main__.py

@@ -7,13 +7,11 @@ def main():
     parser.add_argument("--version", action="store_true")
     args = parser.parse_args()
 
-    # ---
-
     if args.version:
         import av
         import av._core
 
-        print("PyAV v" + av.__version__)
+        print(f"PyAV v{av.__version__}")
 
         by_config = {}
         for libname, config in sorted(av._core.library_meta.items()):
@@ -22,14 +20,13 @@ def main():
                 by_config.setdefault(
                     (config["configuration"], config["license"]), []
                 ).append((libname, config))
+
         for (config, license), libs in sorted(by_config.items()):
             print("library configuration:", config)
             print("library license:", license)
             for libname, config in libs:
                 version = config["version"]
-                print(
-                    "%-13s %3d.%3d.%3d" % (libname, version[0], version[1], version[2])
-                )
+                print(f"{libname:<13} {version[0]:3d}.{version[1]:3d}.{version[2]:3d}")
 
     if args.codecs:
         from av.codec.codec import dump_codecs

av/_core.pyx

@@ -12,9 +12,11 @@ time_base = lib.AV_TIME_BASE
 cdef decode_version(v):
     if v < 0:
         return (-1, -1, -1)
+
     cdef int major = (v >> 16) & 0xff
     cdef int minor = (v >> 8) & 0xff
     cdef int micro = (v) & 0xff
+
     return (major, minor, micro)
 
 library_meta = {

av/audio/codeccontext.pyx

@@ -8,7 +8,6 @@ from av.packet cimport Packet
 
 
 cdef class AudioCodecContext(CodecContext):
-
     cdef _init(self, lib.AVCodecContext *ptr, const lib.AVCodec *codec):
         CodecContext._init(self, ptr, codec)
 

av/audio/fifo.pyx

@@ -3,23 +3,18 @@ from av.error cimport err_check
 
 
 cdef class AudioFifo:
-
     """A simple audio sample FIFO (First In First Out) buffer."""
 
     def __repr__(self):
         try:
-            result = "<av.%s %s samples of %dhz %s %s at 0x%x>" % (
-                self.__class__.__name__,
-                self.samples,
-                self.sample_rate,
-                self.layout,
-                self.format,
-                id(self),
+            result = (
+                f"<av.{self.__class__.__name__} {self.samples} samples of "
+                f"{self.sample_rate}hz {self.layout} {self.format} at 0x{id(self):x}>"
             )
         except AttributeError:
-            result = "<av.%s uninitialized, use fifo.write(frame), at 0x%x>" % (
-                self.__class__.__name__,
-                id(self),
+            result = (
+                f"<av.{self.__class__.__name__} uninitialized, use fifo.write(frame),"
+                f" at 0x{id(self):x}>"
             )
         return result
 
@@ -90,7 +85,9 @@ cdef class AudioFifo:
         if self.pts_per_sample and frame.ptr.pts != lib.AV_NOPTS_VALUE:
             expected_pts = <int64_t>(self.pts_per_sample * self.samples_written)
             if frame.ptr.pts != expected_pts:
-                raise ValueError("Frame.pts (%d) != expected (%d); fix or set to None." % (frame.ptr.pts, expected_pts))
+                raise ValueError(
+                    "Frame.pts (%d) != expected (%d); fix or set to None." % (frame.ptr.pts, expected_pts)
+                )
 
         err_check(lib.av_audio_fifo_write(
             self.ptr,
@@ -173,6 +170,7 @@ cdef class AudioFifo:
                 frames.append(frame)
             else:
                 break
+
         return frames
 
     property format:

av/audio/format.pyx

@@ -18,11 +18,9 @@ cdef AudioFormat get_audio_format(lib.AVSampleFormat c_format):
 
 
 cdef class AudioFormat:
-
     """Descriptor of audio formats."""
 
     def __cinit__(self, name):
-
         if name is _cinit_bypass_sentinel:
             return
 
@@ -33,15 +31,15 @@ cdef class AudioFormat:
             sample_fmt = lib.av_get_sample_fmt(name)
 
         if sample_fmt < 0:
-            raise ValueError("Not a sample format: %r" % name)
+            raise ValueError(f"Not a sample format: {name!r}")
 
         self._init(sample_fmt)
 
     cdef _init(self, lib.AVSampleFormat sample_fmt):
         self.sample_fmt = sample_fmt
 
     def __repr__(self):
-        return "<av.AudioFormat %s>" % (self.name)
+        return f"<av.AudioFormat {self.name}>"
 
     property name:
         """Canonical name of the sample format.
@@ -128,7 +126,6 @@ cdef class AudioFormat:
 
         """
         def __get__(self):
-
             if self.is_planar:
                 raise ValueError("no planar container formats")
 

av/audio/frame.pyx

@@ -37,7 +37,6 @@ cdef AudioFrame alloc_audio_frame():
 
 
 cdef class AudioFrame(Frame):
-
     """A frame of audio."""
 
     def __cinit__(self, format="s16", layout="stereo", samples=0, align=1):
@@ -61,7 +60,6 @@ cdef class AudioFrame(Frame):
         self.ptr.channels = self.layout.nb_channels
 
         if self.layout.channels and nb_samples:
-
             # Cleanup the old buffer.
             lib.av_freep(&self._buffer)
 
@@ -95,15 +93,9 @@ cdef class AudioFrame(Frame):
         self.format = get_audio_format(<lib.AVSampleFormat>self.ptr.format)
 
     def __repr__(self):
-        return "<av.%s %d, pts=%s, %d samples at %dHz, %s, %s at 0x%x>" % (
-            self.__class__.__name__,
-            self.index,
-            self.pts,
-            self.samples,
-            self.rate,
-            self.layout.name,
-            self.format.name,
-            id(self),
+        return (
+           f"<av.{self.__class__.__name__} {self.index} pts={self.pts}, {self.samples} "
+           f"samples at {self.rate}Hz, {self.layout.name}, {self.format.name} at 0x{id(self):x}"
         )
 
     @staticmethod
@@ -117,7 +109,9 @@ cdef class AudioFrame(Frame):
         try:
             dtype = np.dtype(format_dtypes[format])
         except KeyError:
-            raise ValueError("Conversion from numpy array with format `%s` is not yet supported" % format)
+            raise ValueError(
+                f"Conversion from numpy array with format `{format}` is not yet supported"
+            )
 
         # check input format
         nb_channels = len(AudioLayout(layout).channels)
@@ -184,25 +178,21 @@ cdef class AudioFrame(Frame):
         """
         import numpy as np
 
-        # map avcodec type to numpy type
         try:
             dtype = np.dtype(format_dtypes[self.format.name])
         except KeyError:
-            raise ValueError("Conversion from {!r} format to numpy array is not supported.".format(self.format.name))
+            raise ValueError(f"Conversion from {self.format.name!r} format to numpy array is not supported.")
 
         if self.format.is_planar:
             count = self.samples
         else:
             count = self.samples * len(self.layout.channels)
 
-        # convert and return data
         return np.vstack([np.frombuffer(x, dtype=dtype, count=count) for x in self.planes])
 
     def __getattribute__(self, attribute):
-        "This method should be deleted when `frame.index` is removed."
-        if attribute == 'index':
-            warnings.warn(
-                "Using `frame.index` is deprecated.",
-                AVDeprecationWarning
-            )
+        # This method should be deleted when `frame.index` is removed
+        if attribute == "index":
+            warnings.warn("Using `frame.index` is deprecated.", AVDeprecationWarning)
+
         return Frame.__getattribute__(self, attribute)

av/audio/layout.pyx

@@ -63,16 +63,15 @@ cdef dict channel_descriptions = {
 
 
 cdef class AudioLayout:
-
     def __init__(self, layout):
-
         if layout is _cinit_bypass_sentinel:
             return
 
         cdef uint64_t c_layout
         if isinstance(layout, int):
             if layout < 0 or layout > 8:
-                raise ValueError("no layout with %d channels" % layout)
+                raise ValueError(f"no layout with {layout} channels")
+
             c_layout = default_layouts[layout]
         elif isinstance(layout, str):
             c_layout = lib.av_get_channel_layout(layout)
@@ -82,7 +81,7 @@ cdef class AudioLayout:
             raise TypeError("layout must be str or int")
 
         if not c_layout:
-            raise ValueError("invalid channel layout %r" % layout)
+            raise ValueError(f"invalid channel layout: {layout}")
 
         self._init(c_layout)
 
@@ -92,7 +91,7 @@ cdef class AudioLayout:
         self.channels = tuple(AudioChannel(self, i) for i in range(self.nb_channels))
 
     def __repr__(self):
-        return "<av.%s %r>" % (self.__class__.__name__, self.name)
+        return f"<av.{self.__class__.__name__} {self.name!r}>"
 
     property name:
         """The canonical name of the audio layout."""
@@ -104,12 +103,11 @@ cdef class AudioLayout:
 
 
 cdef class AudioChannel:
-
     def __cinit__(self, AudioLayout layout, int index):
         self.channel = lib.av_channel_layout_extract_channel(layout.layout, index)
 
     def __repr__(self):
-        return "<av.%s %r (%s)>" % (self.__class__.__name__, self.name, self.description)
+        return f"<av.{self.__class__.__name__} {self.name!r} ({self.description})>"
 
     property name:
         """The canonical name of the audio channel."""

av/audio/stream.pyx

@@ -1,12 +1,7 @@
 cdef class AudioStream(Stream):
-
     def __repr__(self):
-        return "<av.%s #%d %s at %dHz, %s, %s at 0x%x>" % (
-            self.__class__.__name__,
-            self.index,
-            self.name,
-            self.rate,
-            self.layout.name,
-            self.format.name if self.format else None,
-            id(self),
+        form = self.format.name if self.format else None
+        return (
+            f"<av.{self.__class__.__name__} #{self.index} {self.name} at {self.rate}Hz,"
+            f" {self.layout.name}, {form} at 0x{id(self):x}>"
         )

av/buffer.pyx

@@ -6,7 +6,6 @@ from av.bytesource cimport ByteSource, bytesource
 
 
 cdef class Buffer:
-
     """A base class for PyAV objects which support the buffer protocol, such
     as :class:`.Packet` and :class:`.Plane`.
 
@@ -24,6 +23,7 @@ cdef class Buffer:
     def __getbuffer__(self, Py_buffer *view, int flags):
         if flags & PyBUF_WRITABLE and not self._buffer_writable():
             raise ValueError("buffer is not writable")
+
         PyBuffer_FillInfo(view, self, self._buffer_ptr(), self._buffer_size(), 0, flags)
 
     @property
@@ -59,8 +59,11 @@ cdef class Buffer:
         """
         if not self._buffer_writable():
             raise ValueError("buffer is not writable")
+
         cdef ByteSource source = bytesource(input)
         cdef size_t size = self._buffer_size()
+
         if source.length != size:
-            raise ValueError("got %d bytes; need %d bytes" % (source.length, size))
+            raise ValueError(f"got {source.length} bytes; need {size} bytes")
+
         memcpy(self._buffer_ptr(), source.ptr, size)

av/codec/codec.pyx

@@ -352,7 +352,8 @@ codec_descriptor = wrap_avclass(lib.avcodec_get_class())
 def dump_codecs():
     """Print information about available codecs."""
 
-    print """Codecs:
+    print(
+        """Codecs:
  D..... = Decoding supported
  .E.... = Encoding supported
  ..V... = Video codec
@@ -362,9 +363,9 @@ def dump_codecs():
  ....L. = Lossy compression
  .....S = Lossless compression
  ------"""
+    )
 
     for name in sorted(codecs_available):
-
         try:
             e_codec = Codec(name, "w")
         except ValueError:
@@ -379,15 +380,18 @@ def dump_codecs():
         codec = e_codec or d_codec
 
         try:
-            print " %s%s%s%s%s%s %-18s %s" % (
-                ".D"[bool(d_codec)],
-                ".E"[bool(e_codec)],
-                codec.type[0].upper(),
-                ".I"[codec.intra_only],
-                ".L"[codec.lossy],
-                ".S"[codec.lossless],
-                codec.name,
-                codec.long_name
+            print(
+                " %s%s%s%s%s%s %-18s %s"
+                % (
+                    ".D"[bool(d_codec)],
+                    ".E"[bool(e_codec)],
+                    codec.type[0].upper(),
+                    ".I"[codec.intra_only],
+                    ".L"[codec.lossy],
+                    ".S"[codec.lossless],
+                    codec.name,
+                    codec.long_name,
+                )
             )
         except Exception as e:
-            print "...... %-18s ERROR: %s" % (codec.name, e)
+            print(f"...... {codec.name:<18} ERROR: {e}")