lightphe 0.0.1__tar.gz → 0.0.3__tar.gz

{lightphe-0.0.1 → lightphe-0.0.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lightphe
-Version: 0.0.1
+Version: 0.0.3
 Summary: A Lightweight Partially Homomorphic Encryption Library for Python
 Home-page: https://github.com/serengil/LightPHE
 Author: Sefik Ilkin Serengil
@@ -31,13 +31,21 @@ License-File: LICENSE
 
 </div>
 
-<p align="center"><img src="icons/phi.png" width="200" height="240"></p>
+<p align="center"><img src="https://raw.githubusercontent.com/serengil/LightPHE/master/icons/phi.png" width="200" height="240"></p>
 
 LightPHE is a lightweight partially homomorphic encryption library for python. It is a hybrid homomoprhic encryption library wrapping many schemes such as [`RSA`](https://sefiks.com/2023/03/06/a-step-by-step-partially-homomorphic-encryption-example-with-rsa-in-python/), [`ElGamal`](https://sefiks.com/2023/03/27/a-step-by-step-partially-homomorphic-encryption-example-with-elgamal-in-python/), [`Exponential ElGamal`](https://sefiks.com/2023/03/27/a-step-by-step-partially-homomorphic-encryption-example-with-elgamal-in-python/), [`Elliptic Curve ElGamal`](https://sefiks.com/2018/08/21/elliptic-curve-elgamal-encryption/), [`Paillier`](https://sefiks.com/2023/04/03/a-step-by-step-partially-homomorphic-encryption-example-with-paillier-in-python/), [`Damgard-Jurik`](https://sefiks.com/2023/10/20/a-step-by-step-partially-homomorphic-encryption-example-with-damgard-jurik-in-python/), [`Okamoto–Uchiyama`](https://sefiks.com/2023/10/20/a-step-by-step-partially-homomorphic-encryption-example-with-okamoto-uchiyama-in-python/), [`Benaloh`](https://sefiks.com/2023/10/06/a-step-by-step-partially-homomorphic-encryption-example-with-benaloh-in-python-from-scratch/), [`Naccache–Stern`](https://sefiks.com/2023/10/26/a-step-by-step-partially-homomorphic-encryption-example-with-naccache-stern-in-python/), [`Goldwasser–Micali`](https://sefiks.com/2023/10/27/a-step-by-step-partially-homomorphic-encryption-example-with-goldwasser-micali-in-python/).
 
-Even though fully homomorphic encryption (FHE) has become available in recent times, but when considering the trade-offs, LightPHE emerges as a more efficient and practical choice. If your specific task doesn't demand the full homomorphic capabilities, opting for partial homomorphism with LightPHE is the logical decision. LightPHE is notably faster and demands fewer computational resources compared to FHE. Besides, it generates smaller ciphertexts, making it well-suited for memory-constrained environments. Finally, LightPHE strikes a favorable balance between security and efficiency for practical use cases.
+# Partially vs Fully Homomorphic Encryption
 
-# Installation
+Even though fully homomorphic encryption (FHE) has become available in recent times, but when considering the trade-offs, LightPHE emerges as a more efficient and practical choice. If your specific task doesn't demand the full homomorphic capabilities, opting for partial homomorphism with LightPHE is the logical decision.
+
+- 🏎️ Notably faster
+- 💻 Demands fewer computational resources
+- 📏 Generating smaller ciphertexts
+- 🧠 Well-suited for memory-constrained environments
+- ⚖️ Strikes a favorable balance for practical use cases
+
+# Installation [![PyPI](https://img.shields.io/pypi/v/lightphe.svg)](https://pypi.org/project/lightphe/)
 
 The easiest way to install the LightPHE package is to install it from python package index (PyPI).
 
@@ -118,18 +126,30 @@ m2 = 23
 c1 = cs.encrypt(m1)
 c2 = cs.encrypt(m2)
 
-# performing homomorphic addition on ciphertexts
-assert cs.decrypt(c1 + c2) == m1 + m2
+# homomorphic addition - private key is not required!
+c3 = c1 + c2
+
+# proof of work
+assert cs.decrypt(c3) == m1 + m2
 ```
 
-Besides, Paillier is supporting multiplying ciphertexts by a known plain constant. Simply put, decryption of scalar multiplication of ciphertext is equivalent to that constant times plaintext as well.
+⚡ Notice that once can perform `c1 + c2` here without holding private key. However, just the data owner with private key can perform encryption and decryption. This is the basic definition of homomorphic encryption.
+
+Besides, Paillier is supporting multiplying ciphertexts by a known plain constant. Simply put, decryption of scalar multiplication of ciphertext is equivalent to that constant times plaintext as well. 
 
 ```python
-# scalar multiplication
-k = 5
-assert cs.decrypt(k * c1) == k * m1
+# increasing something 5%
+k = 1.05
+
+# scalar multiplication - private key is not required!
+c4 = k * c1
+
+# proof of work
+assert cs.decrypt(c4) == k * m1
 ```
 
+⚡ Herein, `k * c1` operation can be performed by anyone without holding private key.
+
 Similar to the most of additively homomorphic algorithms, Paillier lets you to regenerate ciphertext while you are not breaking its plaintext restoration. You may consider to do this re-generation many times to have stronger ciphertexts.
 
 ```python
@@ -142,11 +162,11 @@ assert cs.decrypt(c1) == m1
 Finally, if you try to perform an operation that algorithm does not support, then an exception will be thrown. For instance, Paillier is not homomorphic with respect to the multiplication or xor. To put it simply, you cannot multiply two ciphertexts. If you enforce this calculation, you will have an exception.
 
 ```python
-# pailier is not homomorphic with respect to the multiplication
+# pailier is not multiplicatively homomorphic
 with pytest.raises(ValueError, match="Paillier is not homomorphic with respect to the multiplication"):
   c1 * c2
 
-# pailier is not homomorphic with respect to the xor
+# pailier is not exclusively homomorphic
 with pytest.raises(ValueError, match="Paillier is not homomorphic with respect to the exclusive or"):
   c1 ^ c2
 ```
@@ -159,6 +179,16 @@ All PRs are more than welcome! If you are planning to contribute a large patch,
 
 You should be able run `make test` and `make lint` commands successfully before committing. Once a PR is created, GitHub test workflow will be run automatically and unit test results will be available in [GitHub actions](https://github.com/serengil/LightPHE/actions/workflows/tests.yml) before approval. Besides, workflow will evaluate the code with pylint as well.
 
+# Support
+
+There are many ways to support a project - starring⭐️ the GitHub repo is just one 🙏
+
+You can also support this work on [Patreon](https://www.patreon.com/serengil?repo=lightphe) or [GitHub Sponsors](https://github.com/sponsors/serengil).
+
+<a href="https://www.patreon.com/serengil?repo=lightphe">
+<img src="https://raw.githubusercontent.com/serengil/LightPHE/master/icons/patreon.png" width="30%" height="30%">
+</a>
+
 # Citation
 
 Please cite LightPHE in your publications if it helps your research. Here is its BibTex entry:
@@ -173,10 +203,10 @@ Please cite LightPHE in your publications if it helps your research. Here is its
 }
 ```
 
-Also, if you use LightPHE in your projects, please add `LightPHE` in the `requirements.txt`.
+Also, if you use LightPHE in your projects, please add `lightphe` in the `requirements.txt`.
 
 # License
 
-LightPHE is licensed under the MIT License - see [`LICENSE`](LICENSE) for more details.
+LightPHE is licensed under the MIT License - see [`LICENSE`](https://github.com/serengil/LightPHE/blob/master/LICENSE) for more details.
 
 

{lightphe-0.0.1 → lightphe-0.0.3}/README.md

@@ -15,13 +15,21 @@
 
 </div>
 
-<p align="center"><img src="icons/phi.png" width="200" height="240"></p>
+<p align="center"><img src="https://raw.githubusercontent.com/serengil/LightPHE/master/icons/phi.png" width="200" height="240"></p>
 
 LightPHE is a lightweight partially homomorphic encryption library for python. It is a hybrid homomoprhic encryption library wrapping many schemes such as [`RSA`](https://sefiks.com/2023/03/06/a-step-by-step-partially-homomorphic-encryption-example-with-rsa-in-python/), [`ElGamal`](https://sefiks.com/2023/03/27/a-step-by-step-partially-homomorphic-encryption-example-with-elgamal-in-python/), [`Exponential ElGamal`](https://sefiks.com/2023/03/27/a-step-by-step-partially-homomorphic-encryption-example-with-elgamal-in-python/), [`Elliptic Curve ElGamal`](https://sefiks.com/2018/08/21/elliptic-curve-elgamal-encryption/), [`Paillier`](https://sefiks.com/2023/04/03/a-step-by-step-partially-homomorphic-encryption-example-with-paillier-in-python/), [`Damgard-Jurik`](https://sefiks.com/2023/10/20/a-step-by-step-partially-homomorphic-encryption-example-with-damgard-jurik-in-python/), [`Okamoto–Uchiyama`](https://sefiks.com/2023/10/20/a-step-by-step-partially-homomorphic-encryption-example-with-okamoto-uchiyama-in-python/), [`Benaloh`](https://sefiks.com/2023/10/06/a-step-by-step-partially-homomorphic-encryption-example-with-benaloh-in-python-from-scratch/), [`Naccache–Stern`](https://sefiks.com/2023/10/26/a-step-by-step-partially-homomorphic-encryption-example-with-naccache-stern-in-python/), [`Goldwasser–Micali`](https://sefiks.com/2023/10/27/a-step-by-step-partially-homomorphic-encryption-example-with-goldwasser-micali-in-python/).
 
-Even though fully homomorphic encryption (FHE) has become available in recent times, but when considering the trade-offs, LightPHE emerges as a more efficient and practical choice. If your specific task doesn't demand the full homomorphic capabilities, opting for partial homomorphism with LightPHE is the logical decision. LightPHE is notably faster and demands fewer computational resources compared to FHE. Besides, it generates smaller ciphertexts, making it well-suited for memory-constrained environments. Finally, LightPHE strikes a favorable balance between security and efficiency for practical use cases.
+# Partially vs Fully Homomorphic Encryption
 
-# Installation
+Even though fully homomorphic encryption (FHE) has become available in recent times, but when considering the trade-offs, LightPHE emerges as a more efficient and practical choice. If your specific task doesn't demand the full homomorphic capabilities, opting for partial homomorphism with LightPHE is the logical decision.
+
+- 🏎️ Notably faster
+- 💻 Demands fewer computational resources
+- 📏 Generating smaller ciphertexts
+- 🧠 Well-suited for memory-constrained environments
+- ⚖️ Strikes a favorable balance for practical use cases
+
+# Installation [![PyPI](https://img.shields.io/pypi/v/lightphe.svg)](https://pypi.org/project/lightphe/)
 
 The easiest way to install the LightPHE package is to install it from python package index (PyPI).
 
@@ -102,18 +110,30 @@ m2 = 23
 c1 = cs.encrypt(m1)
 c2 = cs.encrypt(m2)
 
-# performing homomorphic addition on ciphertexts
-assert cs.decrypt(c1 + c2) == m1 + m2
+# homomorphic addition - private key is not required!
+c3 = c1 + c2
+
+# proof of work
+assert cs.decrypt(c3) == m1 + m2
 ```
 
-Besides, Paillier is supporting multiplying ciphertexts by a known plain constant. Simply put, decryption of scalar multiplication of ciphertext is equivalent to that constant times plaintext as well.
+⚡ Notice that once can perform `c1 + c2` here without holding private key. However, just the data owner with private key can perform encryption and decryption. This is the basic definition of homomorphic encryption.
+
+Besides, Paillier is supporting multiplying ciphertexts by a known plain constant. Simply put, decryption of scalar multiplication of ciphertext is equivalent to that constant times plaintext as well. 
 
 ```python
-# scalar multiplication
-k = 5
-assert cs.decrypt(k * c1) == k * m1
+# increasing something 5%
+k = 1.05
+
+# scalar multiplication - private key is not required!
+c4 = k * c1
+
+# proof of work
+assert cs.decrypt(c4) == k * m1
 ```
 
+⚡ Herein, `k * c1` operation can be performed by anyone without holding private key.
+
 Similar to the most of additively homomorphic algorithms, Paillier lets you to regenerate ciphertext while you are not breaking its plaintext restoration. You may consider to do this re-generation many times to have stronger ciphertexts.
 
 ```python
@@ -126,11 +146,11 @@ assert cs.decrypt(c1) == m1
 Finally, if you try to perform an operation that algorithm does not support, then an exception will be thrown. For instance, Paillier is not homomorphic with respect to the multiplication or xor. To put it simply, you cannot multiply two ciphertexts. If you enforce this calculation, you will have an exception.
 
 ```python
-# pailier is not homomorphic with respect to the multiplication
+# pailier is not multiplicatively homomorphic
 with pytest.raises(ValueError, match="Paillier is not homomorphic with respect to the multiplication"):
   c1 * c2
 
-# pailier is not homomorphic with respect to the xor
+# pailier is not exclusively homomorphic
 with pytest.raises(ValueError, match="Paillier is not homomorphic with respect to the exclusive or"):
   c1 ^ c2
 ```
@@ -143,6 +163,16 @@ All PRs are more than welcome! If you are planning to contribute a large patch,
 
 You should be able run `make test` and `make lint` commands successfully before committing. Once a PR is created, GitHub test workflow will be run automatically and unit test results will be available in [GitHub actions](https://github.com/serengil/LightPHE/actions/workflows/tests.yml) before approval. Besides, workflow will evaluate the code with pylint as well.
 
+# Support
+
+There are many ways to support a project - starring⭐️ the GitHub repo is just one 🙏
+
+You can also support this work on [Patreon](https://www.patreon.com/serengil?repo=lightphe) or [GitHub Sponsors](https://github.com/sponsors/serengil).
+
+<a href="https://www.patreon.com/serengil?repo=lightphe">
+<img src="https://raw.githubusercontent.com/serengil/LightPHE/master/icons/patreon.png" width="30%" height="30%">
+</a>
+
 # Citation
 
 Please cite LightPHE in your publications if it helps your research. Here is its BibTex entry:
@@ -157,8 +187,8 @@ Please cite LightPHE in your publications if it helps your research. Here is its
 }
 ```
 
-Also, if you use LightPHE in your projects, please add `LightPHE` in the `requirements.txt`.
+Also, if you use LightPHE in your projects, please add `lightphe` in the `requirements.txt`.
 
 # License
 
-LightPHE is licensed under the MIT License - see [`LICENSE`](LICENSE) for more details.
+LightPHE is licensed under the MIT License - see [`LICENSE`](https://github.com/serengil/LightPHE/blob/master/LICENSE) for more details.

lightphe-0.0.3/lightphe/__init__.py

@@ -0,0 +1,230 @@
+import json
+from typing import Optional, Union
+
+from lightphe.models.Ciphertext import Ciphertext
+from lightphe.models.Algorithm import Algorithm
+from lightphe.cryptosystems.RSA import RSA
+from lightphe.cryptosystems.ElGamal import ElGamal
+from lightphe.cryptosystems.Paillier import Paillier
+from lightphe.cryptosystems.DamgardJurik import DamgardJurik
+from lightphe.cryptosystems.OkamotoUchiyama import OkamotoUchiyama
+from lightphe.cryptosystems.Benaloh import Benaloh
+from lightphe.cryptosystems.NaccacheStern import NaccacheStern
+from lightphe.cryptosystems.GoldwasserMicali import GoldwasserMicali
+from lightphe.cryptosystems.EllipticCurveElGamal import EllipticCurveElGamal
+from lightphe.commons.logger import Logger
+
+# pylint: disable=eval-used
+
+logger = Logger()
+
+
+class LightPHE:
+    def __init__(
+        self,
+        algorithm_name: str,
+        keys: Optional[dict] = None,
+        key_file: Optional[str] = None,
+        key_size: Optional[int] = None,
+    ):
+        """
+        Build LightPHE class
+        Args:
+            algorithm_name (str): RSA | ElGamal | Exponential-ElGamal | EllipticCurve-ElGamal
+                | Paillier | Damgard-Jurik | Okamoto-Uchiyama | Benaloh | Naccache-Stern
+                | Goldwasser-Micali
+            keys (dict): optional private-public key pair
+            key_file (str): if keys are exported, you can load them into cryptosystem
+            key_size (int): key size in bits
+        """
+        self.algorithm_name = algorithm_name
+
+        if key_file is not None:
+            keys = self.restore_keys(target_file=key_file)
+
+        self.cs = self.build_cryptosystem(
+            algorithm_name=algorithm_name, keys=keys, key_size=key_size
+        )
+
+    def build_cryptosystem(
+        self,
+        algorithm_name: str,
+        keys: Optional[dict] = None,
+        key_size: Optional[int] = None,
+    ) -> Union[
+        RSA,
+        ElGamal,
+        Paillier,
+        DamgardJurik,
+        OkamotoUchiyama,
+        Benaloh,
+        NaccacheStern,
+        EllipticCurveElGamal,
+    ]:
+        """
+        Build a cryptosystem among partially homomorphic algorithms
+        Args:
+            algorithm_name (str): RSA | ElGamal | Exponential-ElGamal | EllipticCurve-ElGamal
+                | Paillier | Damgard-Jurik | Okamoto-Uchiyama | Benaloh | Naccache-Stern
+                | Goldwasser-Micali
+            keys (dict): optional private-public key pair
+            key_file (str): if keys are exported, you can load them into cryptosystem
+            key_size (int): key size in bits
+        Returns
+            cryptosystem
+        """
+
+        if key_size is None:
+            key_size = self.recommend_key_size(algorithm_name=algorithm_name)
+
+        # build cryptosystem
+        if algorithm_name == Algorithm.RSA:
+            cs = RSA(keys=keys, key_size=key_size)
+        elif algorithm_name == Algorithm.ElGamal:
+            cs = ElGamal(keys=keys, key_size=key_size)
+        elif algorithm_name == Algorithm.ExponentialElGamal:
+            cs = ElGamal(keys=keys, key_size=key_size, exponential=True)
+        elif algorithm_name == Algorithm.EllipticCurveElGamal:
+            cs = EllipticCurveElGamal(keys=keys, key_size=key_size)
+        elif algorithm_name == Algorithm.Paillier:
+            cs = Paillier(keys=keys, key_size=key_size)
+        elif algorithm_name == Algorithm.DamgardJurik:
+            cs = DamgardJurik(keys=keys, key_size=key_size)
+        elif algorithm_name == Algorithm.OkamotoUchiyama:
+            cs = OkamotoUchiyama(keys=keys, key_size=key_size)
+        elif algorithm_name == Algorithm.Benaloh:
+            cs = Benaloh(keys=keys, key_size=key_size)
+        elif algorithm_name == Algorithm.NaccacheStern:
+            cs = NaccacheStern(keys=keys, key_size=key_size)
+        elif algorithm_name == Algorithm.GoldwasserMicali:
+            cs = GoldwasserMicali(keys=keys, key_size=key_size)
+        else:
+            raise ValueError(f"unimplemented algorithm - {algorithm_name}")
+        return cs
+
+    def encrypt(self, plaintext: int) -> Ciphertext:
+        """
+        Encrypt a plaintext with a built cryptosystem
+        Args:
+            plaintext (int): message
+        Returns
+            ciphertext (from lightphe.models.Ciphertext import Ciphertext): encrypted message
+        """
+        ciphertext = self.cs.encrypt(plaintext=plaintext)
+        return Ciphertext(algorithm_name=self.algorithm_name, keys=self.cs.keys, value=ciphertext)
+
+    def decrypt(self, ciphertext: Ciphertext) -> int:
+        """
+        Decrypt a ciphertext with a buit cryptosystem
+        Args:
+            ciphertext (from lightphe.models.Ciphertext import Ciphertext): encrypted message
+        Returns:
+            plaintext (int): restored message
+        """
+        return self.cs.decrypt(ciphertext=ciphertext.value)
+
+    def regenerate_ciphertext(self, ciphertext: Ciphertext) -> Ciphertext:
+        """
+        Generate a different ciphertext belonging to same plaintext
+        Args:
+            ciphertext (from lightphe.models.Ciphertext import Ciphertext): encrypted message
+        Returns:
+            ciphertext (from lightphe.models.Ciphertext import Ciphertext): encrypted message
+        """
+        ciphertext_new = self.cs.reencrypt(ciphertext=ciphertext.value)
+        return Ciphertext(
+            algorithm_name=self.algorithm_name, keys=self.cs.keys, value=ciphertext_new
+        )
+
+    def export_keys(self, target_file: str, public: bool = False) -> None:
+        """
+        Export keys to a file
+        Args:
+            target_file (str): target file name
+            public (bool): set this to True if you will publish this
+                to publicly.
+        """
+        keys = self.cs.keys
+        if public is True and keys.get("private_key") is not None:
+            del keys["private_key"]
+
+        if public is False:
+            logger.warn(
+                "You did not set public arg to True. So, exported key has private key information."
+                "Do not share this to anyone"
+            )
+
+        with open(target_file, "w", encoding="UTF-8") as file:
+            file.write(json.dumps(keys))
+
+    def restore_keys(self, target_file: str) -> dict:
+        """
+        Restore keys from a file
+        Args:
+            target_file (str): target file name
+        Returns:
+            keys (dict): private public key pair
+        """
+        with open(target_file, "r", encoding="UTF-8") as file:
+            dict_str = file.read()
+
+        keys = eval(dict_str)
+        if not isinstance(keys, dict):
+            raise ValueError(
+                f"The content of the file {target_file} does not represent a valid dictionary."
+            )
+
+        if "private_key" in keys.keys():
+            logger.info(f"private-public key pair is restored from {target_file}")
+        elif "public_key" in keys.keys():
+            logger.info(f"public key is restored from {target_file}")
+        else:
+            raise ValueError(f"File {target_file} must have public_key key")
+        return keys
+
+    def recommend_key_size(self, algorithm_name: str) -> int:
+        """
+        Recommend a key size in bits if it is not mentioned by the user
+        Args:
+            algorithm_name (str): algorithm name
+        Returns
+            key_size (int)
+        """
+        if algorithm_name == Algorithm.RSA:
+            key_size = 1024
+        elif algorithm_name == Algorithm.ElGamal:
+            key_size = 1024
+        elif algorithm_name == Algorithm.ExponentialElGamal:
+            key_size = 1024
+        # 160-bit ECC is equivalent to 1024-bit RSA
+        elif algorithm_name == Algorithm.EllipticCurveElGamal:
+            key_size = 160
+        elif algorithm_name == Algorithm.Paillier:
+            key_size = 1024
+        elif algorithm_name == Algorithm.DamgardJurik:
+            key_size = 1024
+        elif algorithm_name == Algorithm.OkamotoUchiyama:
+            key_size = 1024
+        # n should be several hundred bits or more
+        elif algorithm_name == Algorithm.GoldwasserMicali:
+            key_size = 100
+        # Benaloh and Naccache-Stern require to solve DLP in decryption
+        # so small key is recommended
+        elif algorithm_name == Algorithm.Benaloh:
+            key_size = 50
+        elif algorithm_name == Algorithm.NaccacheStern:
+            key_size = 37
+        else:
+            raise ValueError(f"unimplemented algorithm - {algorithm_name}")
+        return key_size
+
+    def create_ciphertext_obj(self, ciphertext: Union[int, tuple, list]) -> Ciphertext:
+        """
+        Ciphertext objects have keys in addition ciphertext itself to perform
+        homomorphic operations.
+        Args:
+            ciphertext (int or tuple or list): ciphertext content
+        Returns:
+            Ciphertext
+        """
+        return Ciphertext(algorithm_name=self.algorithm_name, keys=self.cs.keys, value=ciphertext)

lightphe-0.0.3/lightphe/commons/logger.py

@@ -0,0 +1,39 @@
+import os
+import logging
+from datetime import datetime
+
+
+class Logger:
+    def __init__(self):
+        log_level = os.environ.get("LIGHTPHE_LOG_LEVEL", str(logging.INFO))
+        try:
+            self.log_level = int(log_level)
+        except Exception as err:
+            self.dump_log(
+                f"Exception while parsing $LIGHTPHE_LOG_LEVEL."
+                f"Expected int but it is {log_level} ({str(err)})"
+            )
+            self.log_level = logging.INFO
+
+    def debug(self, message):
+        if self.log_level <= logging.DEBUG:
+            self.dump_log(message)
+
+    def info(self, message):
+        if self.log_level <= logging.INFO:
+            self.dump_log(message)
+
+    def warn(self, message):
+        if self.log_level <= logging.WARNING:
+            self.dump_log(message)
+
+    def error(self, message):
+        if self.log_level <= logging.ERROR:
+            self.dump_log(message)
+
+    def critical(self, message):
+        if self.log_level <= logging.CRITICAL:
+            self.dump_log(message)
+
+    def dump_log(self, message):
+        print(f"{str(datetime.now())[2:-7]} - {message}")