kapitan 0.35.2.dev20__tar.gz → 0.35.2.dev21__tar.gz

{kapitan-0.35.2.dev20 → kapitan-0.35.2.dev21}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kapitan
-Version: 0.35.2.dev20
+Version: 0.35.2.dev21
 Summary: Generic templated configuration management for Kubernetes, Terraform and other things
 Project-URL: Homepage, https://kapitan.dev
 Project-URL: Repository, https://github.com/kapicorp/kapitan

{kapitan-0.35.2.dev20 → kapitan-0.35.2.dev21}/kapitan/cli.py

@@ -91,7 +91,8 @@ def trigger_compile(args):
             ref_controller=ref_controller,
             args=args,
         )
-    except:
+    except Exception as e:
+        logger.debug("Compile failed: %s", e, exc_info=True)
         sys.exit(1)
 
 

{kapitan-0.35.2.dev20 → kapitan-0.35.2.dev21}/kapitan/dependency_manager/base.py

@@ -193,7 +193,7 @@ def fetch_git_source(source, save_dir, item_type):
         logger.error(e)
         raise GitFetchingError(
             f"{item_type} {source}: fetching unsuccessful\n{e.stderr}"
-        )
+        ) from e
 
 
 def fetch_http_dependency(dep_mapping, save_dir, force, item_type="Dependency"):

{kapitan-0.35.2.dev20 → kapitan-0.35.2.dev21}/kapitan/inputs/copy.py

@@ -34,6 +34,10 @@ class Copy(InputType):
 
         ignore_missing = config.ignore_missing
 
+        if not os.path.exists(input_path) and not ignore_missing:
+            raise OSError(
+                f"Path {input_path} does not exist and `ignore_missing` is {ignore_missing}"
+            )
         try:
             if os.path.exists(input_path):
                 logger.debug("Copying '%s' to '%s'.", input_path, compile_path)
@@ -55,11 +59,7 @@ class Copy(InputType):
                         compile_path
                     )  # Resolve relative paths
                     copy_tree(input_path, compile_path)
-            elif not ignore_missing:
-                # Raise exception if input path does not exist and ignore_missing is False
-                raise OSError(
-                    f"Path {input_path} does not exist and `ignore_missing` is {ignore_missing}"
-                )
         except OSError as e:
             # Log exception and re-raise
             logger.exception("Input dir not copied. Error: %s", e)
+            raise

{kapitan-0.35.2.dev20 → kapitan-0.35.2.dev21}/kapitan/inputs/jsonnet.py

@@ -37,18 +37,15 @@ def select_jsonnet_runtime(use_go):
     """
     try:
         if use_go:
-            import _gojsonnet
-
-            return _gojsonnet
-        import _jsonnet
-
-        return _jsonnet
-
+            import _gojsonnet as jsonnet_module
+        else:
+            import _jsonnet as jsonnet_module
     except ImportError as exc:
         raise ImportError(
             "Jsonnet is not installed or running on an unsupported architecture. "
             "See https://kapitan.dev/compile/#jsonnet for installation instructions."
         ) from exc
+    return jsonnet_module
 
 
 class Jsonnet(InputType):

{kapitan-0.35.2.dev20 → kapitan-0.35.2.dev21}/kapitan/inputs/kadet.py

@@ -97,9 +97,10 @@ def load_from_search_paths(module_name):
             _path = os.path.join(path, module_name)
             mod, spec = module_from_path(_path, check_name=module_name)
             spec.loader.exec_module(mod)
-            return mod
         except (ModuleNotFoundError, FileNotFoundError):
             pass
+        else:
+            return mod
     raise ModuleNotFoundError(f"Could not load module name {module_name}")
 
 

{kapitan-0.35.2.dev20 → kapitan-0.35.2.dev21}/kapitan/inputs/kustomize.py

@@ -84,18 +84,20 @@ class Kustomize(InputType):
         Raises:
             KustomizeTemplateError: If kustomize build fails
         """
+
+        # Get the absolute path to the input directory
+        abs_input_path = os.path.abspath(input_path)
+        if not os.path.isdir(abs_input_path):
+            raise KustomizeTemplateError(
+                f"Input path {input_path} must be a directory containing a kustomization.yaml file"
+            )
+
+        result = None
         try:
             # Create a temporary directory for our kustomization
             temp_dir = tempfile.mkdtemp()
             kustomization_path = os.path.join(temp_dir, "kustomization.yaml")
 
