codenerix-lib 1.1.0__py3-none-any.whl

codenerix_lib/__init__.py

@@ -0,0 +1,9 @@
+__version__ = "1.1.0"
+
+__authors__ = [
+    "Juanmi Taboada",
+]
+
+__authors_email__ = [
+    "juanmi@juanmitaboada.com",
+]

codenerix_lib/colors.py

@@ -0,0 +1,121 @@
+#!/usr/bin/env python3
+#
+# django-codenerix
+#
+# Codenerix GNU
+#
+# Project URL : http://www.codenerix.com
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""
+Colors definition
+"""
+
+from colorama import init
+
+init()
+
+__version__ = "201109111106"
+
+
+__all__ = ["colors"]
+
+
+# Colors
+colors = {
+    # Simple
+    "simplegrey": (0, 30),
+    "simplered": (0, 31),
+    "simplegreen": (0, 32),
+    "simpleyellow": (0, 33),
+    "simpleblue": (0, 34),
+    "simplepurple": (0, 35),
+    "simplecyan": (0, 36),
+    "simplewhite": (0, 37),
+    # Bold
+    "grey": (1, 30),
+    "red": (1, 31),
+    "green": (1, 32),
+    "yellow": (1, 33),
+    "blue": (1, 34),
+    "purple": (1, 35),
+    "cyan": (1, 36),
+    "white": (1, 37),
+    # Close
+    "close": (1, 0),
+}
+
+# HTML Colors
+html_colors = {
+    # Simple
+    "simplegrey": (0, (128, 128, 128)),
+    "simplered": (0, (255, 0, 0)),
+    "simplegreen": (0, (0, 255, 0)),
+    "simpleyellow": (0, (255, 255, 0)),
+    "simpleblue": (0, (0, 0, 255)),
+    "simplepurple": (0, (128, 0, 128)),
+    "simplecyan": (0, (0, 255, 255)),
+    "simplewhite": (0, (255, 255, 255)),
+    # Bold
+    "grey": (1, (169, 169, 169)),
+    "red": (1, (255, 69, 0)),
+    "green": (1, (0, 128, 0)),
+    "yellow": (1, (255, 255, 0)),
+    "blue": (1, (0, 0, 255)),
+    "purple": (1, (128, 0, 128)),
+    "cyan": (1, (0, 255, 255)),
+    "white": (1, (255, 255, 255)),
+}
+
+
+def colorize(msg, color=None):
+    # Colors
+    if color in colors:
+        (darkbit, subcolor) = colors[color]
+    else:
+        (darkbit, subcolor) = (1, 0)
+
+    # Prepare the message
+    result = f"\033[{darkbit:1d};{subcolor:02d}m"
+    result += msg
+    result += "\033[1;00m"
+
+    # Return the result
+    return result
+
+
+def get_colors():
+    # Reorder colors
+    keys = []
+    for key in colors.keys():
+        keys.append((colors[key][0], colors[key][1], key))
+    keys.sort()
+
+    # Show up all colors
+    buffer = ""
+    for color in keys:
+        # Get the color information
+        (simplebit, subcolor) = colors[color[2]]
+        if len(buffer) > 0:
+            buffer += "\n"
+        # Show it
+        buffer += (
+            f"{simplebit:1d}:{subcolor:02d} - "
+            f"\033[{simplebit:1d};{subcolor:02d}m{color[2]:<14s}"
+            f"\033[1;00m{color[2]:<s}"
+        )
+    return buffer
+
+
+if __name__ == "__main__":  # pragma: no cover
+    print(get_colors())

codenerix_lib/cryptography.py

@@ -0,0 +1,81 @@
+#
+# django-codenerix-extensions
+#
+# Codenerix GNU
+#
+# Project URL : http://www.codenerix.com
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# This library is intended for encrypting as CODENERIX's Cryptography
+# Libraries work, the basis for the library to work are, the KEY is always
+# a SHA256 from your real KEY, the IV vector should be generated automatically
+# on encryption time by the library and must be inserted at the beginning
+# of the encrypted string (which shoul be padded with PKCS7). The full
+# string IV+ENCRYPTED is encoded to Base64. For decrypting the process is
+# the opossite, the raw string is decoded from Base64, the first 16 bytes
+# are taken as the IV and the rest as the encrypted string, the key is hashed
+# with SHA256 and then the encrypted string is decrypted using the IV and
+# the hashed key.
+import base64
+import hashlib
+
+from Cryptodome import Random
+from Cryptodome.Cipher import AES
+
+
+class AESCipher:
+    """
+    Adapted solution from: https://stackoverflow.com/a/21928790/1481040
+    """
+
+    def __init__(self):
+        self.bs = 32
+
+    def encrypt(self, raw, key, iv=None, b64encoded=True):
+        raw = self._pad(raw)
+        if iv is None:
+            iv = Random.new().read(AES.block_size)
+        hashkey = hashlib.sha256(key.encode()).digest()
+        cipher = AES.new(hashkey, AES.MODE_CBC, iv)
+
+        if not isinstance(raw, bytes):
+            raw = raw.encode()
+
+        if b64encoded:
+            return base64.b64encode(iv + cipher.encrypt(raw))
+        else:
+            return iv + cipher.encrypt(raw)
+
+    def decrypt(self, enc, key, b64encoded=True):
+        if b64encoded:
+            enc = base64.b64decode(enc)
+        iv = enc[: AES.block_size]
+        if not isinstance(key, bytes):
+            key = key.encode()
+        hashkey = hashlib.sha256(key).digest()
+        cipher = AES.new(hashkey, AES.MODE_CBC, iv)
+        unpad = self._unpad(cipher.decrypt(enc[AES.block_size :]))
+        if not isinstance(unpad, bytes):
+            unpad = unpad.decode("utf-8")
+        return unpad
+
+    def _pad(self, s):
+        pad = (self.bs - len(s) % self.bs) * chr(self.bs - len(s) % self.bs)
+        if isinstance(s, bytes):
+            pad = pad.encode()
+        return s + pad
+
+    @staticmethod
+    def _unpad(s):
+        return s[: -ord(s[len(s) - 1 :])]