appier 1.31.4__py2.py3-none-any.whl → 1.32.0__py2.py3-none-any.whl

appier/git.py

@@ -2,7 +2,7 @@
 # -*- coding: utf-8 -*-
 
 # Hive Appier Framework
-# Copyright (c) 2008-2022 Hive Solutions Lda.
+# Copyright (c) 2008-2024 Hive Solutions Lda.
 #
 # This file is part of Hive Appier Framework.
 #
@@ -22,16 +22,7 @@
 __author__ = "João Magalhães <joamag@hive.pt>"
 """ The author(s) of the module """
 
-__version__ = "1.0.0"
-""" The version of the module """
-
-__revision__ = "$LastChangedRevision$"
-""" The revision number of the module """
-
-__date__ = "$LastChangedDate$"
-""" The last change date of the module """
-
-__copyright__ = "Copyright (c) 2008-2022 Hive Solutions Lda."
+__copyright__ = "Copyright (c) 2008-2024 Hive Solutions Lda."
 """ The copyright for the module """
 
 __license__ = "Apache License, Version 2.0"
@@ -42,214 +33,234 @@ from . import common
 from . import legacy
 from . import exceptions
 
-class Git(object):
 
+class Git(object):
     @classmethod
-    def is_git(cls, path = None):
+    def is_git(cls, path=None):
         path = path or common.base().get_base_path()
-        try: result = util.execute(["git", "status"], path = path)
-        except OSError: return False
+        try:
+            result = util.execute(["git", "status"], path=path)
+        except OSError:
+            return False
         code = result["code"]
         return code == 0
 
     @classmethod
-    def clone(cls, url, path = None, raise_e = True):
+    def clone(cls, url, path=None, raise_e=True):
         path = path or common.base().get_base_path()
-        result = util.execute(["git", "clone", url], path = path)
-        if cls._wrap_error(result, raise_e = raise_e): return None
+        result = util.execute(["git", "clone", url], path=path)
+        if cls._wrap_error(result, raise_e=raise_e):
+            return None
         message = result.get("stdout", "")
         return message
 
     @classmethod
-    def fetch(cls, flags = [], path = None, raise_e = True):
+    def fetch(cls, flags=[], path=None, raise_e=True):
         path = path or common.base().get_base_path()
-        result = util.execute(["git", "fetch"] + flags, path = path)
-        if cls._wrap_error(result, raise_e = raise_e): return None
+        result = util.execute(["git", "fetch"] + flags, path=path)
+        if cls._wrap_error(result, raise_e=raise_e):
+            return None
         message = result.get("stdout", "")
         return message
 
     @classmethod
-    def pull(cls, flags = [], path = None, raise_e = True):
+    def pull(cls, flags=[], path=None, raise_e=True):
         path = path or common.base().get_base_path()
-        result = util.execute(["git", "pull"] + flags, path = path)
-        if cls._wrap_error(result, raise_e = raise_e): return None
+        result = util.execute(["git", "pull"] + flags, path=path)
+        if cls._wrap_error(result, raise_e=raise_e):
+            return None
         message = result.get("stdout", "")
         return message
 
     @classmethod
-    def push(cls, flags = [], path = None, raise_e = True):
+    def push(cls, flags=[], path=None, raise_e=True):
         path = path or common.base().get_base_path()
-        result = util.execute(["git", "push"] + flags, path = path)
-        if cls._wrap_error(result, raise_e = raise_e): return None
+        result = util.execute(["git", "push"] + flags, path=path)
+        if cls._wrap_error(result, raise_e=raise_e):
+            return None
         message = result.get("stdout", "")
         return message
 
     @classmethod
-    def commit(cls, message = "Update", flags = [], path = None, raise_e = True):
+    def commit(cls, message="Update", flags=[], path=None, raise_e=True):
         path = path or common.base().get_base_path()
-        result = util.execute(["git", "commit", "-m", message] + flags, path = path)
-        if cls._wrap_error(result, raise_e = raise_e): return None
+        result = util.execute(["git", "commit", "-m", message] + flags, path=path)
+        if cls._wrap_error(result, raise_e=raise_e):
+            return None
         message = result.get("stdout", "")
         return message
 
     @classmethod
-    def checkout(cls, branch = "master", flags = [], path = None, raise_e = True):
+    def checkout(cls, branch="master", flags=[], path=None, raise_e=True):
         path = path or common.base().get_base_path()