-            # Get the absolute path to the input directory
-            abs_input_path = os.path.abspath(input_path)
-            if not os.path.isdir(abs_input_path):
-                raise KustomizeTemplateError(
-                    f"Input path {input_path} must be a directory containing a kustomization.yaml file"
-                )
-
             # Copy the input directory to the temporary directory
             input_dir_name = os.path.basename(abs_input_path)
             temp_input_dir = os.path.join(temp_dir, input_dir_name)
@@ -147,11 +149,15 @@ class Kustomize(InputType):
                 result = subprocess.run(
                     cmd, stdout=f, stderr=subprocess.PIPE, text=True, check=False
                 )
-                if result.returncode != 0:
-                    raise KustomizeTemplateError(
-                        f"Kustomize build failed: {result.stderr}"
-                    )
+        except Exception as e:
+            raise KustomizeTemplateError(
+                f"Failed to compile Kustomize overlay: {e!s}"
+            ) from e
+
+        if result.returncode != 0:
+            raise KustomizeTemplateError(f"Kustomize build failed: {result.stderr}")
 
+        try:
             # Read and process the output
             with open(output_file) as f:
                 for doc in yaml.safe_load_all(f):
@@ -167,6 +173,7 @@ class Kustomize(InputType):
                         output_path = os.path.join(compile_path, filename)
                         with open(output_path, "w") as out:
                             yaml.dump(doc, out, default_flow_style=False)
-
         except Exception as e:
-            raise KustomizeTemplateError(f"Failed to compile Kustomize overlay: {e!s}")
+            raise KustomizeTemplateError(
+                f"Failed to compile Kustomize overlay: {e!s}"
+            ) from e

{kapitan-0.35.2.dev20 → kapitan-0.35.2.dev21}/kapitan/inventory/backends/omegaconf/resolvers.py

@@ -315,5 +315,5 @@ def register_user_resolvers(user_resolver_file: str) -> None:
     for name, func in funcs.items():
         try:
             OmegaConf.register_new_resolver(name, func, replace=True)
-        except:
-            logger.warning(f"Could not load resolver {name}")
+        except Exception as e:
+            logger.warning(f"Could not load resolver {name}: {e}")

{kapitan-0.35.2.dev20 → kapitan-0.35.2.dev21}/kapitan/inventory/backends/reclass/__init__.py

@@ -1,6 +1,6 @@
 import logging
 import os
-from datetime import datetime
+from datetime import datetime, timezone
 
 import yaml
 
@@ -46,9 +46,9 @@ class ReclassInventory(Inventory):
             _reclass = reclass.core.Core(
                 storage, class_mappings, reclass.settings.Settings(reclass_config)
             )
-            start = datetime.now()
+            start = datetime.now(timezone.utc)
             rendered_inventory = _reclass.inventory()
-            elapsed = datetime.now() - start
+            elapsed = datetime.now(timezone.utc) - start
             logger.debug(f"Inventory rendering with reclass took {elapsed}")
 
             # store parameters and classes
@@ -63,7 +63,7 @@ class ReclassInventory(Inventory):
                 logger.error("Inventory reclass error: inventory not found")
             else:
                 logger.error(f"Inventory reclass error: {e.message}")
-            raise InventoryError(e.message)
+            raise InventoryError(e.message) from e
 
 
 def get_reclass_config(

{kapitan-0.35.2.dev20 → kapitan-0.35.2.dev21}/kapitan/inventory/backends/reclass_rs/__init__.py

@@ -1,5 +1,5 @@
 import logging
-from datetime import datetime
+from datetime import datetime, timezone
 
 import reclass_rs
 from kapitan.errors import InventoryError
@@ -30,9 +30,9 @@ class ReclassRsInventory(Inventory):
     ):
         try:
             r = self._make_reclass_rs(ignore_class_not_found)
-            start = datetime.now()
+            start = datetime.now(timezone.utc)
             inv = r.inventory()
-            elapsed = datetime.now() - start
+            elapsed = datetime.now(timezone.utc) - start
             logger.debug(f"Inventory rendering with reclass-rs took {elapsed}")
 
             for target_name, nodeinfo in inv.nodes.items():
@@ -43,4 +43,4 @@ class ReclassRsInventory(Inventory):
 
         except ValueError as e:
             logger.error(f"Reclass-rs error: {e}")
