Merge pull request #2089 from zh794390558/cpplint

[audio] format code

.pre-commit-config.yaml

@@ -76,4 +76,4 @@ repos:
         entry: bash .pre-commit-hooks/cpplint.hook
         language: system
         files: \.(c|cc|cxx|cpp|cu|h|hpp|hxx)$
-        exclude: (?=speechx/speechx/kaldi|speechx/patch|speechx/tools/fstbin|speechx/tools/lmbin).*(\.cpp|\.cc|\.h|\.py)$
+        exclude: (?=speechx/speechx/kaldi|speechx/patch|speechx/tools/fstbin|speechx/tools/lmbin|paddlespeech/audio/src/optional).*(\.cpp|\.cc|\.h|\.hpp)$
\ No newline at end of file

audio/audio/csrc/pybind/pybind.cpp

 #include "pybind/sox/io.h"
 
 PYBIND11_MODULE(_paddleaudio, m) {
-  m.def("get_info_file", &paddleaudio::sox_io::get_info_file,
+    m.def("get_info_file",
+          &paddleaudio::sox_io::get_info_file,
           "Get metadata of audio file.");
-  m.def("get_info_fileobj", &paddleaudio::sox_io::get_info_fileobj,
+    m.def("get_info_fileobj",
+          &paddleaudio::sox_io::get_info_fileobj,
           "Get metadata of audio in file object.");
 }
\ No newline at end of file

audio/audio/csrc/pybind/sox/io.cpp

@@ -8,7 +8,8 @@ namespace sox_io {
 
 auto get_info_file(const std::string &path, const std::string &format)
     -> std::tuple<int64_t, int64_t, int64_t, int64_t, std::string> {
-  SoxFormat sf(sox_open_read(path.data(),
+    SoxFormat sf(
+        sox_open_read(path.data(),
                       /*signal=*/nullptr,
                       /*encoding=*/nullptr,
                       /*filetype=*/format.empty() ? nullptr : format.data()));
@@ -38,7 +39,9 @@ auto get_info_fileobj(py::object fileobj, const std::string &format)
     // If the file is shorter than 256, then libsox cannot read the header.
     auto buf_size = (num_read > 256) ? num_read : 256;
 
-  SoxFormat sf(sox_open_mem_read(buf, buf_size,
+    SoxFormat sf(sox_open_mem_read(
+        buf,
+        buf_size,
         /*signal=*/nullptr,
         /*encoding=*/nullptr,
         /*filetype=*/format.empty() ? nullptr : format.data()));

audio/audio/csrc/pybind/sox/utils.cpp

@@ -31,7 +31,8 @@ auto read_fileobj(py::object *fileobj, const uint64_t size, char *buffer)
         }
         if (chunk_len > request) {
             std::ostringstream message;
-      message << "Requested up to " << request << " bytes but, "
+            message
+                << "Requested up to " << request << " bytes but, "
                 << "received " << chunk_len << " bytes. "
                 << "The given object does not confirm to read protocol of file "
                    "object.";
@@ -48,8 +49,8 @@ int64_t get_buffer_size() { return sox_get_globals()->bufsiz; }
 
 void validate_input_file(const SoxFormat &sf, const std::string &path) {
     if (static_cast<sox_format_t *>(sf) == nullptr) {
-    throw std::runtime_error("Error loading audio file: failed to open file " +
-                             path);
+        throw std::runtime_error(
+            "Error loading audio file: failed to open file " + path);
     }
     if (sf->encoding.encoding == SOX_ENCODING_UNKNOWN) {
         throw std::runtime_error("Error loading audio file: unknown encoding.");

audio/audio/csrc/pybind/sox/utils.h

@@ -22,7 +22,7 @@ struct SoxFormat {
 
     void close();
 
-private:
+  private:
     sox_format_t *fd_;
 };
 

paddlespeech/__init__.py

@@ -14,5 +14,3 @@
 import _locale
 
 _locale._getdefaultlocale = (lambda *args: ['en_US', 'utf8'])
-
-

paddlespeech/audio/_class.py

 import types
 
+
 class _ClassNamespace(types.ModuleType):
     def __init__(self, name):
         super(_ClassNamespace, self).__init__('paddlespeech.classes' + name)
@@ -11,6 +12,7 @@ class _ClassNamespace(types.ModuleType):
             raise RuntimeError(f'Class {self.name}.{attr} not registered!')
         return proxy
 
+
 class _Classes(types.ModuleType):
     __file__ = '_classes.py'
 
@@ -43,5 +45,6 @@ class _Classes(types.ModuleType):
         """
         paddlespeech.ops.load_library(path)
 
+
 # The classes "namespace"
 classes = _Classes()

paddlespeech/audio/_extension.py

@@ -64,7 +64,8 @@ def _init_ffmpeg():
     try:
         _load_lib("libpaddlleaudio_ffmpeg")
     except OSError as err:
-        raise ImportError("FFmpeg libraries are not found. Please install FFmpeg.") from err
+        raise ImportError(
+            "FFmpeg libraries are not found. Please install FFmpeg.") from err
 
     import paddllespeech._paddlleaudio_ffmpeg  # noqa
 

paddlespeech/audio/_internal/module_utils.py

@@ -3,6 +3,7 @@ import warnings
 from functools import wraps
 from typing import Optional
 
+
 def is_module_available(*modules: str) -> bool:
     r"""Returns if a top-level module with :attr:`name` exists *without**
     importing it. This is generally safer than try-catch block around a
@@ -26,19 +27,21 @@ def requires_module(*modules: str):
             return func
 
     else:
-        req = f"module: {missing[0]}" if len(missing) == 1 else f"modules: {missing}"
+        req = f"module: {missing[0]}" if len(
+            missing) == 1 else f"modules: {missing}"
 
         def decorator(func):
             @wraps(func)
             def wrapped(*args, **kwargs):
-                raise RuntimeError(f"{func.__module__}.{func.__name__} requires {req}")
+                raise RuntimeError(
+                    f"{func.__module__}.{func.__name__} requires {req}")
 
             return wrapped
 
     return decorator
 
 
-def deprecated(direction: str, version: Optional[str] = None):
+def deprecated(direction: str, version: Optional[str]=None):
     """Decorator to add deprecation message
     Args:
         direction (str): Migration steps to be given to users.
@@ -51,8 +54,7 @@ def deprecated(direction: str, version: Optional[str] = None):
             message = (
                 f"{func.__module__}.{func.__name__} has been deprecated "
                 f'and will be removed from {"future" if version is None else version} release. '
-                f"{direction}"
-            )
+                f"{direction}")
             warnings.warn(message, stacklevel=2)
             return func(*args, **kwargs)
 
@@ -62,7 +64,7 @@ def deprecated(direction: str, version: Optional[str] = None):
 
 
 def is_kaldi_available():
-    return is_module_available("paddlespeech"._paddleaudio") and paddlespeech.ops.paddleaudio.is_kaldi_available()
+    return is_module_available("paddlespeech.audio._paddleaudio")
 
 
 def requires_kaldi():
@@ -76,7 +78,8 @@ def requires_kaldi():
         def decorator(func):
             @wraps(func)
             def wrapped(*args, **kwargs):
-                raise RuntimeError(f"{func.__module__}.{func.__name__} requires kaldi")
+                raise RuntimeError(
+                    f"{func.__module__}.{func.__name__} requires kaldi")
 
             return wrapped
 
@@ -91,7 +94,8 @@ def _check_soundfile_importable():
 
         return True
     except Exception:
-        warnings.warn("Failed to import soundfile. 'soundfile' backend is not available.")
+        warnings.warn(
+            "Failed to import soundfile. 'soundfile' backend is not available.")
         return False
 
 
@@ -113,7 +117,8 @@ def requires_soundfile():
         def decorator(func):
             @wraps(func)
             def wrapped(*args, **kwargs):
-                raise RuntimeError(f"{func.__module__}.{func.__name__} requires soundfile")
+                raise RuntimeError(
+                    f"{func.__module__}.{func.__name__} requires soundfile")
 
             return wrapped
 
@@ -121,7 +126,7 @@ def requires_soundfile():
 
 
 def is_sox_available():
-    return is_module_available("paddlespeech._paddleaudio") and paddlespeech.ops.paddleaudio.is_sox_available()
+    return is_module_available("paddlespeech.audio._paddleaudio")
 
 
 def requires_sox():
@@ -135,7 +140,8 @@ def requires_sox():
         def decorator(func):
             @wraps(func)
             def wrapped(*args, **kwargs):
-                raise RuntimeError(f"{func.__module__}.{func.__name__} requires sox")
+                raise RuntimeError(
+                    f"{func.__module__}.{func.__name__} requires sox")
 
             return wrapped
 

paddlespeech/audio/_ops.py

 import contextlib
 import ctypes
-import sys
 import os
+import sys
 import types
 
 # Query `hasattr` only once.
-_SET_GLOBAL_FLAGS = hasattr(sys, 'getdlopenflags') and hasattr(sys, 'setdlopenflags')
+_SET_GLOBAL_FLAGS = hasattr(sys, 'getdlopenflags') and hasattr(sys,
+                                                               'setdlopenflags')
 
 
 @contextlib.contextmanager

paddlespeech/audio/src/optional/optional.hpp

@@ -55,27 +55,30 @@
 // GCC < 5 doesn't support some standard C++11 type traits
 #define TL_OPTIONAL_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(T) \
     std::has_trivial_copy_constructor<T>::value
-#define TL_OPTIONAL_IS_TRIVIALLY_COPY_ASSIGNABLE(T) std::has_trivial_copy_assign<T>::value
+#define TL_OPTIONAL_IS_TRIVIALLY_COPY_ASSIGNABLE(T) \
+    std::has_trivial_copy_assign<T>::value
 
 // This one will be different for GCC 5.7 if it's ever supported
-#define TL_OPTIONAL_IS_TRIVIALLY_DESTRUCTIBLE(T) std::is_trivially_destructible<T>::value
+#define TL_OPTIONAL_IS_TRIVIALLY_DESTRUCTIBLE(T) \
+    std::is_trivially_destructible<T>::value
 
-// GCC 5 < v < 8 has a bug in is_trivially_copy_constructible which breaks std::vector
+// GCC 5 < v < 8 has a bug in is_trivially_copy_constructible which breaks
+// std::vector
 // for non-copyable types
-#elif (defined(__GNUC__) && __GNUC__ < 8 &&                                                \
-     !defined(__clang__))
+#elif (defined(__GNUC__) && __GNUC__ < 8 && !defined(__clang__))
 #ifndef TL_GCC_LESS_8_TRIVIALLY_COPY_CONSTRUCTIBLE_MUTEX
 #define TL_GCC_LESS_8_TRIVIALLY_COPY_CONSTRUCTIBLE_MUTEX
 namespace tl {
-  namespace detail {
-      template<class T>
-      struct is_trivially_copy_constructible : std::is_trivially_copy_constructible<T>{};
+namespace detail {
+template <class T>
+struct is_trivially_copy_constructible
+    : std::is_trivially_copy_constructible<T> {};
 #ifdef _GLIBCXX_VECTOR
-      template<class T, class A>
-      struct is_trivially_copy_constructible<std::vector<T,A>>
-          : std::is_trivially_copy_constructible<T>{};
+template <class T, class A>
+struct is_trivially_copy_constructible<std::vector<T, A>>
+    : std::is_trivially_copy_constructible<T> {};
 #endif
-  }
+}
 }
 #endif
 
@@ -83,13 +86,15 @@ namespace tl {
     tl::detail::is_trivially_copy_constructible<T>::value
 #define TL_OPTIONAL_IS_TRIVIALLY_COPY_ASSIGNABLE(T) \
     std::is_trivially_copy_assignable<T>::value
-#define TL_OPTIONAL_IS_TRIVIALLY_DESTRUCTIBLE(T) std::is_trivially_destructible<T>::value
+#define TL_OPTIONAL_IS_TRIVIALLY_DESTRUCTIBLE(T) \
+    std::is_trivially_destructible<T>::value
 #else
 #define TL_OPTIONAL_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(T) \
     std::is_trivially_copy_constructible<T>::value
 #define TL_OPTIONAL_IS_TRIVIALLY_COPY_ASSIGNABLE(T) \
     std::is_trivially_copy_assignable<T>::value
-#define TL_OPTIONAL_IS_TRIVIALLY_DESTRUCTIBLE(T) std::is_trivially_destructible<T>::value
+#define TL_OPTIONAL_IS_TRIVIALLY_DESTRUCTIBLE(T) \
+    std::is_trivially_destructible<T>::value
 #endif
 
 #if __cplusplus > 201103L
@@ -118,24 +123,29 @@ struct in_place_t {
 static constexpr in_place_t in_place{};
 #endif
 
-template <class T> class optional;
+template <class T>
+class optional;
 
 namespace detail {
 #ifndef TL_TRAITS_MUTEX
 #define TL_TRAITS_MUTEX
 // C++14-style aliases for brevity
-template <class T> using remove_const_t = typename std::remove_const<T>::type;
+template <class T>
+using remove_const_t = typename std::remove_const<T>::type;
 template <class T>
 using remove_reference_t = typename std::remove_reference<T>::type;
-template <class T> using decay_t = typename std::decay<T>::type;
+template <class T>
+using decay_t = typename std::decay<T>::type;
 template <bool E, class T = void>
 using enable_if_t = typename std::enable_if<E, T>::type;
 template <bool B, class T, class F>
 using conditional_t = typename std::conditional<B, T, F>::type;
 
 // std::conjunction from C++17
-template <class...> struct conjunction : std::true_type {};
-template <class B> struct conjunction<B> : B {};
+template <class...>
+struct conjunction : std::true_type {};
+template <class B>
+struct conjunction<B> : B {};
 template <class B, class... Bs>
 struct conjunction<B, Bs...>
     : std::conditional<bool(B::value), conjunction<Bs...>, B>::type {};
@@ -148,31 +158,43 @@ struct conjunction<B, Bs...>
 // which results in a hard-error when using it in a noexcept expression
 // in some cases. This is a check to workaround the common failing case.
 #ifdef TL_TRAITS_LIBCXX_MEM_FN_WORKAROUND
-template <class T> struct is_pointer_to_non_const_member_func : std::false_type{};
+template <class T>
+struct is_pointer_to_non_const_member_func : std::false_type {};
 template <class T, class Ret, class... Args>
-struct is_pointer_to_non_const_member_func<Ret (T::*) (Args...)> : std::true_type{};
+struct is_pointer_to_non_const_member_func<Ret (T::*)(Args...)>
+    : std::true_type {};
 template <class T, class Ret, class... Args>
-struct is_pointer_to_non_const_member_func<Ret (T::*) (Args...)&> : std::true_type{};
+struct is_pointer_to_non_const_member_func<Ret (T::*)(Args...) &>
+    : std::true_type {};
 template <class T, class Ret, class... Args>
-struct is_pointer_to_non_const_member_func<Ret (T::*) (Args...)&&> : std::true_type{};        
+struct is_pointer_to_non_const_member_func<Ret (T::*)(Args...) &&>
+    : std::true_type {};
 template <class T, class Ret, class... Args>
-struct is_pointer_to_non_const_member_func<Ret (T::*) (Args...) volatile> : std::true_type{};
+struct is_pointer_to_non_const_member_func<Ret (T::*)(Args...) volatile>
+    : std::true_type {};
 template <class T, class Ret, class... Args>
-struct is_pointer_to_non_const_member_func<Ret (T::*) (Args...) volatile&> : std::true_type{};
+struct is_pointer_to_non_const_member_func<Ret (T::*)(Args...) volatile &>
+    : std::true_type {};
 template <class T, class Ret, class... Args>
-struct is_pointer_to_non_const_member_func<Ret (T::*) (Args...) volatile&&> : std::true_type{};        
+struct is_pointer_to_non_const_member_func<Ret (T::*)(Args...) volatile &&>
+    : std::true_type {};
 
-template <class T> struct is_const_or_const_ref : std::false_type{};
-template <class T> struct is_const_or_const_ref<T const&> : std::true_type{};
-template <class T> struct is_const_or_const_ref<T const> : std::true_type{};    
+template <class T>
+struct is_const_or_const_ref : std::false_type {};
+template <class T>
+struct is_const_or_const_ref<T const &> : std::true_type {};
+template <class T>
+struct is_const_or_const_ref<T const> : std::true_type {};
 #endif
 
 // std::invoke from C++17
 // https://stackoverflow.com/questions/38288042/c11-14-invoke-workaround
-template <typename Fn, typename... Args,
+template <
+    typename Fn,
+    typename... Args,
 #ifdef TL_TRAITS_LIBCXX_MEM_FN_WORKAROUND
-          typename = enable_if_t<!(is_pointer_to_non_const_member_func<Fn>::value 
-                                 && is_const_or_const_ref<Args...>::value)>, 
+    typename = enable_if_t<!(is_pointer_to_non_const_member_func<Fn>::value &&
+                             is_const_or_const_ref<Args...>::value)>,
 #endif
     typename = enable_if_t<std::is_member_pointer<decay_t<Fn>>::value>,
     int = 0>
@@ -182,7 +204,8 @@ constexpr auto invoke(Fn &&f, Args &&... args) noexcept(
     return std::mem_fn(f)(std::forward<Args>(args)...);
 }
 
-template <typename Fn, typename... Args,
+template <typename Fn,
+          typename... Args,
           typename = enable_if_t<!std::is_member_pointer<decay_t<Fn>>::value>>
 constexpr auto invoke(Fn &&f, Args &&... args) noexcept(
     noexcept(std::forward<Fn>(f)(std::forward<Args>(args)...)))
@@ -191,13 +214,16 @@ constexpr auto invoke(Fn &&f, Args &&... args) noexcept(
 }
 
 // std::invoke_result from C++17
-template <class F, class, class... Us> struct invoke_result_impl;
+template <class F, class, class... Us>
+struct invoke_result_impl;
 
 template <class F, class... Us>
 struct invoke_result_impl<
-    F, decltype(detail::invoke(std::declval<F>(), std::declval<Us>()...), void()),
+    F,
+    decltype(detail::invoke(std::declval<F>(), std::declval<Us>()...), void()),
     Us...> {
-  using type = decltype(detail::invoke(std::declval<F>(), std::declval<Us>()...));
+    using type =
+        decltype(detail::invoke(std::declval<F>(), std::declval<Us>()...));
 };
 
 template <class F, class... Us>
@@ -208,9 +234,11 @@ using invoke_result_t = typename invoke_result<F, Us...>::type;
 
 #if defined(_MSC_VER) && _MSC_VER <= 1900
 // TODO make a version which works with MSVC 2015
-template <class T, class U = T> struct is_swappable : std::true_type {};
+template <class T, class U = T>
+struct is_swappable : std::true_type {};
 
-template <class T, class U = T> struct is_nothrow_swappable : std::true_type {};
+template <class T, class U = T>
+struct is_nothrow_swappable : std::true_type {};
 #else
 // https://stackoverflow.com/questions/26744589/what-is-a-proper-way-to-implement-is-swappable-to-test-for-the-swappable-concept
 namespace swap_adl_tests {
@@ -218,18 +246,23 @@ namespace swap_adl_tests {
 // signature)
 struct tag {};
 
-template <class T> tag swap(T &, T &);
-template <class T, std::size_t N> tag swap(T (&a)[N], T (&b)[N]);
+template <class T>
+tag swap(T &, T &);
+template <class T, std::size_t N>
+tag swap(T (&a)[N], T (&b)[N]);
 
 // helper functions to test if an unqualified swap is possible, and if it
 // becomes std::swap
-template <class, class> std::false_type can_swap(...) noexcept(false);
-template <class T, class U,
+template <class, class>
+std::false_type can_swap(...) noexcept(false);
+template <class T,
+          class U,
           class = decltype(swap(std::declval<T &>(), std::declval<U &>()))>
 std::true_type can_swap(int) noexcept(noexcept(swap(std::declval<T &>(),
                                                     std::declval<U &>())));
 
-template <class, class> std::false_type uses_std(...);
+template <class, class>
+std::false_type uses_std(...);
 template <class T, class U>
 std::is_same<decltype(swap(std::declval<T &>(), std::declval<U &>())), tag>
 uses_std(int);
@@ -281,13 +314,20 @@ struct is_nothrow_swappable
 #endif
 
 // std::void_t from C++17
-template <class...> struct voider { using type = void; };
-template <class... Ts> using void_t = typename voider<Ts...>::type;
+template <class...>
+struct voider {
+    using type = void;
+};
+template <class... Ts>
+using void_t = typename voider<Ts...>::type;
 
 // Trait for checking if a type is a tl::optional
-template <class T> struct is_optional_impl : std::false_type {};
-template <class T> struct is_optional_impl<optional<T>> : std::true_type {};
-template <class T> using is_optional = is_optional_impl<decay_t<T>>;
+template <class T>
+struct is_optional_impl : std::false_type {};
+template <class T>
+struct is_optional_impl<optional<T>> : std::true_type {};
+template <class T>
+using is_optional = is_optional_impl<decay_t<T>>;
 
 // Change void to tl::monostate
 template <class U>
@@ -297,7 +337,8 @@ template <class F, class U, class = invoke_result_t<F, U>>
 using get_map_return = optional<fixup_void<invoke_result_t<F, U>>>;
 
 // Check if invoking F for some Us returns void
-template <class F, class = void, class... U> struct returns_void_impl;
+template <class F, class = void, class... U>
+struct returns_void_impl;
 template <class F, class... U>
 struct returns_void_impl<F, void_t<invoke_result_t<F, U...>>, U...>
     : std::is_void<invoke_result_t<F, U...>> {};
@@ -358,7 +399,8 @@ using enable_assign_from_other = detail::enable_if_t<
 template <class T, bool = ::std::is_trivially_destructible<T>::value>
 struct optional_storage_base {
     TL_OPTIONAL_11_CONSTEXPR optional_storage_base() noexcept
-      : m_dummy(), m_has_value(false) {}
+        : m_dummy(),
+          m_has_value(false) {}
 
     template <class... U>
     TL_OPTIONAL_11_CONSTEXPR optional_storage_base(in_place_t, U &&... u)
@@ -381,9 +423,11 @@ struct optional_storage_base {
 };
 
 // This case is for when T is trivially destructible.
-template <class T> struct optional_storage_base<T, true> {
+template <class T>
+struct optional_storage_base<T, true> {
     TL_OPTIONAL_11_CONSTEXPR optional_storage_base() noexcept
-      : m_dummy(), m_has_value(false) {}
+        : m_dummy(),
+          m_has_value(false) {}
 
     template <class... U>
     TL_OPTIONAL_11_CONSTEXPR optional_storage_base(in_place_t, U &&... u)
@@ -402,7 +446,8 @@ template <class T> struct optional_storage_base<T, true> {
 
 // This base class provides some handy member functions which can be used in
 // further derived classes
-template <class T> struct optional_operations_base : optional_storage_base<T> {
+template <class T>
+struct optional_operations_base : optional_storage_base<T> {
     using optional_storage_base<T>::optional_storage_base;
 
     void hard_reset() noexcept {
@@ -410,12 +455,14 @@ template <class T> struct optional_operations_base : optional_storage_base<T> {
         this->m_has_value = false;
     }
 
-  template <class... Args> void construct(Args &&... args) noexcept {
+    template <class... Args>
+    void construct(Args &&... args) noexcept {
         new (std::addressof(this->m_value)) T(std::forward<Args>(args)...);
         this->m_has_value = true;
     }
 
-  template <class Opt> void assign(Opt &&rhs) {
+    template <class Opt>
+    void assign(Opt &&rhs) {
         if (this->has_value()) {
             if (rhs.has_value()) {
                 this->m_value = std::forward<Opt>(rhs).get();
@@ -478,9 +525,11 @@ struct optional_move_base : optional_copy_base<T> {
     using optional_copy_base<T>::optional_copy_base;
 };
 #else
-template <class T, bool = false> struct optional_move_base;
+template <class T, bool = false>
+struct optional_move_base;
 #endif
-template <class T> struct optional_move_base<T, false> : optional_copy_base<T> {
+template <class T>
+struct optional_move_base<T, false> : optional_copy_base<T> {
     using optional_copy_base<T>::optional_copy_base;
 
     optional_move_base() = default;
@@ -499,7 +548,8 @@ template <class T> struct optional_move_base<T, false> : optional_copy_base<T> {
 };
 
 // This class manages conditionally having a trivial copy assignment operator
-template <class T, bool = TL_OPTIONAL_IS_TRIVIALLY_COPY_ASSIGNABLE(T) &&
+template <class T,
+          bool = TL_OPTIONAL_IS_TRIVIALLY_COPY_ASSIGNABLE(T) &&
                  TL_OPTIONAL_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(T) &&
                  TL_OPTIONAL_IS_TRIVIALLY_DESTRUCTIBLE(T)>
 struct optional_copy_assign_base : optional_move_base<T> {
@@ -518,8 +568,8 @@ struct optional_copy_assign_base<T, false> : optional_move_base<T> {
         this->assign(rhs);
         return *this;
     }
-  optional_copy_assign_base &
-  operator=(optional_copy_assign_base &&rhs) = default;
+    optional_copy_assign_base &operator=(optional_copy_assign_base &&rhs) =
+        default;
 };
 
 // This class manages conditionally having a trivial move assignment operator
@@ -528,14 +578,16 @@ struct optional_copy_assign_base<T, false> : optional_move_base<T> {
 // to make do with a non-trivial move assignment operator even if T is trivially
 // move assignable
 #ifndef TL_OPTIONAL_GCC49
-template <class T, bool = std::is_trivially_destructible<T>::value
+template <class T,
+          bool = std::is_trivially_destructible<T>::value
               &&std::is_trivially_move_constructible<T>::value
                   &&std::is_trivially_move_assignable<T>::value>
 struct optional_move_assign_base : optional_copy_assign_base<T> {
     using optional_copy_assign_base<T>::optional_copy_assign_base;
 };
 #else
-template <class T, bool = false> struct optional_move_assign_base;
+template <class T, bool = false>
+struct optional_move_assign_base;
 #endif
 
 template <class T>
@@ -547,8 +599,8 @@ struct optional_move_assign_base<T, false> : optional_copy_assign_base<T> {
 
     optional_move_assign_base(optional_move_assign_base &&rhs) = default;
 
-  optional_move_assign_base &
-  operator=(const optional_move_assign_base &rhs) = default;
+    optional_move_assign_base &operator=(const optional_move_assign_base &rhs) =
+        default;
 
     optional_move_assign_base &
     operator=(optional_move_assign_base &&rhs) noexcept(
@@ -561,46 +613,50 @@ struct optional_move_assign_base<T, false> : optional_copy_assign_base<T> {
 
 // optional_delete_ctor_base will conditionally delete copy and move
 // constructors depending on whether T is copy/move constructible
-template <class T, bool EnableCopy = std::is_copy_constructible<T>::value,
+template <class T,
+          bool EnableCopy = std::is_copy_constructible<T>::value,
           bool EnableMove = std::is_move_constructible<T>::value>
 struct optional_delete_ctor_base {
     optional_delete_ctor_base() = default;
     optional_delete_ctor_base(const optional_delete_ctor_base &) = default;
     optional_delete_ctor_base(optional_delete_ctor_base &&) noexcept = default;
-  optional_delete_ctor_base &
-  operator=(const optional_delete_ctor_base &) = default;
-  optional_delete_ctor_base &
-  operator=(optional_delete_ctor_base &&) noexcept = default;
+    optional_delete_ctor_base &operator=(const optional_delete_ctor_base &) =
+        default;
+    optional_delete_ctor_base &operator=(
+        optional_delete_ctor_base &&) noexcept = default;
 };
 
-template <class T> struct optional_delete_ctor_base<T, true, false> {
+template <class T>
+struct optional_delete_ctor_base<T, true, false> {
     optional_delete_ctor_base() = default;
     optional_delete_ctor_base(const optional_delete_ctor_base &) = default;
     optional_delete_ctor_base(optional_delete_ctor_base &&) noexcept = delete;
-  optional_delete_ctor_base &
-  operator=(const optional_delete_ctor_base &) = default;
-  optional_delete_ctor_base &
-  operator=(optional_delete_ctor_base &&) noexcept = default;
+    optional_delete_ctor_base &operator=(const optional_delete_ctor_base &) =
+        default;
+    optional_delete_ctor_base &operator=(
+        optional_delete_ctor_base &&) noexcept = default;
 };
 
-template <class T> struct optional_delete_ctor_base<T, false, true> {
+template <class T>
+struct optional_delete_ctor_base<T, false, true> {
     optional_delete_ctor_base() = default;
     optional_delete_ctor_base(const optional_delete_ctor_base &) = delete;
     optional_delete_ctor_base(optional_delete_ctor_base &&) noexcept = default;
-  optional_delete_ctor_base &
-  operator=(const optional_delete_ctor_base &) = default;
-  optional_delete_ctor_base &
-  operator=(optional_delete_ctor_base &&) noexcept = default;
+    optional_delete_ctor_base &operator=(const optional_delete_ctor_base &) =
+        default;
+    optional_delete_ctor_base &operator=(
+        optional_delete_ctor_base &&) noexcept = default;
 };
 
-template <class T> struct optional_delete_ctor_base<T, false, false> {
+template <class T>
+struct optional_delete_ctor_base<T, false, false> {
     optional_delete_ctor_base() = default;
     optional_delete_ctor_base(const optional_delete_ctor_base &) = delete;
     optional_delete_ctor_base(optional_delete_ctor_base &&) noexcept = delete;
-  optional_delete_ctor_base &
-  operator=(const optional_delete_ctor_base &) = default;
-  optional_delete_ctor_base &
-  operator=(optional_delete_ctor_base &&) noexcept = default;
+    optional_delete_ctor_base &operator=(const optional_delete_ctor_base &) =
+        default;
+    optional_delete_ctor_base &operator=(
+        optional_delete_ctor_base &&) noexcept = default;
 };
 
 // optional_delete_assign_base will conditionally delete copy and move
@@ -615,43 +671,46 @@ struct optional_delete_assign_base {
     optional_delete_assign_base(const optional_delete_assign_base &) = default;
     optional_delete_assign_base(optional_delete_assign_base &&) noexcept =
         default;
-  optional_delete_assign_base &
-  operator=(const optional_delete_assign_base &) = default;
-  optional_delete_assign_base &
-  operator=(optional_delete_assign_base &&) noexcept = default;
+    optional_delete_assign_base &operator=(
+        const optional_delete_assign_base &) = default;
+    optional_delete_assign_base &operator=(
+        optional_delete_assign_base &&) noexcept = default;
 };
 
-template <class T> struct optional_delete_assign_base<T, true, false> {
+template <class T>
+struct optional_delete_assign_base<T, true, false> {
     optional_delete_assign_base() = default;
     optional_delete_assign_base(const optional_delete_assign_base &) = default;
     optional_delete_assign_base(optional_delete_assign_base &&) noexcept =
         default;
-  optional_delete_assign_base &
-  operator=(const optional_delete_assign_base &) = default;
-  optional_delete_assign_base &
-  operator=(optional_delete_assign_base &&) noexcept = delete;
+    optional_delete_assign_base &operator=(
+        const optional_delete_assign_base &) = default;
+    optional_delete_assign_base &operator=(
+        optional_delete_assign_base &&) noexcept = delete;
 };
 
-template <class T> struct optional_delete_assign_base<T, false, true> {
+template <class T>
+struct optional_delete_assign_base<T, false, true> {
     optional_delete_assign_base() = default;
     optional_delete_assign_base(const optional_delete_assign_base &) = default;
     optional_delete_assign_base(optional_delete_assign_base &&) noexcept =
         default;
-  optional_delete_assign_base &
-  operator=(const optional_delete_assign_base &) = delete;
-  optional_delete_assign_base &
-  operator=(optional_delete_assign_base &&) noexcept = default;
+    optional_delete_assign_base &operator=(
+        const optional_delete_assign_base &) = delete;
+    optional_delete_assign_base &operator=(
+        optional_delete_assign_base &&) noexcept = default;
 };
 
-template <class T> struct optional_delete_assign_base<T, false, false> {
+template <class T>
+struct optional_delete_assign_base<T, false, false> {
     optional_delete_assign_base() = default;
     optional_delete_assign_base(const optional_delete_assign_base &) = default;
     optional_delete_assign_base(optional_delete_assign_base &&) noexcept =
         default;
-  optional_delete_assign_base &
-  operator=(const optional_delete_assign_base &) = delete;
-  optional_delete_assign_base &
-  operator=(optional_delete_assign_base &&) noexcept = delete;
+    optional_delete_assign_base &operator=(
+        const optional_delete_assign_base &) = delete;
+    optional_delete_assign_base &operator=(
+        optional_delete_assign_base &&) noexcept = delete;
 };
 
 }  // namespace detail
@@ -666,7 +725,7 @@ static constexpr nullopt_t nullopt{nullopt_t::do_not_use{},
                                    nullopt_t::do_not_use{}};
 
 class bad_optional_access : public std::exception {
-public:
+  public:
     bad_optional_access() = default;
     const char *what() const noexcept { return "Optional has no value"; }
 };
@@ -688,7 +747,7 @@ class optional : private detail::optional_move_assign_base<T>,
     static_assert(!std::is_same<detail::decay_t<T>, nullopt_t>::value,
                   "instantiation of optional with nullopt_t is ill-formed");
 
-public:
+  public:
 // The different versions for C++14 and 11 are needed because deduced return
 // types are not SFINAE-safe. This provides better support for things like
 // generic lambdas. C.f.
@@ -697,7 +756,8 @@ public:
     !defined(TL_OPTIONAL_GCC54) && !defined(TL_OPTIONAL_GCC55)
     /// Carries out some operation which returns an optional on the stored
     /// object if there is one.
-  template <class F> TL_OPTIONAL_11_CONSTEXPR auto and_then(F &&f) & {
+    template <class F>
+    TL_OPTIONAL_11_CONSTEXPR auto and_then(F &&f) & {
         using result = detail::invoke_result_t<F, T &>;
         static_assert(detail::is_optional<result>::value,
                       "F must return an optional");
@@ -706,16 +766,19 @@ public:
                            : result(nullopt);
     }
 
-  template <class F> TL_OPTIONAL_11_CONSTEXPR auto and_then(F &&f) && {
+    template <class F>
+    TL_OPTIONAL_11_CONSTEXPR auto and_then(F &&f) && {
         using result = detail::invoke_result_t<F, T &&>;
         static_assert(detail::is_optional<result>::value,
                       "F must return an optional");
 
-    return has_value() ? detail::invoke(std::forward<F>(f), std::move(**this))
+        return has_value()
+                   ? detail::invoke(std::forward<F>(f), std::move(**this))
                    : result(nullopt);
     }
 
-  template <class F> constexpr auto and_then(F &&f) const & {
+    template <class F>
+    constexpr auto and_then(F &&f) const & {
         using result = detail::invoke_result_t<F, const T &>;
         static_assert(detail::is_optional<result>::value,
                       "F must return an optional");
@@ -725,12 +788,14 @@ public:
     }
 
 #ifndef TL_OPTIONAL_NO_CONSTRR
-  template <class F> constexpr auto and_then(F &&f) const && {
+    template <class F>
+    constexpr auto and_then(F &&f) const && {
         using result = detail::invoke_result_t<F, const T &&>;
         static_assert(detail::is_optional<result>::value,
                       "F must return an optional");
 
-    return has_value() ? detail::invoke(std::forward<F>(f), std::move(**this))
+        return has_value()
+                   ? detail::invoke(std::forward<F>(f), std::move(**this))
                    : result(nullopt);
     }
 #endif
@@ -748,12 +813,14 @@ public:
     }
 
     template <class F>
-  TL_OPTIONAL_11_CONSTEXPR detail::invoke_result_t<F, T &&> and_then(F &&f) && {
+    TL_OPTIONAL_11_CONSTEXPR detail::invoke_result_t<F, T &&> and_then(
+        F &&f) && {
         using result = detail::invoke_result_t<F, T &&>;
         static_assert(detail::is_optional<result>::value,
                       "F must return an optional");
 
-    return has_value() ? detail::invoke(std::forward<F>(f), std::move(**this))
+        return has_value()
+                   ? detail::invoke(std::forward<F>(f), std::move(**this))
                    : result(nullopt);
     }
 
@@ -774,7 +841,8 @@ public:
         static_assert(detail::is_optional<result>::value,
                       "F must return an optional");
 
-    return has_value() ? detail::invoke(std::forward<F>(f), std::move(**this))
+        return has_value()
+                   ? detail::invoke(std::forward<F>(f), std::move(**this))
                    : result(nullopt);
     }
 #endif
@@ -783,33 +851,37 @@ public:
 #if defined(TL_OPTIONAL_CXX14) && !defined(TL_OPTIONAL_GCC49) && \
     !defined(TL_OPTIONAL_GCC54) && !defined(TL_OPTIONAL_GCC55)
     /// Carries out some operation on the stored object if there is one.
-  template <class F> TL_OPTIONAL_11_CONSTEXPR auto map(F &&f) & {
+    template <class F>
+    TL_OPTIONAL_11_CONSTEXPR auto map(F &&f) & {
         return optional_map_impl(*this, std::forward<F>(f));
     }
 
-  template <class F> TL_OPTIONAL_11_CONSTEXPR auto map(F &&f) && {
+    template <class F>
+    TL_OPTIONAL_11_CONSTEXPR auto map(F &&f) && {
         return optional_map_impl(std::move(*this), std::forward<F>(f));
     }
 
-  template <class F> constexpr auto map(F &&f) const & {
+    template <class F>
+    constexpr auto map(F &&f) const & {
         return optional_map_impl(*this, std::forward<F>(f));
     }
 
-  template <class F> constexpr auto map(F &&f) const && {
+    template <class F>
+    constexpr auto map(F &&f) const && {
         return optional_map_impl(std::move(*this), std::forward<F>(f));
     }
 #else
     /// Carries out some operation on the stored object if there is one.
     template <class F>
-  TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<optional &>(),
-                                             std::declval<F &&>()))
+    TL_OPTIONAL_11_CONSTEXPR decltype(
+        optional_map_impl(std::declval<optional &>(), std::declval<F &&>()))
     map(F &&f) & {
         return optional_map_impl(*this, std::forward<F>(f));
     }
 
     template <class F>
-  TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<optional &&>(),
-                                             std::declval<F &&>()))
+    TL_OPTIONAL_11_CONSTEXPR decltype(
+        optional_map_impl(std::declval<optional &&>(), std::declval<F &&>()))
     map(F &&f) && {
         return optional_map_impl(std::move(*this), std::forward<F>(f));
     }
@@ -834,49 +906,53 @@ public:
 #if defined(TL_OPTIONAL_CXX14) && !defined(TL_OPTIONAL_GCC49) && \
     !defined(TL_OPTIONAL_GCC54) && !defined(TL_OPTIONAL_GCC55)
     /// Carries out some operation on the stored object if there is one.
-  template <class F> TL_OPTIONAL_11_CONSTEXPR auto transform(F&& f) & {
+    template <class F>
+    TL_OPTIONAL_11_CONSTEXPR auto transform(F &&f) & {
         return optional_map_impl(*this, std::forward<F>(f));
     }
 
-  template <class F> TL_OPTIONAL_11_CONSTEXPR auto transform(F&& f) && {
+    template <class F>
+    TL_OPTIONAL_11_CONSTEXPR auto transform(F &&f) && {
         return optional_map_impl(std::move(*this), std::forward<F>(f));
     }
 
-  template <class F> constexpr auto transform(F&& f) const & {
+    template <class F>
+    constexpr auto transform(F &&f) const & {
         return optional_map_impl(*this, std::forward<F>(f));
     }
 
-  template <class F> constexpr auto transform(F&& f) const && {
+    template <class F>
+    constexpr auto transform(F &&f) const && {
         return optional_map_impl(std::move(*this), std::forward<F>(f));
     }
 #else
     /// Carries out some operation on the stored object if there is one.
     template <class F>
-  TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<optional&>(),
-    std::declval<F&&>()))
-    transform(F&& f) & {
+    TL_OPTIONAL_11_CONSTEXPR decltype(
+        optional_map_impl(std::declval<optional &>(), std::declval<F &&>()))
+    transform(F &&f) & {
         return optional_map_impl(*this, std::forward<F>(f));
     }
 
     template <class F>
-  TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<optional&&>(),
-    std::declval<F&&>()))
-    transform(F&& f) && {
+    TL_OPTIONAL_11_CONSTEXPR decltype(
+        optional_map_impl(std::declval<optional &&>(), std::declval<F &&>()))
+    transform(F &&f) && {
         return optional_map_impl(std::move(*this), std::forward<F>(f));
     }
 
     template <class F>
-  constexpr decltype(optional_map_impl(std::declval<const optional&>(),
-    std::declval<F&&>()))
-    transform(F&& f) const & {
+    constexpr decltype(optional_map_impl(std::declval<const optional &>(),
+                                         std::declval<F &&>()))
+    transform(F &&f) const & {
         return optional_map_impl(*this, std::forward<F>(f));
     }
 
 #ifndef TL_OPTIONAL_NO_CONSTRR
     template <class F>
-  constexpr decltype(optional_map_impl(std::declval<const optional&&>(),
-    std::declval<F&&>()))
-    transform(F&& f) const && {
+    constexpr decltype(optional_map_impl(std::declval<const optional &&>(),
+                                         std::declval<F &&>()))
+    transform(F &&f) const && {
         return optional_map_impl(std::move(*this), std::forward<F>(f));
     }
 #endif
@@ -885,8 +961,7 @@ public:
     /// Calls `f` if the optional is empty
     template <class F, detail::enable_if_ret_void<F> * = nullptr>
     optional<T> TL_OPTIONAL_11_CONSTEXPR or_else(F &&f) & {
-    if (has_value())
-      return *this;
+        if (has_value()) return *this;
 
         std::forward<F>(f)();
         return nullopt;
@@ -899,8 +974,7 @@ public:
 
     template <class F, detail::enable_if_ret_void<F> * = nullptr>
     optional<T> or_else(F &&f) && {
-    if (has_value())
-      return std::move(*this);
+        if (has_value()) return std::move(*this);
 
         std::forward<F>(f)();
         return nullopt;
@@ -913,8 +987,7 @@ public:
 
     template <class F, detail::enable_if_ret_void<F> * = nullptr>
     optional<T> or_else(F &&f) const & {
-    if (has_value())
-      return *this;
+        if (has_value()) return *this;
 
         std::forward<F>(f)();
         return nullopt;
@@ -928,8 +1001,7 @@ public:
 #ifndef TL_OPTIONAL_NO_CONSTRR
     template <class F, detail::enable_if_ret_void<F> * = nullptr>
     optional<T> or_else(F &&f) const && {
-    if (has_value())
-      return std::move(*this);
+        if (has_value()) return std::move(*this);
 
         std::forward<F>(f)();
         return nullopt;
@@ -942,24 +1014,30 @@ public:
 #endif
 
     /// Maps the stored value with `f` if there is one, otherwise returns `u`.
-  template <class F, class U> U map_or(F &&f, U &&u) & {
+    template <class F, class U>
+    U map_or(F &&f, U &&u) & {
         return has_value() ? detail::invoke(std::forward<F>(f), **this)
                            : std::forward<U>(u);
     }
 
-  template <class F, class U> U map_or(F &&f, U &&u) && {
-    return has_value() ? detail::invoke(std::forward<F>(f), std::move(**this))
+    template <class F, class U>
+    U map_or(F &&f, U &&u) && {
+        return has_value()
+                   ? detail::invoke(std::forward<F>(f), std::move(**this))
                    : std::forward<U>(u);
     }
 
-  template <class F, class U> U map_or(F &&f, U &&u) const & {
+    template <class F, class U>
+    U map_or(F &&f, U &&u) const & {
         return has_value() ? detail::invoke(std::forward<F>(f), **this)
                            : std::forward<U>(u);
     }
 
 #ifndef TL_OPTIONAL_NO_CONSTRR
-  template <class F, class U> U map_or(F &&f, U &&u) const && {
-    return has_value() ? detail::invoke(std::forward<F>(f), std::move(**this))
+    template <class F, class U>
+    U map_or(F &&f, U &&u) const && {
+        return has_value()
+                   ? detail::invoke(std::forward<F>(f), std::move(**this))
                    : std::forward<U>(u);
     }
 #endif
@@ -974,7 +1052,8 @@ public:
 
     template <class F, class U>
     detail::invoke_result_t<U> map_or_else(F &&f, U &&u) && {
-    return has_value() ? detail::invoke(std::forward<F>(f), std::move(**this))
+        return has_value()
+                   ? detail::invoke(std::forward<F>(f), std::move(**this))
                    : std::forward<U>(u)();
     }
 
@@ -987,7 +1066,8 @@ public:
 #ifndef TL_OPTIONAL_NO_CONSTRR
     template <class F, class U>
     detail::invoke_result_t<U> map_or_else(F &&f, U &&u) const && {
-    return has_value() ? detail::invoke(std::forward<F>(f), std::move(**this))
+        return has_value()
+                   ? detail::invoke(std::forward<F>(f), std::move(**this))
                    : std::forward<U>(u)();
     }
 #endif
@@ -1065,16 +1145,19 @@ public:
     /// Constructs the stored value in-place using the given arguments.
     template <class... Args>
     constexpr explicit optional(
-      detail::enable_if_t<std::is_constructible<T, Args...>::value, in_place_t>,
+        detail::enable_if_t<std::is_constructible<T, Args...>::value,
+                            in_place_t>,
         Args &&... args)
         : base(in_place, std::forward<Args>(args)...) {}
 
     template <class U, class... Args>
     TL_OPTIONAL_11_CONSTEXPR explicit optional(
-      detail::enable_if_t<std::is_constructible<T, std::initializer_list<U> &,
+        detail::enable_if_t<std::is_constructible<T,
+                                                  std::initializer_list<U> &,
                                                   Args &&...>::value,
                             in_place_t>,
-      std::initializer_list<U> il, Args &&... args) {
+        std::initializer_list<U> il,
+        Args &&... args) {
         this->construct(il, std::forward<Args>(args)...);
     }
 
@@ -1092,16 +1175,18 @@ public:
     constexpr explicit optional(U &&u) : base(in_place, std::forward<U>(u)) {}
 
     /// Converting copy constructor.
-  template <
-      class U, detail::enable_from_other<T, U, const U &> * = nullptr,
-      detail::enable_if_t<std::is_convertible<const U &, T>::value> * = nullptr>
+    template <class U,
+              detail::enable_from_other<T, U, const U &> * = nullptr,
+              detail::enable_if_t<std::is_convertible<const U &, T>::value> * =
+                  nullptr>
     optional(const optional<U> &rhs) {
         if (rhs.has_value()) {
             this->construct(*rhs);
         }
     }
 
-  template <class U, detail::enable_from_other<T, U, const U &> * = nullptr,
+    template <class U,
+              detail::enable_from_other<T, U, const U &> * = nullptr,
               detail::enable_if_t<!std::is_convertible<const U &, T>::value> * =
                   nullptr>
     explicit optional(const optional<U> &rhs) {
@@ -1112,7 +1197,8 @@ public:
 
     /// Converting move constructor.
     template <
-      class U, detail::enable_from_other<T, U, U &&> * = nullptr,
+        class U,
+        detail::enable_from_other<T, U, U &&> * = nullptr,
         detail::enable_if_t<std::is_convertible<U &&, T>::value> * = nullptr>
     optional(optional<U> &&rhs) {
         if (rhs.has_value()) {
@@ -1121,7 +1207,8 @@ public:
     }
 
     template <
-      class U, detail::enable_from_other<T, U, U &&> * = nullptr,
+        class U,
+        detail::enable_from_other<T, U, U &&> * = nullptr,
         detail::enable_if_t<!std::is_convertible<U &&, T>::value> * = nullptr>
     explicit optional(optional<U> &&rhs) {
         if (rhs.has_value()) {
@@ -1215,7 +1302,8 @@ public:
 
     /// Constructs the value in-place, destroying the current one if there is
     /// one.
-  template <class... Args> T &emplace(Args &&... args) {
+    template <class... Args>
+    T &emplace(Args &&... args) {
         static_assert(std::is_constructible<T, Args &&...>::value,
                       "T must be constructible with Args");
 
@@ -1240,8 +1328,8 @@ public:
     /// If both have a value, the values are swapped.
     /// If one has a value, it is moved to the other and the movee is left
     /// valueless.
-  void
-  swap(optional &rhs) noexcept(std::is_nothrow_move_constructible<T>::value
+    void swap(optional &rhs) noexcept(
+        std::is_nothrow_move_constructible<T>::value
             &&detail::is_nothrow_swappable<T>::value) {
         using std::swap;
         if (has_value()) {
@@ -1277,7 +1365,9 @@ public:
     }
 
 #ifndef TL_OPTIONAL_NO_CONSTRR
-  constexpr const T &&operator*() const && { return std::move(this->m_value); }
+    constexpr const T &&operator*() const && {
+        return std::move(this->m_value);
+    }
 #endif
 
     /// Returns whether or not the optional has a value
@@ -1287,40 +1377,39 @@ public:
         return this->m_has_value;
     }
 
-  /// Returns the contained value if there is one, otherwise throws bad_optional_access
+    /// Returns the contained value if there is one, otherwise throws
+    /// bad_optional_access
     TL_OPTIONAL_11_CONSTEXPR T &value() & {
-    if (has_value())
-      return this->m_value;
+        if (has_value()) return this->m_value;
         throw bad_optional_access();
     }
     TL_OPTIONAL_11_CONSTEXPR const T &value() const & {
-    if (has_value())
-      return this->m_value;
+        if (has_value()) return this->m_value;
         throw bad_optional_access();
     }
     TL_OPTIONAL_11_CONSTEXPR T &&value() && {
-    if (has_value())
-      return std::move(this->m_value);
+        if (has_value()) return std::move(this->m_value);
         throw bad_optional_access();
     }
 
 #ifndef TL_OPTIONAL_NO_CONSTRR
     TL_OPTIONAL_11_CONSTEXPR const T &&value() const && {
-    if (has_value())
-      return std::move(this->m_value);
+        if (has_value()) return std::move(this->m_value);
         throw bad_optional_access();
     }
 #endif
 
     /// Returns the stored value if there is one, otherwise returns `u`
-  template <class U> constexpr T value_or(U &&u) const & {
+    template <class U>
+    constexpr T value_or(U &&u) const & {
         static_assert(std::is_copy_constructible<T>::value &&
                           std::is_convertible<U &&, T>::value,
                       "T must be copy constructible and convertible from U");
         return has_value() ? **this : static_cast<T>(std::forward<U>(u));
     }
 
-  template <class U> TL_OPTIONAL_11_CONSTEXPR T value_or(U &&u) && {
+    template <class U>
+    TL_OPTIONAL_11_CONSTEXPR T value_or(U &&u) && {
         static_assert(std::is_move_constructible<T>::value &&
                           std::is_convertible<U &&, T>::value,
                       "T must be move constructible and convertible from U");
@@ -1482,10 +1571,12 @@ namespace detail {
 struct i_am_secret {};
 }  // namespace detail
 
-template <class T = detail::i_am_secret, class U,
+template <class T = detail::i_am_secret,
+          class U,
           class Ret =
               detail::conditional_t<std::is_same<T, detail::i_am_secret>::value,
-                                    detail::decay_t<U>, T>>
+                                    detail::decay_t<U>,
+                                    T>>
 inline constexpr optional<Ret> make_optional(U &&v) {
     return optional<Ret>(std::forward<U>(v));
 }
@@ -1501,13 +1592,15 @@ inline constexpr optional<T> make_optional(std::initializer_list<U> il,
 }
 
 #if __cplusplus >= 201703L
-template <class T> optional(T)->optional<T>;
+template <class T>
+optional(T)->optional<T>;
 #endif
 
 /// \exclude
 namespace detail {
 #ifdef TL_OPTIONAL_CXX14
-template <class Opt, class F,
+template <class Opt,
+          class F,
           class Ret = decltype(detail::invoke(std::declval<F>(),
                                               *std::declval<Opt>())),
           detail::enable_if_t<!std::is_void<Ret>::value> * = nullptr>
@@ -1517,7 +1610,8 @@ constexpr auto optional_map_impl(Opt &&opt, F &&f) {
                : optional<Ret>(nullopt);
 }
 
-template <class Opt, class F,
+template <class Opt,
+          class F,
           class Ret = decltype(detail::invoke(std::declval<F>(),
                                               *std::declval<Opt>())),
           detail::enable_if_t<std::is_void<Ret>::value> * = nullptr>
@@ -1530,7 +1624,8 @@ auto optional_map_impl(Opt &&opt, F &&f) {
     return optional<monostate>(nullopt);
 }
 #else
-template <class Opt, class F,
+template <class Opt,
+          class F,
           class Ret = decltype(detail::invoke(std::declval<F>(),
                                               *std::declval<Opt>())),
           detail::enable_if_t<!std::is_void<Ret>::value> * = nullptr>
@@ -1541,7 +1636,8 @@ constexpr auto optional_map_impl(Opt &&opt, F &&f) -> optional<Ret> {
                : optional<Ret>(nullopt);
 }
 
-template <class Opt, class F,
+template <class Opt,
+          class F,
           class Ret = decltype(detail::invoke(std::declval<F>(),
                                               *std::declval<Opt>())),
           detail::enable_if_t<std::is_void<Ret>::value> * = nullptr>
@@ -1559,8 +1655,9 @@ auto optional_map_impl(Opt &&opt, F &&f) -> optional<monostate> {
 
 /// Specialization for when `T` is a reference. `optional<T&>` acts similarly
 /// to a `T*`, but provides more operations and shows intent more clearly.
-template <class T> class optional<T &> {
-public:
+template <class T>
+class optional<T &> {
+  public:
 // The different versions for C++14 and 11 are needed because deduced return
 // types are not SFINAE-safe. This provides better support for things like
 // generic lambdas. C.f.
@@ -1570,7 +1667,8 @@ public:
 
     /// Carries out some operation which returns an optional on the stored
     /// object if there is one.
-  template <class F> TL_OPTIONAL_11_CONSTEXPR auto and_then(F &&f) & {
+    template <class F>
+    TL_OPTIONAL_11_CONSTEXPR auto and_then(F &&f) & {
         using result = detail::invoke_result_t<F, T &>;
         static_assert(detail::is_optional<result>::value,
                       "F must return an optional");
@@ -1579,7 +1677,8 @@ public:
                            : result(nullopt);
     }
 
-  template <class F> TL_OPTIONAL_11_CONSTEXPR auto and_then(F &&f) && {
+    template <class F>
+    TL_OPTIONAL_11_CONSTEXPR auto and_then(F &&f) && {
         using result = detail::invoke_result_t<F, T &>;
         static_assert(detail::is_optional<result>::value,
                       "F must return an optional");
@@ -1588,7 +1687,8 @@ public:
                            : result(nullopt);
     }
 
-  template <class F> constexpr auto and_then(F &&f) const & {
+    template <class F>
+    constexpr auto and_then(F &&f) const & {
         using result = detail::invoke_result_t<F, const T &>;
         static_assert(detail::is_optional<result>::value,
                       "F must return an optional");
@@ -1598,7 +1698,8 @@ public:
     }
 
 #ifndef TL_OPTIONAL_NO_CONSTRR
-  template <class F> constexpr auto and_then(F &&f) const && {
+    template <class F>
+    constexpr auto and_then(F &&f) const && {
         using result = detail::invoke_result_t<F, const T &>;
         static_assert(detail::is_optional<result>::value,
                       "F must return an optional");
@@ -1621,7 +1722,8 @@ public:
     }
 
     template <class F>
-  TL_OPTIONAL_11_CONSTEXPR detail::invoke_result_t<F, T &> and_then(F &&f) && {
+    TL_OPTIONAL_11_CONSTEXPR detail::invoke_result_t<F, T &> and_then(
+        F &&f) && {
         using result = detail::invoke_result_t<F, T &>;
         static_assert(detail::is_optional<result>::value,
                       "F must return an optional");
@@ -1656,48 +1758,52 @@ public:
 #if defined(TL_OPTIONAL_CXX14) && !defined(TL_OPTIONAL_GCC49) && \
     !defined(TL_OPTIONAL_GCC54) && !defined(TL_OPTIONAL_GCC55)
     /// Carries out some operation on the stored object if there is one.
-  template <class F> TL_OPTIONAL_11_CONSTEXPR auto map(F &&f) & {
+    template <class F>
+    TL_OPTIONAL_11_CONSTEXPR auto map(F &&f) & {
         return detail::optional_map_impl(*this, std::forward<F>(f));
     }
 
-  template <class F> TL_OPTIONAL_11_CONSTEXPR auto map(F &&f) && {
+    template <class F>
+    TL_OPTIONAL_11_CONSTEXPR auto map(F &&f) && {
         return detail::optional_map_impl(std::move(*this), std::forward<F>(f));
     }
 
-  template <class F> constexpr auto map(F &&f) const & {
+    template <class F>
+    constexpr auto map(F &&f) const & {
         return detail::optional_map_impl(*this, std::forward<F>(f));
     }
 
-  template <class F> constexpr auto map(F &&f) const && {
+    template <class F>
+    constexpr auto map(F &&f) const && {
         return detail::optional_map_impl(std::move(*this), std::forward<F>(f));
     }
 #else
     /// Carries out some operation on the stored object if there is one.
     template <class F>
-  TL_OPTIONAL_11_CONSTEXPR decltype(detail::optional_map_impl(std::declval<optional &>(),
-                                                     std::declval<F &&>()))
+    TL_OPTIONAL_11_CONSTEXPR decltype(detail::optional_map_impl(
+        std::declval<optional &>(), std::declval<F &&>()))
     map(F &&f) & {
         return detail::optional_map_impl(*this, std::forward<F>(f));
     }
 
     template <class F>
-  TL_OPTIONAL_11_CONSTEXPR decltype(detail::optional_map_impl(std::declval<optional &&>(),
-                                                     std::declval<F &&>()))
+    TL_OPTIONAL_11_CONSTEXPR decltype(detail::optional_map_impl(
+        std::declval<optional &&>(), std::declval<F &&>()))
     map(F &&f) && {
         return detail::optional_map_impl(std::move(*this), std::forward<F>(f));
     }
 
     template <class F>
-  constexpr decltype(detail::optional_map_impl(std::declval<const optional &>(),
-                                      std::declval<F &&>()))
+    constexpr decltype(detail::optional_map_impl(
+        std::declval<const optional &>(), std::declval<F &&>()))
     map(F &&f) const & {
         return detail::optional_map_impl(*this, std::forward<F>(f));
     }
 
 #ifndef TL_OPTIONAL_NO_CONSTRR
     template <class F>
-  constexpr decltype(detail::optional_map_impl(std::declval<const optional &&>(),
-                                      std::declval<F &&>()))
+    constexpr decltype(detail::optional_map_impl(
+        std::declval<const optional &&>(), std::declval<F &&>()))
     map(F &&f) const && {
         return detail::optional_map_impl(std::move(*this), std::forward<F>(f));
     }
@@ -1707,51 +1813,55 @@ public:
 #if defined(TL_OPTIONAL_CXX14) && !defined(TL_OPTIONAL_GCC49) && \
     !defined(TL_OPTIONAL_GCC54) && !defined(TL_OPTIONAL_GCC55)
     /// Carries out some operation on the stored object if there is one.
-  template <class F> TL_OPTIONAL_11_CONSTEXPR auto transform(F&& f) & {
+    template <class F>
+    TL_OPTIONAL_11_CONSTEXPR auto transform(F &&f) & {
         return detail::optional_map_impl(*this, std::forward<F>(f));
     }
 
-  template <class F> TL_OPTIONAL_11_CONSTEXPR auto transform(F&& f) && {
+    template <class F>
+    TL_OPTIONAL_11_CONSTEXPR auto transform(F &&f) && {
         return detail::optional_map_impl(std::move(*this), std::forward<F>(f));
     }
 
-  template <class F> constexpr auto transform(F&& f) const & {
+    template <class F>
+    constexpr auto transform(F &&f) const & {
         return detail::optional_map_impl(*this, std::forward<F>(f));
     }
 
-  template <class F> constexpr auto transform(F&& f) const && {
+    template <class F>
+    constexpr auto transform(F &&f) const && {
         return detail::optional_map_impl(std::move(*this), std::forward<F>(f));
     }
 #else
     /// Carries out some operation on the stored object if there is one.
     template <class F>
-  TL_OPTIONAL_11_CONSTEXPR decltype(detail::optional_map_impl(std::declval<optional&>(),
-    std::declval<F&&>()))
-    transform(F&& f) & {
+    TL_OPTIONAL_11_CONSTEXPR decltype(detail::optional_map_impl(
+        std::declval<optional &>(), std::declval<F &&>()))
+    transform(F &&f) & {
         return detail::optional_map_impl(*this, std::forward<F>(f));
     }
 
     /// \group map
     /// \synopsis template <class F> auto transform(F &&f) &&;
     template <class F>
-  TL_OPTIONAL_11_CONSTEXPR decltype(detail::optional_map_impl(std::declval<optional&&>(),
-    std::declval<F&&>()))
-    transform(F&& f) && {
+    TL_OPTIONAL_11_CONSTEXPR decltype(detail::optional_map_impl(
+        std::declval<optional &&>(), std::declval<F &&>()))
+    transform(F &&f) && {
         return detail::optional_map_impl(std::move(*this), std::forward<F>(f));
     }
 
     template <class F>
-  constexpr decltype(detail::optional_map_impl(std::declval<const optional&>(),
-    std::declval<F&&>()))
-    transform(F&& f) const & {
+    constexpr decltype(detail::optional_map_impl(
+        std::declval<const optional &>(), std::declval<F &&>()))
+    transform(F &&f) const & {
         return detail::optional_map_impl(*this, std::forward<F>(f));
     }
 
 #ifndef TL_OPTIONAL_NO_CONSTRR
     template <class F>
-  constexpr decltype(detail::optional_map_impl(std::declval<const optional&&>(),
-    std::declval<F&&>()))
-    transform(F&& f) const && {
+    constexpr decltype(detail::optional_map_impl(
+        std::declval<const optional &&>(), std::declval<F &&>()))
+    transform(F &&f) const && {
         return detail::optional_map_impl(std::move(*this), std::forward<F>(f));
     }
 #endif
@@ -1760,8 +1870,7 @@ public:
     /// Calls `f` if the optional is empty
     template <class F, detail::enable_if_ret_void<F> * = nullptr>
     optional<T> TL_OPTIONAL_11_CONSTEXPR or_else(F &&f) & {
-    if (has_value())
-      return *this;
+        if (has_value()) return *this;
 
         std::forward<F>(f)();
         return nullopt;
@@ -1774,8 +1883,7 @@ public:
 
     template <class F, detail::enable_if_ret_void<F> * = nullptr>
     optional<T> or_else(F &&f) && {
-    if (has_value())
-      return std::move(*this);
+        if (has_value()) return std::move(*this);
 
         std::forward<F>(f)();
         return nullopt;
@@ -1788,8 +1896,7 @@ public:
 
     template <class F, detail::enable_if_ret_void<F> * = nullptr>
     optional<T> or_else(F &&f) const & {
-    if (has_value())
-      return *this;
+        if (has_value()) return *this;
 
         std::forward<F>(f)();
         return nullopt;
@@ -1803,8 +1910,7 @@ public:
 #ifndef TL_OPTIONAL_NO_CONSTRR
     template <class F, detail::enable_if_ret_void<F> * = nullptr>
     optional<T> or_else(F &&f) const && {
-    if (has_value())
-      return std::move(*this);
+        if (has_value()) return std::move(*this);
 
         std::forward<F>(f)();
         return nullopt;
@@ -1817,24 +1923,30 @@ public:
 #endif
 
     /// Maps the stored value with `f` if there is one, otherwise returns `u`
-  template <class F, class U> U map_or(F &&f, U &&u) & {
+    template <class F, class U>
+    U map_or(F &&f, U &&u) & {
         return has_value() ? detail::invoke(std::forward<F>(f), **this)
                            : std::forward<U>(u);
     }
 
-  template <class F, class U> U map_or(F &&f, U &&u) && {
-    return has_value() ? detail::invoke(std::forward<F>(f), std::move(**this))
+    template <class F, class U>
+    U map_or(F &&f, U &&u) && {
+        return has_value()
+                   ? detail::invoke(std::forward<F>(f), std::move(**this))
                    : std::forward<U>(u);
     }
 
-  template <class F, class U> U map_or(F &&f, U &&u) const & {
+    template <class F, class U>
+    U map_or(F &&f, U &&u) const & {
         return has_value() ? detail::invoke(std::forward<F>(f), **this)
                            : std::forward<U>(u);
     }
 
 #ifndef TL_OPTIONAL_NO_CONSTRR
-  template <class F, class U> U map_or(F &&f, U &&u) const && {
-    return has_value() ? detail::invoke(std::forward<F>(f), std::move(**this))
+    template <class F, class U>
+    U map_or(F &&f, U &&u) const && {
+        return has_value()
+                   ? detail::invoke(std::forward<F>(f), std::move(**this))
                    : std::forward<U>(u);
     }
 #endif
@@ -1849,7 +1961,8 @@ public:
 
     template <class F, class U>
     detail::invoke_result_t<U> map_or_else(F &&f, U &&u) && {
-    return has_value() ? detail::invoke(std::forward<F>(f), std::move(**this))
+        return has_value()
+                   ? detail::invoke(std::forward<F>(f), std::move(**this))
                    : std::forward<U>(u)();
     }
 
@@ -1862,7 +1975,8 @@ public:
 #ifndef TL_OPTIONAL_NO_CONSTRR
     template <class F, class U>
     detail::invoke_result_t<U> map_or_else(F &&f, U &&u) const && {
-    return has_value() ? detail::invoke(std::forward<F>(f), std::move(**this))
+        return has_value()
+                   ? detail::invoke(std::forward<F>(f), std::move(**this))
                    : std::forward<U>(u)();
     }
 #endif
@@ -1939,14 +2053,16 @@ public:
 
     /// Constructs the stored value with `u`.
     template <class U = T,
-            detail::enable_if_t<!detail::is_optional<detail::decay_t<U>>::value>
-                * = nullptr>
+              detail::enable_if_t<
+                  !detail::is_optional<detail::decay_t<U>>::value> * = nullptr>
     constexpr optional(U &&u) noexcept : m_value(std::addressof(u)) {
-    static_assert(std::is_lvalue_reference<U>::value, "U must be an lvalue");
+        static_assert(std::is_lvalue_reference<U>::value,
+                      "U must be an lvalue");
     }
 
     template <class U>
-  constexpr explicit optional(const optional<U> &rhs) noexcept : optional(*rhs) {}
+    constexpr explicit optional(const optional<U> &rhs) noexcept
+        : optional(*rhs) {}
 
     /// No-op
     ~optional() = default;
@@ -1967,10 +2083,11 @@ public:
 
     /// Rebinds this optional to `u`.
     template <class U = T,
-            detail::enable_if_t<!detail::is_optional<detail::decay_t<U>>::value>
-                * = nullptr>
+              detail::enable_if_t<
+                  !detail::is_optional<detail::decay_t<U>>::value> * = nullptr>
     optional &operator=(U &&u) {
-    static_assert(std::is_lvalue_reference<U>::value, "U must be an lvalue");
+        static_assert(std::is_lvalue_reference<U>::value,
+                      "U must be an lvalue");
         m_value = std::addressof(u);
         return *this;
     }
@@ -1979,15 +2096,16 @@ public:
     ///
     /// Rebinds this optional to the referee of `rhs` if there is one. Otherwise
     /// resets the stored value in `*this`.
-  template <class U> optional &operator=(const optional<U> &rhs) noexcept {
+    template <class U>
+    optional &operator=(const optional<U> &rhs) noexcept {
         m_value = std::addressof(rhs.value());
         return *this;
     }
 
     /// Rebinds this optional to `u`.
     template <class U = T,
-            detail::enable_if_t<!detail::is_optional<detail::decay_t<U>>::value>
-                * = nullptr>
+              detail::enable_if_t<
+                  !detail::is_optional<detail::decay_t<U>>::value> * = nullptr>
     optional &emplace(U &&u) noexcept {
         return *this = std::forward<U>(u);
     }
@@ -2010,20 +2128,20 @@ public:
         return m_value != nullptr;
     }
 
-  /// Returns the contained value if there is one, otherwise throws bad_optional_access
+    /// Returns the contained value if there is one, otherwise throws
+    /// bad_optional_access
     TL_OPTIONAL_11_CONSTEXPR T &value() {
-    if (has_value())
-      return *m_value;
+        if (has_value()) return *m_value;
         throw bad_optional_access();
     }
     TL_OPTIONAL_11_CONSTEXPR const T &value() const {
-    if (has_value())
-      return *m_value;
+        if (has_value()) return *m_value;
         throw bad_optional_access();
     }
 
     /// Returns the stored value if there is one, otherwise returns `u`
-  template <class U> constexpr T value_or(U &&u) const & noexcept {
+    template <class U>
+    constexpr T value_or(U &&u) const &noexcept {
         static_assert(std::is_copy_constructible<T>::value &&
                           std::is_convertible<U &&, T>::value,
                       "T must be copy constructible and convertible from U");
@@ -2031,7 +2149,8 @@ public:
     }
 
     /// \group value_or
-  template <class U> TL_OPTIONAL_11_CONSTEXPR T value_or(U &&u) && noexcept {
+    template <class U>
+        TL_OPTIONAL_11_CONSTEXPR T value_or(U &&u) && noexcept {
         static_assert(std::is_move_constructible<T>::value &&
                           std::is_convertible<U &&, T>::value,
                       "T must be move constructible and convertible from U");
@@ -2041,20 +2160,19 @@ public:
     /// Destroys the stored value if one exists, making the optional empty
     void reset() noexcept { m_value = nullptr; }
 
-private:
+  private:
     T *m_value;
 };  // namespace tl
 
 
-
 }  // namespace tl
 
 namespace std {
 // TODO SFINAE
-template <class T> struct hash<tl::optional<T>> {
+template <class T>
+struct hash<tl::optional<T>> {
     ::std::size_t operator()(const tl::optional<T> &o) const {
-    if (!o.has_value())
-      return 0;
+        if (!o.has_value()) return 0;
 
         return std::hash<tl::detail::remove_const_t<T>>()(*o);
     }

paddlespeech/audio/src/pybind/kaldi_frontend/feature_common.h

@@ -14,9 +14,9 @@
 
 #pragma once
 
-#include "feat/feature-window.h"
-#include <pybind11/pybind11.h>
 #include <pybind11/numpy.h>
+#include <pybind11/pybind11.h>
+#include "feat/feature-window.h"
 
 namespace paddleaudio {
 
@@ -29,13 +29,9 @@ class StreamingFeatureTpl {
     StreamingFeatureTpl(const Options& opts);
     bool ComputeFeature(const kaldi::VectorBase<kaldi::BaseFloat>& wav,
                         kaldi::Vector<kaldi::BaseFloat>* feats);
-    void Reset() {
-        remained_wav_.Resize(0);
-    }
+    void Reset() { remained_wav_.Resize(0); }
 
-    int Dim() {
-      return computer_.Dim();
-    }
+    int Dim() { return computer_.Dim(); }
 
   private:
     bool Compute(const kaldi::Vector<kaldi::BaseFloat>& waves,
@@ -49,4 +45,3 @@ class StreamingFeatureTpl {
 }  // namespace ppspeech
 
 #include "feature_common_inl.h"
-

paddlespeech/audio/src/pybind/kaldi_frontend/feature_common_inl.h

@@ -17,15 +17,14 @@
 namespace paddleaudio {
 
 template <class F>
-StreamingFeatureTpl<F>::StreamingFeatureTpl(
-    const Options& opts)
-    : opts_(opts), computer_(opts), 
-      window_function_(opts.frame_opts) {
-      //window_function_(computer_.GetFrameOptions()) { the opt set to zero
+StreamingFeatureTpl<F>::StreamingFeatureTpl(const Options& opts)
+    : opts_(opts), computer_(opts), window_function_(opts.frame_opts) {
+    // window_function_(computer_.GetFrameOptions()) { the opt set to zero
 }
 
 template <class F>
-bool StreamingFeatureTpl<F>::ComputeFeature(const kaldi::VectorBase<kaldi::BaseFloat>& wav, 
+bool StreamingFeatureTpl<F>::ComputeFeature(
+    const kaldi::VectorBase<kaldi::BaseFloat>& wav,
     kaldi::Vector<kaldi::BaseFloat>* feats) {
     // append remaned waves
     kaldi::int32 wav_len = wav.Dim();

paddlespeech/audio/src/pybind/kaldi_frontend/kaldi_feature.cc

 
-#include <pybind11/pybind11.h>
 #include <pybind11/numpy.h>
+#include <pybind11/pybind11.h>
 
 #include "kaldi_feature_wrapper.h"
 
-namespace py=pybind11;
+namespace py = pybind11;
 
-bool InitFbank(
-    float samp_freq, // frame opts 
+bool InitFbank(float samp_freq,  // frame opts
                float frame_shift_ms,
                float frame_length_ms,
                float dither,
@@ -139,5 +138,7 @@ PYBIND11_MODULE(kaldi_featurepy, m) {
     m.def("InitFbank", &InitFbank, "init fbank");
     m.def("ResetFbank", &ResetFbank, "reset fbank");
     m.def("ComputeFbank", &ComputeFbank, "compute fbank");
-    m.def("ComputeFbankStreaming", &ComputeFbankStreaming, "compute fbank streaming");
+    m.def("ComputeFbankStreaming",
+          &ComputeFbankStreaming,
+          "compute fbank streaming");
 }

paddlespeech/audio/src/pybind/kaldi_frontend/kaldi_feature.h

-#include <pybind11/pybind11.h>
 #include <pybind11/numpy.h>
+#include <pybind11/pybind11.h>
 
 #include "kaldi_feature_wrapper.h"
 
-namespace py=pybind11;
+namespace py = pybind11;
 
-bool InitFbank(
-    float samp_freq, // frame opts 
+bool InitFbank(float samp_freq,  // frame opts
                float frame_shift_ms,
                float frame_length_ms,
                float dither,

paddlespeech/audio/src/pybind/kaldi_frontend/kaldi_feature_wrapper.cc

@@ -12,7 +12,8 @@ bool KaldiFeatureWrapper::InitFbank(kaldi::FbankOptions opts) {
     return true;
 }
 
-py::array_t<double> KaldiFeatureWrapper::ComputeFbank(const py::array_t<double> wav) {
+py::array_t<double> KaldiFeatureWrapper::ComputeFbank(
+    const py::array_t<double> wav) {
     py::buffer_info info = wav.request();
     kaldi::Vector<kaldi::BaseFloat> input_wav(info.size);
     double* wav_ptr = (double*)info.ptr;
@@ -38,8 +39,8 @@ py::array_t<double> KaldiFeatureWrapper::ComputeFbank(const py::array_t<double>
         res_ptr++;
     }
 
-    return result.reshape({ feats.Dim() / Dim(), Dim()});
-/*
+    return result.reshape({feats.Dim() / Dim(), Dim()});
+    /*
          py::buffer_info info = wav.request();
         std::cout << info.size << std::endl;
         auto result = py::array_t<double>(info.size);
@@ -48,9 +49,10 @@ py::array_t<double> KaldiFeatureWrapper::ComputeFbank(const py::array_t<double>
         py::buffer_info info_re = result.request();
 
         memcpy(input_wav.Data(), (double*)info.ptr, wav.nbytes());
-    memcpy((double*)info_re.ptr, input_wav.Data(), input_wav.Dim()* sizeof(double));
+        memcpy((double*)info_re.ptr, input_wav.Data(), input_wav.Dim()*
+       sizeof(double));
         return result;
-*/
+    */
 }
 
 

paddlespeech/audio/src/pybind/kaldi_frontend/kaldi_feature_wrapper.h

 
 #include "base/kaldi-common.h"
-#include "feature_common.h"
 #include "feat/feature-fbank.h"
+#include "feature_common.h"
 
 #pragma once
 
@@ -14,12 +14,8 @@ class KaldiFeatureWrapper {
     static KaldiFeatureWrapper* GetInstance();
     bool InitFbank(kaldi::FbankOptions opts);
     py::array_t<double> ComputeFbank(const py::array_t<double> wav);
-    int Dim() {
-      return fbank_->Dim();
-    }
-    void ResetFbank() {
-      fbank_->Reset();
-    }
+    int Dim() { return fbank_->Dim(); }
+    void ResetFbank() { fbank_->Reset(); }
 
   private:
     std::unique_ptr<paddleaudio::Fbank> fbank_;

paddlespeech/audio/src/pybind/pybind.cpp

-//Copyright (c) 2017 Facebook Inc. (Soumith Chintala), 
-//All rights reserved.
+// Copyright (c) 2017 Facebook Inc. (Soumith Chintala),
+// All rights reserved.
 
 #include "paddlespeech/audio/src/pybind/sox/io.h"
 
 PYBIND11_MODULE(_paddleaudio, m) {
-  m.def("get_info_file", &paddleaudio::sox_io::get_info_file,
+    m.def("get_info_file",
+          &paddleaudio::sox_io::get_info_file,
           "Get metadata of audio file.");
-  m.def("get_info_fileobj", &paddleaudio::sox_io::get_info_fileobj,
+    m.def("get_info_fileobj",
+          &paddleaudio::sox_io::get_info_fileobj,
           "Get metadata of audio in file object.");
 }
\ No newline at end of file

paddlespeech/audio/src/pybind/sox/io.cpp

-//Copyright (c) 2017 Facebook Inc. (Soumith Chintala), 
-//All rights reserved.
+// Copyright (c) 2017 Facebook Inc. (Soumith Chintala),
+// All rights reserved.
 
 #include "paddlespeech/audio/src/pybind/sox/io.h"
 #include "paddlespeech/audio/src/pybind/sox/utils.h"
@@ -11,7 +11,8 @@ namespace sox_io {
 
 auto get_info_file(const std::string &path, const std::string &format)
     -> std::tuple<int64_t, int64_t, int64_t, int64_t, std::string> {
-  SoxFormat sf(sox_open_read(path.data(),
+    SoxFormat sf(
+        sox_open_read(path.data(),
                       /*signal=*/nullptr,
                       /*encoding=*/nullptr,
                       /*filetype=*/format.empty() ? nullptr : format.data()));
@@ -41,7 +42,9 @@ auto get_info_fileobj(py::object fileobj, const std::string &format)
     // If the file is shorter than 256, then libsox cannot read the header.
     auto buf_size = (num_read > 256) ? num_read : 256;
 
-  SoxFormat sf(sox_open_mem_read(buf, buf_size,
+    SoxFormat sf(sox_open_mem_read(
+        buf,
+        buf_size,
         /*signal=*/nullptr,
         /*encoding=*/nullptr,
         /*filetype=*/format.empty() ? nullptr : format.data()));

paddlespeech/audio/src/pybind/sox/io.h

-//Copyright (c) 2017 Facebook Inc. (Soumith Chintala), 
-//All rights reserved.
+// Copyright (c) 2017 Facebook Inc. (Soumith Chintala),
+// All rights reserved.
 
 #ifndef PADDLEAUDIO_PYBIND_SOX_IO_H
 #define PADDLEAUDIO_PYBIND_SOX_IO_H

paddlespeech/audio/src/pybind/sox/utils.cpp

-//Copyright (c) 2017 Facebook Inc. (Soumith Chintala), 
-//All rights reserved.
+// Copyright (c) 2017 Facebook Inc. (Soumith Chintala),
+// All rights reserved.
 
 #include "paddlespeech/audio/src/pybind/sox/utils.h"
 
@@ -34,7 +34,8 @@ auto read_fileobj(py::object *fileobj, const uint64_t size, char *buffer)
         }
         if (chunk_len > request) {
             std::ostringstream message;
-      message << "Requested up to " << request << " bytes but, "
+            message
+                << "Requested up to " << request << " bytes but, "
                 << "received " << chunk_len << " bytes. "
                 << "The given object does not confirm to read protocol of file "
                    "object.";
@@ -51,8 +52,8 @@ int64_t get_buffer_size() { return sox_get_globals()->bufsiz; }
 
 void validate_input_file(const SoxFormat &sf, const std::string &path) {
     if (static_cast<sox_format_t *>(sf) == nullptr) {
-    throw std::runtime_error("Error loading audio file: failed to open file " +
-                             path);
+        throw std::runtime_error(
+            "Error loading audio file: failed to open file " + path);
     }
     if (sf->encoding.encoding == SOX_ENCODING_UNKNOWN) {
         throw std::runtime_error("Error loading audio file: unknown encoding.");

paddlespeech/audio/src/pybind/sox/utils.h

-//Copyright (c) 2017 Facebook Inc. (Soumith Chintala), 
-//All rights reserved.
+// Copyright (c) 2017 Facebook Inc. (Soumith Chintala),
+// All rights reserved.
 
 #ifndef PADDLEAUDIO_PYBIND_SOX_UTILS_H
 #define PADDLEAUDIO_PYBIND_SOX_UTILS_H
@@ -25,7 +25,7 @@ struct SoxFormat {
 
     void close();
 
-private:
+  private:
     sox_format_t *fd_;
 };
 

paddlespeech/audio/src/sox/io.cpp

@@ -11,8 +11,7 @@ namespace paddleaudio {
 namespace sox_io {
 
 tl::optional<MetaDataTuple> get_info_file(
-    const std::string& path,
-    const tl::optional<std::string>& format) {
+    const std::string& path, const tl::optional<std::string>& format) {
     SoxFormat sf(sox_open_read(
         path.c_str(),
         /*signal=*/nullptr,
@@ -73,8 +72,7 @@ tl::optional<std::tuple<torch::Tensor, int64_t>> load_audio_file(
         path, effects, normalize, channels_first, format);
 }
 
-void save_audio_file(
-    const std::string& path,
+void save_audio_file(const std::string& path,
                      torch::Tensor tensor,
                      int64_t sample_rate,
                      bool channels_first,
@@ -85,25 +83,23 @@ void save_audio_file(
     validate_input_tensor(tensor);
 
     const auto filetype = [&]() {
-    if (format.has_value())
-      return format.value();
+        if (format.has_value()) return format.value();
         return get_filetype(path);
     }();
 
     if (filetype == "amr-nb") {
         const auto num_channels = tensor.size(channels_first ? 0 : 1);
-    TORCH_CHECK(
-        num_channels == 1, "amr-nb format only supports single channel audio.");
+        TORCH_CHECK(num_channels == 1,
+                    "amr-nb format only supports single channel audio.");
     } else if (filetype == "htk") {
         const auto num_channels = tensor.size(channels_first ? 0 : 1);
-    TORCH_CHECK(
-        num_channels == 1, "htk format only supports single channel audio.");
+        TORCH_CHECK(num_channels == 1,
+                    "htk format only supports single channel audio.");
     } else if (filetype == "gsm") {
         const auto num_channels = tensor.size(channels_first ? 0 : 1);
-    TORCH_CHECK(
-        num_channels == 1, "gsm format only supports single channel audio.");
-    TORCH_CHECK(
-        sample_rate == 8000,
+        TORCH_CHECK(num_channels == 1,
+                    "gsm format only supports single channel audio.");
+        TORCH_CHECK(sample_rate == 8000,
                     "gsm format only supports a sampling rate of 8kHz.");
     }
     const auto signal_info =
@@ -111,8 +107,7 @@ void save_audio_file(
     const auto encoding_info = get_encodinginfo_for_save(
         filetype, tensor.dtype(), compression, encoding, bits_per_sample);
 
-  SoxFormat sf(sox_open_write(
-      path.c_str(),
+    SoxFormat sf(sox_open_write(path.c_str(),
                                 &signal_info,
                                 &encoding_info,
                                 /*filetype=*/filetype.c_str(),
@@ -134,11 +129,9 @@ void save_audio_file(
 
 TORCH_LIBRARY_FRAGMENT(paddleaudio, m) {
     m.def("paddleaudio::sox_io_get_info", &paddleaudio::sox_io::get_info_file);
-  m.def(
-      "paddleaudio::sox_io_load_audio_file",
+    m.def("paddleaudio::sox_io_load_audio_file",
           &paddleaudio::sox_io::load_audio_file);
-  m.def(
-      "paddleaudio::sox_io_save_audio_file",
+    m.def("paddleaudio::sox_io_save_audio_file",
           &paddleaudio::sox_io::save_audio_file);
 }
 

paddlespeech/audio/src/sox/io.h

 
-//Copyright (c) 2017 Facebook Inc. (Soumith Chintala), 
-//All rights reserved.
+// Copyright (c) 2017 Facebook Inc. (Soumith Chintala),
+// All rights reserved.
 
 #ifndef PADDLEAUDIO_SOX_IO_H
 #define PADDLEAUDIO_SOX_IO_H
@@ -11,8 +11,7 @@
 namespace paddleaudio {
 namespace sox_io {
 
-auto get_effects(
-    const tl::optional<int64_t>& frame_offset,
+auto get_effects(const tl::optional<int64_t>& frame_offset,
                  const tl::optional<int64_t>& num_frames)
     -> std::vector<std::vector<std::string>>;
 
@@ -20,8 +19,7 @@ using MetaDataTuple =
     std::tuple<int64_t, int64_t, int64_t, int64_t, std::string>;
 
 tl::optional<MetaDataTuple> get_info_file(
-    const std::string& path,
-    const tl::optional<std::string>& format);
+    const std::string& path, const tl::optional<std::string>& format);
 
 tl::optional<std::tuple<torch::Tensor, int64_t>> load_audio_file(
     const std::string& path,
@@ -31,8 +29,7 @@ tl::optional<std::tuple<torch::Tensor, int64_t>> load_audio_file(
     tl::optional<bool> channels_first,
     const tl::optional<std::string>& format);
 
-void save_audio_file(
-    const std::string& path,
+void save_audio_file(const std::string& path,
                      torch::Tensor tensor,
                      int64_t sample_rate,
                      bool channels_first,

setup.py

@@ -18,9 +18,9 @@ import os
 import subprocess as sp
 import sys
 from pathlib import Path
-from typing import Union
-from typing import Tuple
 from typing import List
+from typing import Tuple
+from typing import Union
 
 import distutils.command.clean
 from setuptools import Command
@@ -38,43 +38,13 @@ VERSION = '0.0.0'
 COMMITID = 'none'
 
 base = [
-    "editdistance",
-    "g2p_en", 
-    "g2pM", 
-    "h5py", 
-    "inflect", 
-    "jieba", 
-    "jsonlines",
-    "kaldiio", 
-    "librosa==0.8.1",
-    "loguru", 
-    "matplotlib", 
-    "nara_wpe",
-    "onnxruntime", 
-    "pandas", 
-    "paddlenlp", 
-    "paddlespeech_feat", 
-    "praatio==5.0.0",
-    "pypinyin", 
-    "pypinyin-dict", 
-    "python-dateutil", 
-    "pyworld", 
-    "resampy==0.2.2",
-    "sacrebleu", 
-    "scipy", 
-    "sentencepiece~=0.1.96", 
-    "soundfile~=0.10",
-    "textgrid", 
-    "timer", 
-    "tqdm", 
-    "typeguard", 
-    "visualdl", 
-    "webrtcvad",
-    "yacs~=0.1.8", 
-    "prettytable", 
-    "zhon", 
-    'colorlog', 
-    'pathos == 0.2.8'
+    "editdistance", "g2p_en", "g2pM", "h5py", "inflect", "jieba", "jsonlines",
+    "kaldiio", "librosa==0.8.1", "loguru", "matplotlib", "nara_wpe",
+    "onnxruntime", "pandas", "paddlenlp", "paddlespeech_feat", "praatio==5.0.0",
+    "pypinyin", "pypinyin-dict", "python-dateutil", "pyworld", "resampy==0.2.2",
+    "sacrebleu", "scipy", "sentencepiece~=0.1.96", "soundfile~=0.10",
+    "textgrid", "timer", "tqdm", "typeguard", "visualdl", "webrtcvad",
+    "yacs~=0.1.8", "prettytable", "zhon", 'colorlog', 'pathos == 0.2.8'
 ]
 
 server = [
@@ -264,6 +234,7 @@ class clean(distutils.command.clean.clean):
                 print(f"removing '{path}' (and everything under it)")
                 shutil.rmtree(str(path), ignore_errors=True)
 
+
 def main():
     sha = check_output(["git", "rev-parse", "HEAD"])  # commit id
     branch = check_output(["git", "rev-parse", "--abbrev-ref", "HEAD"])
@@ -319,7 +290,8 @@ def main():
             requirements["develop"],
             'doc': [
                 "sphinx", "sphinx-rtd-theme", "numpydoc", "myst_parser",
-                "recommonmark>=0.5.0", "sphinx-markdown-tables", "sphinx-autobuild"
+                "recommonmark>=0.5.0", "sphinx-markdown-tables",
+                "sphinx-autobuild"
             ],
             'test': ['nose', 'torchaudio==0.10.2'],
         },
@@ -358,5 +330,6 @@ def main():
 
     setup(**setup_info)
 
+
 if __name__ == '__main__':
     main()

speechx/examples/ds2_ol/onnx/local/onnx_infer_shape.py

@@ -494,6 +494,11 @@ class SymbolicShapeInference:
             # contrib ops
 
 
+
+
+
+
+
             'Attention', 'BiasGelu', \
             'EmbedLayerNormalization', \
             'FastGelu', 'Gelu', 'LayerNormalization', \

tools/setup_helpers/extension.py

-import distutils.sysconfig
 import os
 import platform
 import subprocess
 from pathlib import Path
 
+import distutils.sysconfig
 from setuptools import Extension
 from setuptools.command.build_ext import build_ext
 
@@ -27,11 +27,13 @@ def _get_build(var, default=False):
     if val in trues:
         return True
     if val not in falses:
-        print(f"WARNING: Unexpected environment variable value `{var}={val}`. " f"Expected one of {trues + falses}")
+        print(f"WARNING: Unexpected environment variable value `{var}={val}`. "
+              f"Expected one of {trues + falses}")
     return False
 
 
-_BUILD_SOX = False if platform.system() == "Windows" else _get_build("BUILD_SOX", True)
+_BUILD_SOX = False if platform.system() == "Windows" else _get_build(
+    "BUILD_SOX", True)
 _BUILD_MAD = _get_build("BUILD_MAD", False)
 # _BUILD_KALDI = False if platform.system() == "Windows" else _get_build("BUILD_KALDI", True)
 # _BUILD_RNNT = _get_build("BUILD_RNNT", True)
@@ -40,7 +42,8 @@ _BUILD_MAD = _get_build("BUILD_MAD", False)
 # _USE_ROCM = _get_build("USE_ROCM", torch.cuda.is_available() and torch.version.hip is not None)
 # _USE_CUDA = _get_build("USE_CUDA", torch.cuda.is_available() and torch.version.hip is None)
 # _USE_OPENMP = _get_build("USE_OPENMP", True) and "ATen parallel backend: OpenMP" in torch.__config__.parallel_info()
-_PADDLESPEECH_CUDA_ARCH_LIST = os.environ.get("PADDLESPEECH_CUDA_ARCH_LIST", None)
+_PADDLESPEECH_CUDA_ARCH_LIST = os.environ.get("PADDLESPEECH_CUDA_ARCH_LIST",
+                                              None)
 
 
 def get_ext_modules():
@@ -71,7 +74,8 @@ class CMakeBuild(build_ext):
         if ext.name != "paddlespeech.audio._paddleaudio":
             return
 
-        extdir = os.path.abspath(os.path.dirname(self.get_ext_filename(ext.name)))
+        extdir = os.path.abspath(
+            os.path.dirname(self.get_ext_filename(ext.name)))
 
         # required for auto-detection of auxiliary "native" libs
         if not extdir.endswith(os.path.sep):
@@ -101,8 +105,12 @@ class CMakeBuild(build_ext):
         if _PADDLESPEECH_CUDA_ARCH_LIST is not None:
             # Convert MAJOR.MINOR[+PTX] list to new style one
             # defined at https://cmake.org/cmake/help/latest/prop_tgt/CUDA_ARCHITECTURES.html
-            _arches = _PADDLESPEECH_CUDA_ARCH_LIST.replace(".", "").replace(" ", ";").split(";")
-            _arches = [arch[:-4] if arch.endswith("+PTX") else f"{arch}-real" for arch in _arches]
+            _arches = _PADDLESPEECH_CUDA_ARCH_LIST.replace(".", "").replace(
+                " ", ";").split(";")
+            _arches = [
+                arch[:-4] if arch.endswith("+PTX") else f"{arch}-real"
+                for arch in _arches
+            ]
             cmake_args += [f"-DCMAKE_CUDA_ARCHITECTURES={';'.join(_arches)}"]
 
         # Default to Ninja
@@ -131,10 +139,13 @@ class CMakeBuild(build_ext):
         if not os.path.exists(self.build_temp):
             os.makedirs(self.build_temp)
 
-        print(f"cmake {_ROOT_DIR} {' '.join(cmake_args)}, cwd={self.build_temp}")
-        subprocess.check_call(["cmake", str(_ROOT_DIR)] + cmake_args, cwd=self.build_temp)
+        print(
+            f"cmake {_ROOT_DIR} {' '.join(cmake_args)}, cwd={self.build_temp}")
+        subprocess.check_call(
+            ["cmake", str(_ROOT_DIR)] + cmake_args, cwd=self.build_temp)
         print(f"cmake --build . {' '.join(build_args)}, cwd={self.build_temp}")
-        subprocess.check_call(["cmake", "--build", "."] + build_args, cwd=self.build_temp)
+        subprocess.check_call(
+            ["cmake", "--build", "."] + build_args, cwd=self.build_temp)
 
     def get_ext_filename(self, fullname):
         ext_filename = super().get_ext_filename(fullname)