-        result = util.execute(["git", "checkout", branch] + flags, path = path)
-        if cls._wrap_error(result, raise_e = raise_e): return None
+        result = util.execute(["git", "checkout", branch] + flags, path=path)
+        if cls._wrap_error(result, raise_e=raise_e):
+            return None
         message = result.get("stdout", "")
         return message
 
     @classmethod
-    def add(cls, target = "*", flags = [], path = None, raise_e = True):
+    def add(cls, target="*", flags=[], path=None, raise_e=True):
         path = path or common.base().get_base_path()
-        result = util.execute(["git", "add", target] + flags, path = path)
-        if cls._wrap_error(result, raise_e = raise_e): return None
+        result = util.execute(["git", "add", target] + flags, path=path)
+        if cls._wrap_error(result, raise_e=raise_e):
+            return None
         message = result.get("stdout", "")
         return message
 
     @classmethod
-    def add_upstream(cls, url, name = "upstream", path = None, raise_e = True):
+    def add_upstream(cls, url, name="upstream", path=None, raise_e=True):
         path = path or common.base().get_base_path()
-        result = util.execute(["git", "remote", "add", name, url], path = path)
-        if cls._wrap_error(result, raise_e = raise_e): return None
+        result = util.execute(["git", "remote", "add", name, url], path=path)
+        if cls._wrap_error(result, raise_e=raise_e):
+            return None
         message = result.get("stdout", "")
         return message
 
     @classmethod
-    def remove_upstream(cls, name = "upstream", path = None, raise_e = True):
+    def remove_upstream(cls, name="upstream", path=None, raise_e=True):
         path = path or common.base().get_base_path()
-        result = util.execute(["git", "remote", "remove", name], path = path)
-        if cls._wrap_error(result, raise_e = raise_e): return None
+        result = util.execute(["git", "remote", "remove", name], path=path)
+        if cls._wrap_error(result, raise_e=raise_e):
+            return None
         message = result.get("stdout", "")
         return message
 
     @classmethod
-    def config(cls, key, value, _global = True, path = None, raise_e = True):
+    def config(cls, key, value, _global=True, path=None, raise_e=True):
         path = path or common.base().get_base_path()
         result = util.execute(
-            ["git", "config", "--global" if _global else "", key, value],
-            path = path
+            ["git", "config", "--global" if _global else "", key, value], path=path
         )
-        if cls._wrap_error(result, raise_e = raise_e): return None
+        if cls._wrap_error(result, raise_e=raise_e):
+            return None
         message = result.get("stdout", "")
         return message
 
     @classmethod
-    def get_config(cls, key, _global = True, path = None, raise_e = False):
+    def get_config(cls, key, _global=True, path=None, raise_e=False):
         path = path or common.base().get_base_path()
         result = util.execute(
-            ["git", "config", "--global" if _global else "", "--get", key],
-            path = path
+            ["git", "config", "--global" if _global else "", "--get", key], path=path
         )
-        if cls._wrap_error(result, raise_e = raise_e): return None
+        if cls._wrap_error(result, raise_e=raise_e):
+            return None
         message = result.get("stdout", "")
         value = message.strip()
         return value
 
     @classmethod
-    def get_branches(cls, names = False, path = None, raise_e = False):
+    def get_branches(cls, names=False, path=None, raise_e=False):
         path = path or common.base().get_base_path()
-        result = util.execute(["git", "branch"], path = path)
-        if cls._wrap_error(result, raise_e = raise_e): return None
+        result = util.execute(["git", "branch"], path=path)
+        if cls._wrap_error(result, raise_e=raise_e):
+            return None
         message = result.get("stdout", "")
         branches = message.strip()
         branches = branches.split("\n")
         branches = [(value.lstrip("* "), value.startswith("*")) for value in branches]
-        if names: branches = [branch[0] for branch in branches]
+        if names:
+            branches = [branch[0] for branch in branches]
         return branches
 
     @classmethod
-    def get_branch(cls, path = None, raise_e = False):
+    def get_branch(cls, path=None, raise_e=False):
         path = path or common.base().get_base_path()
-        branches = cls.get_branches(path = path, raise_e = raise_e)
+        branches = cls.get_branches(path=path, raise_e=raise_e)
         for branch, selected in branches:
-            if not selected: continue
+            if not selected:
+                continue
             return branch
         return None
 
     @classmethod
-    def get_commit(cls, path = None, raise_e = False):
+    def get_commit(cls, path=None, raise_e=False):
         path = path or common.base().get_base_path()
-        result = util.execute(["git", "rev-parse", "HEAD"], path = path)
-        if cls._wrap_error(result, raise_e = raise_e): return None
+        result = util.execute(["git", "rev-parse", "HEAD"], path=path)
+        if cls._wrap_error(result, raise_e=raise_e):
+            return None
         message = result.get("stdout", "")
         commit = message.strip()
         return commit
 
     @classmethod
-    def get_origin(cls, path = None, raise_e = False):
+    def get_origin(cls, path=None, raise_e=False):
         path = path or common.base().get_base_path()
         result = util.execute(
-            ["git", "config", "--get", "remote.origin.url"],
-            path = path
+            ["git", "config", "--get", "remote.origin.url"], path=path
         )
-        if cls._wrap_error(result, raise_e = raise_e): return None
+        if cls._wrap_error(result, raise_e=raise_e):
+            return None
         message = result.get("stdout", "")
         origin = message.strip()
         origin = cls.safe_origin(origin)
         return origin
 
     @classmethod
-    def get_repo_path(cls, path = None, raise_e = False):
+    def get_repo_path(cls, path=None, raise_e=False):
         path = path or common.base().get_base_path()
-        result = util.execute(
-            ["git", "rev-parse", "--show-toplevel"],
-            path = path
-        )
-        if cls._wrap_error(result, raise_e = raise_e): return None
+        result = util.execute(["git", "rev-parse", "--show-toplevel"], path=path)
+        if cls._wrap_error(result, raise_e=raise_e):
+            return None
         message = result.get("stdout", "")
         repo_path = message.strip()
         return repo_path
 
     @classmethod
-    def safe_origin(cls, origin, display_l = 3):
+    def safe_origin(cls, origin, display_l=3):
         parse = legacy.urlparse(origin)
         safe_l = []
-        if parse.scheme: safe_l.append(parse.scheme + "://")
-        if parse.username: safe_l.append(parse.username)
+        if parse.scheme:
+            safe_l.append(parse.scheme + "://")
+        if parse.username:
+            safe_l.append(parse.username)
         if parse.password:
             obfuscated = util.obfuscate(parse.password)
             safe_l.append(":" + obfuscated)
-        if parse.username: safe_l.append("@")
-        if parse.hostname: safe_l.append(parse.hostname)
-        if parse.path: safe_l.append(parse.path)
+        if parse.username:
+            safe_l.append("@")
+        if parse.hostname:
+            safe_l.append(parse.hostname)
+        if parse.path:
+            safe_l.append(parse.path)
         return "".join(safe_l)
 
     @classmethod
-    def norm_origin(cls, origin, prefix = "https://"):
-        if origin.startswith(("http://", "https://")): return origin
-        if origin.endswith(".git"): origin = origin[:-4]
+    def norm_origin(cls, origin, prefix="https://"):
+        if origin.startswith(("http://", "https://")):
+            return origin
+        if origin.endswith(".git"):
+            origin = origin[:-4]
         origin = origin.replace(":", "/")
         origin = prefix + origin
         return origin
 
     @classmethod
-    def parse_origin(cls, origin, safe = True):
+    def parse_origin(cls, origin, safe=True):
         parse = legacy.urlparse(origin)
         if safe and not parse.scheme:
             origin = cls.norm_origin(origin)
-            return cls.parse_origin(origin, safe = False)
+            return cls.parse_origin(origin, safe=False)
         scheme = parse.scheme if parse.scheme else "ssh"
         username = parse.username if parse.username else None
         password = parse.password if parse.password else None
         hostname = parse.hostname if parse.hostname else None
         path = parse.path if parse.path else None
         return dict(
-            scheme = scheme,
-            username = username,
-            password = password,
-            hostname = hostname,
-            path = path
+            scheme=scheme,
+            username=username,
+            password=password,
+            hostname=hostname,
+            path=path,
         )
 
     @classmethod
-    def _wrap_error(cls, result, raise_e = False):
+    def _wrap_error(cls, result, raise_e=False):
         code = result["code"]