-            raise InventoryError(f"{e}")
+            raise InventoryError(f"{e}") from e

{kapitan-0.35.2.dev20 → kapitan-0.35.2.dev21}/kapitan/jinja2_filters.py

@@ -75,8 +75,9 @@ def load_module_from_path(env, path):
                 logger.debug("custom filter loaded from %s", path)
                 env.filters[function] = getattr(custom_filter_module, function)
     except Exception as e:
-        raise OSError(f"jinja2 failed to render, could not load filter at {path}: {e}")
-        logger.debug("failed to find custom filter from path %s", path)
+        raise OSError(
+            f"jinja2 failed to render, could not load filter at {path}: {e}"
+        ) from e
 
 
 def load_jinja2_filters_from_file(env, jinja2_filters):
@@ -132,8 +133,11 @@ def to_bool(a):
     return False
 
 
-def to_datetime(string, format="%Y-%m-%d %H:%M:%S"):
-    return datetime.datetime.strptime(string, format)
+def to_datetime(string, format="%Y-%m-%d %H:%M:%S", tz=None):
+    dt = datetime.datetime.strptime(string, format)  # noqa: DTZ007 - naive by default; pass tz= for timezone-aware output
+    if tz is not None:
+        dt = dt.replace(tzinfo=tz)
+    return dt
 
 
 def strftime(string_format, second=None):
@@ -141,8 +145,8 @@ def strftime(string_format, second=None):
     if second is not None:
         try:
             second = int(second)
-        except Exception:
-            raise CompileError(f"Invalid value for epoch value ({second})")
+        except (ValueError, TypeError) as e:
+            raise CompileError(f"Invalid value for epoch value ({second})") from e
     return time.strftime(string_format, time.localtime(second))
 
 

{kapitan-0.35.2.dev20 → kapitan-0.35.2.dev21}/kapitan/refs/base.py

@@ -99,7 +99,7 @@ class PlainRef:
             except KeyError:
                 raise RefError(
                     f"PlainRef: cannot access sub-variable key {self.embedded_subvar_path}"
-                )
+                ) from None
         else:
             return self.data
 
@@ -195,9 +195,10 @@ class PlainRefBackend:
     def __contains__(self, ref_path):
         try:
             self.__getitem__(ref_path)
-            return True
         except KeyError:
             return False
+        else:
+            return True
 
     def __iter__(self):
         for full_path in list_all_paths(self.path):
@@ -320,7 +321,7 @@ class Revealer:
                 except KeyError:
                     raise RefError(
                         f"Revealer: cannot access {tag} sub-variable key {ref.embedded_subvar_path}"
-                    )
+                    ) from None
 
             # else this is just a ref
             else:
@@ -359,7 +360,7 @@ class Revealer:
             except KeyError:
                 raise RefError(
                     f"Revealer: cannot access {tag} sub-variable key {subvar_path}"
-                )
+                ) from None
 
     @lru_cache(maxsize=256)
     def _reveal_tag_without_subvar(self, tag_without_subvar):
@@ -395,7 +396,7 @@ class Revealer:
                 return ref.compile()
             # if refs don't exist:
             except KeyError:
-                raise RefError(f"Could not find ref backend for tag: {tag}")
+                raise RefError(f"Could not find ref backend for tag: {tag}") from None
 
         return compile_replace_match
 
@@ -601,7 +602,7 @@ class RefController:
         try:
             yield
         except RefBackendError as e:
-            raise RefBackendError(f"{e}\n  for key {ref_key}")
+            raise RefBackendError(f"{e}\n  for key {ref_key}") from e
 
     def __init__(self, path, **kwargs):
         """
@@ -664,7 +665,7 @@ class RefController:
 
                 self.register_backend(AzureKMSBackend(self.path, **ref_kwargs))
             else:
-                raise RefBackendError(f"no backend for ref type: {type_name}")
+                raise RefBackendError(f"no backend for ref type: {type_name}") from None
         return self.backends[type_name]
 
     def tag_type(self, tag):
@@ -810,11 +811,11 @@ class RefController:
                 except KeyError:
                     raise RefError(
                         f"{func_name}: unknown ref function used. Choose one of: {[key for key in get_func_lookup()]}"
-                    )
-                except TypeError:
+                    ) from None
+                except TypeError as e:
                     raise RefError(
                         f"{func_params}: too many arguments for function {func_name}"
-                    )
+                    ) from e
 
         return ctx
 
@@ -844,7 +845,7 @@ class RefController:
                     # raise RefFromFuncError to indicate new ref needs to be created
                     raise RefFromFuncError(
                         f"{token}: does not exist and must be created from function: {func_str}"
-                    )
+                    ) from None
 
         raise KeyError(f"{tag}: ref not found")
 

{kapitan-0.35.2.dev20 → kapitan-0.35.2.dev21}/kapitan/refs/base64.py

@@ -45,7 +45,7 @@ class Base64Ref(PlainRef):
         decoded = base64.b64decode(self.data)
         try:
             return decoded.decode()
-        except:
+        except UnicodeDecodeError:
             return self.data
 
     def compile_embedded(self):

{kapitan-0.35.2.dev20 → kapitan-0.35.2.dev21}/kapitan/refs/cmd_parser.py

@@ -63,7 +63,7 @@ def ref_write(args, ref_controller):
             except UnicodeDecodeError as e:
                 raise KapitanError(
                     f"Could not read file. Please add '--binary' if the file contains binary data. ({e})"
-                )
+                ) from e
 
     # Empty configuration object
     reference_backend_configs = KapitanReferenceConfig()
@@ -75,19 +75,19 @@ def ref_write(args, ref_controller):
             reference_backend_configs = inv.get_parameters(
                 args.target_name
             ).kapitan.secrets
-        except (KeyError, AttributeError):
+        except (KeyError, AttributeError) as e:
             raise KapitanError(
                 f"parameters.kapitan.secrets not defined in {args.target_name}"
-            )
+            ) from e
 
     type_name, token_path = token_name.split(":")
 
     try:
         type_name = KapitanReferencesTypes(type_name)
-    except ValueError:
+    except ValueError as e:
         raise KapitanError(
             f"Invalid token type: {type_name}. Try using gpg/gkms/awskms/azkms/vaultkv/vaulttransit/base64/plain/env"
-        )
+        ) from e
 
     tag = f"?{{{type_name}:{token_path}}}"
 
@@ -361,8 +361,8 @@ def ref_reveal(args, ref_controller):
         elif tag_name:
             out = revealer.reveal_raw_string(tag_name)
             sys.stdout.write(out)
-    except (RefHashMismatchError, KeyError):
-        raise KapitanError(f"Reveal failed for file {file_name}")
+    except (RefHashMismatchError, KeyError) as e:
+        raise KapitanError(f"Reveal failed for file {file_name}") from e
 
 
 def secret_update_validate(args, ref_controller):

{kapitan-0.35.2.dev20 → kapitan-0.35.2.dev21}/kapitan/refs/functions.py

@@ -235,10 +235,10 @@ def random(ctx, type="str", nchars="", special_chars=string.punctuation):
         # check input for nchars
         try:
             nchars = int(nchars)
-        except ValueError:
+        except ValueError as e:
             raise RefError(
                 f"Ref error: eval_func: {nchars} cannot be converted into integer."
-            )
+            ) from e
 
     # check if any special characters are specified without using type special
     if type != "special" and special_chars != string.punctuation:

{kapitan-0.35.2.dev20 → kapitan-0.35.2.dev21}/kapitan/refs/secrets/awskms.py

@@ -61,7 +61,9 @@ class AWSKMSSecret(Base64Ref):
             key = target_inv.kapitan.secrets.awskms.key
             return cls(data, key, **ref_params.kwargs)
         except KeyError:
-            raise RefError("Could not create AWSKMSSecret: target_name missing")
+            raise RefError(
+                "Could not create AWSKMSSecret: target_name missing"
+            ) from None
 
     @classmethod
     def from_path(cls, ref_full_path, **kwargs):
@@ -118,7 +120,7 @@ class AWSKMSSecret(Base64Ref):
             self.key = key
 
         except Exception as e:
-            raise AWSKMSError(e)
+            raise AWSKMSError(str(e)) from e
 
     def _decrypt(self, data):
         """decrypt data"""
@@ -134,7 +136,7 @@ class AWSKMSSecret(Base64Ref):
             return plaintext.decode()
 
         except Exception as e:
-            raise AWSKMSError(e)
+            raise AWSKMSError(str(e)) from e
 
     def dump(self):
         """

{kapitan-0.35.2.dev20 → kapitan-0.35.2.dev21}/kapitan/refs/secrets/azkms.py