-        if code == 0: return False
+        if code == 0:
+            return False
         if raise_e:
             raise exceptions.OperationalError(
-                message = result.get("stderr", "") or\
-                    result.get("stdout", "")
+                message=result.get("stderr", "") or result.get("stdout", "")
             )
         return True

appier/graph.py

@@ -2,7 +2,7 @@
 # -*- coding: utf-8 -*-
 
 # Hive Appier Framework
-# Copyright (c) 2008-2022 Hive Solutions Lda.
+# Copyright (c) 2008-2024 Hive Solutions Lda.
 #
 # This file is part of Hive Appier Framework.
 #
@@ -22,16 +22,7 @@
 __author__ = "João Magalhães <joamag@hive.pt>"
 """ The author(s) of the module """
 
-__version__ = "1.0.0"
-""" The version of the module """
-
-__revision__ = "$LastChangedRevision$"
-""" The revision number of the module """
-
-__date__ = "$LastChangedDate$"
-""" The last change date of the module """
-
-__copyright__ = "Copyright (c) 2008-2022 Hive Solutions Lda."
+__copyright__ = "Copyright (c) 2008-2024 Hive Solutions Lda."
 """ The copyright for the module """
 
 __license__ = "Apache License, Version 2.0"
@@ -40,6 +31,7 @@ __license__ = "Apache License, Version 2.0"
 from . import defines
 from . import queuing
 
+
 class Graph(object):
     """
     Graph structure and associated algorithms. Made up by a dictionary of
@@ -63,7 +55,8 @@ class Graph(object):
         cur, path = dst, []
         while not cur == src:
             path.append(cur)
-            if not cur in prev: return []
+            if not cur in prev:
+                return []
             cur = prev[cur]
         path.append(src)
         path.reverse()
@@ -71,17 +64,22 @@ class Graph(object):
 
     def add_edges(self, edges):
         for edge in edges:
-            if len(edge) < 2: continue
+            if len(edge) < 2:
+                continue
             src, dst = edge[0], edge[1]
             cost = edge[2] if len(edge) > 2 and isinstance(edge[2], int) else 1
-            bidirectional = edge[3] if len(edge) > 3 and isinstance(edge[3], bool) else False
-            self.add_edge(src, dst, cost = cost, bidirectional = bidirectional)
-
-    def add_edge(self, src, dst, cost = 1, bidirectional = False):
-        if not src in self.edges: self.edges[src] = []
+            bidirectional = (
+                edge[3] if len(edge) > 3 and isinstance(edge[3], bool) else False
+            )
+            self.add_edge(src, dst, cost=cost, bidirectional=bidirectional)
+
+    def add_edge(self, src, dst, cost=1, bidirectional=False):
+        if not src in self.edges:
+            self.edges[src] = []
         self.edges[src].append((dst, cost))
 
-        if bidirectional: self.add_edge(dst, src, cost = cost, bidirectional = False)
+        if bidirectional:
+            self.add_edge(dst, src, cost=cost, bidirectional=False)
 
     def dijkstra(self, src, dst):
         """
@@ -96,28 +94,29 @@ class Graph(object):
         :see: https://en.wikipedia.org/wiki/Dijkstra%27s_algorithm
         """
 
-        if src == dst: return [src], 0
+        if src == dst:
+            return [src], 0
 
         cls = self.__class__
         dist, prev = dict(), dict()
         dist[src] = 0
 
         queue = queuing.MemoryQueue()
-        queue.push(src, priority = 0)
+        queue.push(src, priority=0)
 
         while queue.length() > 0:
-            (_, _, top) = queue.pop(full = True)
+            (_, _, top) = queue.pop(full=True)
             dist[top] = dist[top] if top in dist else defines.INFINITY
 
             edges = self.edges[top] if top in self.edges else []
-            for (nxt, cost) in edges:
+            for nxt, cost in edges:
                 dist[nxt] = dist[nxt] if nxt in dist else defines.INFINITY
 
                 alt = dist[top] + cost
                 if alt < dist[nxt]:
                     dist[nxt] = alt
                     prev[nxt] = top
-                    queue.push(nxt, priority = dist[nxt])
+                    queue.push(nxt, priority=dist[nxt])
 
         path = cls._build_path(prev, src, dst)
         cost = dist[dst] if dst in dist else defines.INFINITY