@@ -85,7 +85,9 @@ class AzureKMSSecret(Base64Ref):
             key = target_inv.kapitan.secrets.azkms.key
             return cls(data, key, **ref_params.kwargs)
         except KeyError:
-            raise RefError("Could not create AzureKMSSecret: target_name missing")
+            raise RefError(
+                "Could not create AzureKMSSecret: target_name missing"
+            ) from None
 
     @classmethod
     def from_path(cls, ref_full_path, **kwargs):
@@ -145,7 +147,7 @@ class AzureKMSSecret(Base64Ref):
             self.key = key
 
         except Exception as e:
-            raise AzureKMSError(e)
+            raise AzureKMSError(str(e)) from e
 
     def _decrypt(self, data, key):
         """decrypt data"""
@@ -161,7 +163,7 @@ class AzureKMSSecret(Base64Ref):
             return plaintext.decode()
 
         except Exception as e:
-            raise AzureKMSError(e)
+            raise AzureKMSError(str(e)) from e
 
     def dump(self):
         """

{kapitan-0.35.2.dev20 → kapitan-0.35.2.dev21}/kapitan/refs/secrets/gkms.py

@@ -73,7 +73,9 @@ class GoogleKMSSecret(Base64Ref):
             key = target_inv.kapitan.secrets.gkms.key
             return cls(data, key, **ref_params.kwargs)
         except KeyError:
-            raise RefError("Could not create GoogleKMSSecret: target_name missing")
+            raise RefError(
+                "Could not create GoogleKMSSecret: target_name missing"
+            ) from None
 
     @classmethod
     def from_path(cls, ref_full_path, **kwargs):
@@ -135,7 +137,7 @@ class GoogleKMSSecret(Base64Ref):
             self.key = key
 
         except Exception as e:
-            raise GoogleKMSError(e)
+            raise GoogleKMSError(str(e)) from e
 
     def _decrypt(self, data):
         """decrypt data"""
@@ -155,7 +157,7 @@ class GoogleKMSSecret(Base64Ref):
             return plaintext.decode()
 
         except Exception as e:
-            raise GoogleKMSError(e)
+            raise GoogleKMSError(str(e)) from e
 
     def dump(self):
         """

{kapitan-0.35.2.dev20 → kapitan-0.35.2.dev21}/kapitan/refs/secrets/gpg.py

@@ -91,7 +91,7 @@ class GPGSecret(Base64Ref):
 
             return cls(data, recipients, **ref_params.kwargs)
         except KeyError:
-            raise RefError("Could not create GPGSecret: target_name missing")
+            raise RefError("Could not create GPGSecret: target_name missing") from None
 
     @classmethod
     def from_path(cls, ref_full_path, **kwargs):

{kapitan-0.35.2.dev20 → kapitan-0.35.2.dev21}/kapitan/refs/secrets/vaultkv.py

@@ -85,7 +85,7 @@ class VaultSecret(Base64Ref):
             except KeyError:
                 raise RefError(
                     "Could not create VaultSecret: vaultkv parameters missing"
-                )
+                ) from None
 
         # set mount, path and key as ref params, read from token
         token = ref_params.kwargs.get("token")
@@ -173,11 +173,11 @@ class VaultSecret(Base64Ref):
                 path=self.path, secret=secrets, mount_point=self.mount
             )
             client.adapter.close()
-        except Forbidden:
+        except Forbidden as e:
             raise VaultError(
                 "Permission Denied. "
                 f"make sure the token is authorised to access '{self.path}' on Vault"
-            )
+            ) from e
 
         # set the data to path:key
         data = f"{self.path}:{self.key}".encode()
@@ -226,15 +226,15 @@ class VaultSecret(Base64Ref):
                 )
                 return_data = response["data"]["data"][secret_key]
             client.adapter.close()
-        except Forbidden:
+        except Forbidden as e:
             raise VaultError(
                 "Permission Denied. "
                 f"make sure the token is authorised to access '{secret_path}' on Vault"
-            )
-        except InvalidPath:
-            raise VaultError(f"path '{secret_path}' does not exist on Vault")
-        except KeyError:
-            raise VaultError(f"key '{secret_key}' does not exist on Vault")
+            ) from e
+        except InvalidPath as e:
+            raise VaultError(f"path '{secret_path}' does not exist on Vault") from e
+        except KeyError as e:
+            raise VaultError(f"key '{secret_key}' does not exist on Vault") from e
         finally:
             client.adapter.close()
 

{kapitan-0.35.2.dev20 → kapitan-0.35.2.dev21}/kapitan/refs/secrets/vaulttransit.py

@@ -70,7 +70,7 @@ class VaultTransit(Base64Ref):
         except KeyError:
             raise RefError(
                 "Could not create VaultSecret: vaulttransit parameters missing"
-            )
+            ) from None
 
     @classmethod
     def from_path(cls, ref_full_path, **kwargs):
@@ -139,13 +139,13 @@ class VaultTransit(Base64Ref):
 
             self.data = ciphertext.encode()
             self.vault_params.crypto_key = key
-        except Forbidden:
+        except Forbidden as e:
             raise VaultError(
                 "Permission Denied. "
                 f"make sure the token is authorised to access {data[0]} on Vault"
-            )
-        except InvalidPath:
-            raise VaultError(f"{data[0]} does not exist on Vault secret")
+            ) from e
+        except InvalidPath as e:
+            raise VaultError(f"{data[0]} does not exist on Vault secret") from e
         finally:
             client.adapter.close()
 
@@ -178,13 +178,13 @@ class VaultTransit(Base64Ref):
             plaintext = base64.b64decode(response["data"]["plaintext"])
 
             return plaintext.decode()
-        except Forbidden:
+        except Forbidden as e:
             raise VaultError(
                 "Permission Denied. "
                 f"make sure the token is authorised to access {data[0]} on Vault"
-            )
-        except InvalidPath:
-            raise VaultError(f"{data[0]} does not exist on Vault secret")
+            ) from e
+        except InvalidPath as e:
+            raise VaultError(f"{data[0]} does not exist on Vault secret") from e
         finally:
             client.adapter.close()
 

{kapitan-0.35.2.dev20 → kapitan-0.35.2.dev21}/kapitan/refs/vault_resources.py

@@ -53,8 +53,8 @@ class VaultClient(hvac.Client):
         try:
             with open(token_file) as fp:
                 token = fp.read()
-        except OSError:
-            raise VaultError(f"Cannot read file {token_file}")
+        except OSError as e:
+            raise VaultError(f"Cannot read file {token_file}") from e
 
         if not token:
             raise VaultError(f"{token_file} is empty")

{kapitan-0.35.2.dev20 → kapitan-0.35.2.dev21}/kapitan/resources.py

@@ -83,9 +83,10 @@ def jsonschema_validate(obj, schema_obj):
         jsonschema.validate(
             _obj, _schema_obj, format_checker=jsonschema.FormatChecker()
         )
-        return {"valid": True, "reason": ""}
     except jsonschema.ValidationError as e:
         return {"valid": False, "reason": "" + str(e)}
+    else:
+        return {"valid": True, "reason": ""}
 
 
 def yaml_dump(obj):
@@ -128,7 +129,9 @@ def jinja2_render_file(search_paths, name, ctx):
             try:
                 return render_jinja2_file(_full_path, ctx, search_paths=search_paths)
             except Exception as e:
-                raise CompileError(f"Jsonnet jinja2 failed to render {_full_path}: {e}")
+                raise CompileError(
+                    f"Jsonnet jinja2 failed to render {_full_path}: {e}"
+                ) from e
 
     raise OSError(f"jinja2 failed to render, could not find file: {_full_path}")
 
@@ -144,7 +147,9 @@ def yaml_load(search_paths, name):
                 with open(_full_path) as f:
                     return json.dumps(yaml.safe_load(f.read()))
             except Exception as e:
-                raise CompileError(f"Parse yaml failed to parse {_full_path}: {e}")
+                raise CompileError(
+                    f"Parse yaml failed to parse {_full_path}: {e}"
+                ) from e
 
     raise OSError(f"could not find any input yaml file: {_full_path}")
 
@@ -161,7 +166,9 @@ def yaml_load_stream(search_paths, name):
                     _obj = yaml.load_all(f.read(), Loader=yaml.SafeLoader)
                     return json.dumps(list(_obj))
             except Exception as e:
-                raise CompileError(f"Parse yaml failed to parse {_full_path}: {e}")
+                raise CompileError(
+                    f"Parse yaml failed to parse {_full_path}: {e}"
+                ) from e
 
     raise OSError(f"could not find any input yaml file: {_full_path}")