znote 1.0.0__py3-none-any.whl

znote/core/client/settings.py

@@ -0,0 +1,142 @@
+import __main__
+import impmagic
+
+
+class Settings():
+    @impmagic.loader(
+        {'module': '__main__'},
+        {'module': 'os'},
+        {'module': 'pyotp'},
+        {'module': 'app.display','submodule': ['logs']},
+        {'module': 'Crypto','submodule': ['Random']},
+        {'module': 'Crypto.PublicKey','submodule': ['RSA']},
+        {'module': 'core.config','submodule': ['Config']},
+        {'module': 'core.client.token','submodule': ['get_token']}
+    )
+    def __init__(self, config_file):
+        self.config_dir = os.path.abspath(os.path.expanduser('~/.config/znote'))
+        
+        self.token_file = os.path.join(self.config_dir, ".token")
+
+        if not config_file:
+            config_file = os.path.join(self.config_dir, "config.yml")
+
+        self.config = Config(f"{config_file}")
+
+        self.verbose = self.config.get('client.verbose', default=False, auto_set=True)
+        
+        self.host = self.config.get('client.host', default="127.0.0.1", auto_set=True)
+        self.port = self.config.get('client.port', default=40017, auto_set=True)
+        self.key_size = self.config.get('client.key_size', default=2048, auto_set=True)
+        self.key_otp = self.config.get('client.key_otp', default='JBSWY3DPEHPK3PXP', auto_set=True)     
+        self.totp = pyotp.TOTP(self.key_otp)
+
+        self.PubServ = None
+        self.keyC = None
+
+        self.token = get_token(self.token_file)
+        self.pubserv_set = None
+        self.authenticated = False
+
+
+    @impmagic.loader(
+        {'module': '__main__'},
+        {'module': 'os'},
+        {'module': 'hashlib'},
+        {'module': 'Crypto.PublicKey', 'submodule': ['RSA']},
+        {'module': 'Crypto', 'submodule': ['Random']},
+        {'module': 'app.display', 'submodule': ['logs']},
+    )
+    def load_key(self):
+        privkey_path = os.path.join(self.config_dir, "client.key")
+        pubkey_path = os.path.join(self.config_dir, "client.pem")
+        
+        if not os.path.exists(privkey_path) or not os.path.exists(pubkey_path):
+            try:
+                #Génération de la paire de clé pour les échanges avec le client
+                logs("Création de la paire de clé", "info")
+                rng = Random.new().read
+                rsa_key = RSA.generate(self.key_size, rng)
+                rsa_priv = rsa_key.exportKey("PEM")
+
+                self.PrivKey = rsa_key.exportKey('PEM', pkcs=1)
+
+                with open(privkey_path, "wb") as f:
+                    f.write(self.PrivKey)
+
+                key_pub = rsa_key.publickey()
+                self.PubKey = key_pub.exportKey("PEM")
+                
+                with open(pubkey_path, "wb") as f:
+                    f.write(self.PubKey)
+
+                
+                logs("Paire de clé créée", "success")
+
+            except Exception as err:
+                logs(f"Erreur lors de la création de la paire de clé: {err}", "error")
+
+        else:
+            try:
+                logs("Chargement de la paire de clé", "info")
+                
+                with open(privkey_path, "rb") as f:
+                    self.PrivKey = f.read()
+                
+                with open(pubkey_path, "rb") as f:
+                    self.PubKey = f.read()
+                
+                logs("Paire de clé chargée", "success")
+
+            except Exception as err:
+                logs(f"Erreur lors du chargement de la paire de clé: {err}", "error")
+
+        self.key = RSA.importKey(self.PrivKey)
+
+        #Calcul du hash de la clé du client
+        self.clienthash = hashlib.sha256(self.PubKey).hexdigest()
+
+
+        #Chargement de la clé serveur stocké
+        serverpub_path = os.path.join(self.config_dir, "server.pub")
+        if os.path.exists(serverpub_path):
+            try:
+                logs("Chargement de la clé du serveur", "info")
+
+                with open(serverpub_path, "rb") as f:
+                    content = f.read()
+
+                self.pubserv_set = True
+                self.keyC = RSA.importKey(content)
+                #Calcul du hash de la clé du serveur
+                self.serverhash = hashlib.sha256(content).hexdigest()
+
+            except Exception as err:
+                logs(f"Erreur lors du chargement de la clé du serveur: {err}", "error")
+
+
+    @impmagic.loader(
+        {'module': 'zpp_color', 'submodule': ['fg', 'attr']},
+    )
+    def init_settings(self):
+        host = input(f"{fg('dark_gray')}host [{fg('cyan')}{self.host}{fg('dark_gray')}]: ")
+        port = input(f"{fg('dark_gray')}port [{fg('cyan')}{self.port}{fg('dark_gray')}]: ")
+        key_size = input(f"{fg('dark_gray')}key_size [{fg('cyan')}{self.key_size}{fg('dark_gray')}]: ")
+        key_otp = input(f"{fg('dark_gray')}key_otp [{fg('cyan')}{self.key_otp}{fg('dark_gray')}]: ")
+        verbose = input(f"{fg('dark_gray')}verbose [{fg('cyan')}{self.verbose}{fg('dark_gray')}]: ")
+        
+        if host:
+            self.config.set('server.host', host)
+
+        if port and isinstance(port, int):
+            self.config.set('server.port', int(port))
+
+        if key_size and isinstance(key_size, int): 
+            self.config.set('server.key_size', int(key_size))
+        
+        if key_otp:
+            self.config.set('server.key_otp', key_otp)
+        
+        if verbose:
+            self.config.set('server.verbose', verbose)
+

znote/core/client/token.py

@@ -0,0 +1,17 @@
+import __main__
+import impmagic
+
+def set_token(token):
+    with open(__main__.settings.token_file, 'w') as f:
+        f.write(token)
+
+
+@impmagic.loader(
+    {'module': 'os'},
+)
+def get_token(token_file):
+    if os.path.exists(token_file):
+        with open(token_file, 'r') as f:
+            return f.read()
+    else:
+        return False

znote/core/config.py

@@ -0,0 +1,73 @@
+import os
+import yaml
+
+class Config:
+    def __init__(self, path):
+        self.path = os.path.expanduser(path)
+        self.data = {}
+        self._load()
+
+    def _load(self):
+        if os.path.exists(self.path):
+            with open(self.path, "r", encoding="utf-8") as f:
+                self.data = yaml.safe_load(f) or {}
+        else:
+            self.data = {}
+
+    def _save(self):
+        directory = os.path.dirname(self.path)
+        if directory:
+            os.makedirs(directory, exist_ok=True)
+
+        with open(self.path, "w", encoding="utf-8") as f:
+            yaml.safe_dump(self.data, f, default_flow_style=False, sort_keys=False)
+
+    def _get_recursive(self, data, keys):
+        if len(keys) == 1:
+            return data.get(keys[0])
+        if keys[0] in data:
+            return self._get_recursive(data[keys[0]], keys[1:])
+        return None
+
+    def _set_recursive(self, data, keys, value):
+        if len(keys) == 1:
+            data[keys[0]] = value
+            return data
+        if keys[0] not in data or not isinstance(data[keys[0]], dict):
+            data[keys[0]] = {}
+        data[keys[0]] = self._set_recursive(data[keys[0]], keys[1:], value)
+        return data
+
+    def get(self, dotted_key, default=None, auto_set=False):
+        keys = dotted_key.split(".")
+        result = self._get_recursive(self.data, keys)
+
+        if result is not None:
+            return result
+
+        if auto_set:
+            self.set(dotted_key, default)
+            return default
+
+        return default
+
+    def set(self, dotted_key, value):
+        keys = dotted_key.split(".")
+        self.data = self._set_recursive(self.data, keys, value)
+        self._save()
+
+    def delete(self, dotted_key):
+        keys = dotted_key.split(".")
+        parent = self._get_recursive(self.data, keys[:-1])
+        if parent and keys[-1] in parent:
+            del parent[keys[-1]]
+            # Nettoie récursivement si parent vide :
+            while keys[:-1]:
+                keys = keys[:-1]
+                parent = self._get_recursive(self.data, keys[:-1])
+                if parent and not parent.get(keys[-1]):
+                    del parent[keys[-1]]
+            self._save()
+
+    def has(self, dotted_key):
+        return self.get(dotted_key) is not None

znote/core/editor.py

@@ -0,0 +1,132 @@
+# -*- coding: utf-8 -*-
+
+import sys
+import asyncio
+import os # Import os for checking file existence
+
+from prompt_toolkit import Application
+from prompt_toolkit.layout import Layout, HSplit, Window
+from prompt_toolkit.widgets import TextArea, Label
+from prompt_toolkit.buffer import Buffer
+from prompt_toolkit.key_binding import KeyBindings
+from prompt_toolkit.filters import Condition
+
+from prompt_toolkit.layout.containers import ConditionalContainer
+from prompt_toolkit.shortcuts import message_dialog
+from prompt_toolkit.layout.controls import BufferControl
+
+from zpp_ManagedFile import ManagedFile
+
+class Editor:
+    def __init__(self, filename, file):
+        # --- État de l'application ---
+        self.file = file # Default filename
+        self.filename = filename
+
+        # --- UI Elements ---
+        self.text_area = TextArea(
+            multiline=True,
+            wrap_lines=True,
+            scrollbar=True,
+            line_numbers=True,
+        )
+        # Initial status bar text will be set after loading
+        self.status_bar = Label(text="") # Start empty, will be set by load_file
+        # --- Layout ---
+        self.layout = Layout(
+            HSplit([
+                self.text_area,
+                self.status_bar,
+            ]),
+        )
+
+        # --- Key Bindings ---
+        self.kb = KeyBindings()
+
+        @self.kb.add("c-q")
+        def _(event):
+            """ Global shortcut to quit """
+            asyncio.get_event_loop().create_task(self.quit())
+
+
+        @self.kb.add("c-s") # Active only in editor mode
+        def _(event):
+            """ Ctrl+S shortcut to save """
+            # Schedule save_file as it's an async method
+            asyncio.get_event_loop().create_task(self.save_file())
+
+        # --- Application ---
+        self.app = Application(
+            layout=self.layout,
+            key_bindings=self.kb,
+            full_screen=True,
+            # style...
+        )
+
+        # --- Initial Actions ---
+        self.load_file(self.file) # Load file content on startup
+        self.app.layout.focus(self.text_area) # Set initial focus
+
+    # --- File Loading ---
+    def load_file(self, filename):
+        """ Loads content from a file into the text area on startup """
+        try:
+            if isinstance(self.file,ManagedFile) and hasattr(self.file,'read'):
+                self.file.seek(0)
+                self.text_area.text = self.file.read()
+                self.status_bar.text = f"Fichier chargé."
+            else:
+                if os.path.exists(filename):
+                    with open(filename, "r", encoding='utf-8') as f:
+                        content = f.read()
+                        self.text_area.text = content
+                    self.status_bar.text = f"Fichier '{filename}' chargé."
+                else:
+                    self.status_bar.text = f"Nouveau fichier '{filename}'."
+        except Exception as e:
+            # Basic error handling for loading
+            self.status_bar.text = f"Erreur de chargement : {e}"
+        # Status messages set here are static until the first save/reset
+
+
+    # --- File Saving ---
+    # save_file must be async because it's awaited in save_and_quit
+    async def save_file(self):
+        """ Saves content to the default file """
+        filename = self.file # Use attribute
+        try:
+            if isinstance(self.file,ManagedFile) and hasattr(self.file,'read'):
+                self.file.seek(0)
+                self.file.truncate(0)
+                self.file.write(self.text_area.text)
+            else:
+                # Synchronous file writing
+                with open(self.file, "w", encoding='utf-8') as f:
+                    f.write(self.text_area.text)
+
+            # Update status bar on success and schedule reset
+            self.status_bar.text = f"Fichier '{filename}' sauvegardé."
+            return True
+        except Exception as e:
+             # Update status bar on error and schedule reset
+            self.status_bar.text = f"Erreur de sauvegarde : {e}"
+            return False
+
+    # --- Quit ---
+    # async because it awaits the message_dialog
+    async def quit(self, event=None):
+        """ Asks for confirmation and quits the application """
+        # Use the message_dialog, which is awaited
+        self.app.exit()
+
+# Entry point
+if __name__ == '__main__':
+    try:
+        file = ManagedFile(mode='a', typefile='stringio')
+        editor = Editor(file)
+        editor.app.run()
+        file.seek(0)
+        print(file.read())
+    except Exception as e:
+        print(f"An unexpected error occurred: {e}")
+        sys.exit(1)

znote/core/gen.py

@@ -0,0 +1,21 @@
+import impmagic
+
+
+@impmagic.loader(
+    {'module': 'string'},
+    {'module': 'secrets'}
+)
+def gen_password(size):
+    alphabet = string.ascii_letters + string.digits + string.punctuation
+    pwd = ''
+    for i in range(size):
+      pwd += ''.join(secrets.choice(alphabet))
+
+    return pwd.encode()
+
+
+@impmagic.loader(
+    {'module': 'uuid','submodule': ['uuid4']}
+)
+def UUID():
+    return str(uuid4()).replace("-","")

znote/core/pack.py

@@ -0,0 +1,72 @@
+import impmagic
+
+
+#Création de la signature d'une donnée
+@impmagic.loader(
+    {'module': 'Crypto.Hash', 'submodule': ['SHA256']},
+    {'module': 'Crypto.Signature','submodule': ['PKCS1_v1_5']}
+)
+def sign(data, privKey):
+    if not isinstance(data, bytes):
+        data = data.encode()
+
+    digest = SHA256.new(data)
+
+    signature = PKCS1_v1_5.new(privKey).sign(digest)
+
+    return signature
+
+
+#Vérification de la signature d'une donnée
+@impmagic.loader(
+    {'module': 'Crypto.Hash', 'submodule': ['SHA256']},
+    {'module': 'Crypto.Signature','submodule': ['PKCS1_v1_5']}
+)
+def verify(data, signature, pubKey):
+    if not isinstance(data, bytes):
+        data = data.encode()
+    
+    digest = SHA256.new(data)
+
+    verifier = PKCS1_v1_5.new(pubKey)
+    return verifier.verify(digest, signature)
+
+
+#Création du package à envoyer
+@impmagic.loader(
+    {'module': 'dill', 'submodule': ['dumps']}
+)
+def pack(data, privKey):
+    #Transformation d'un objet en binaire
+    data = dumps(data)
+
+    #Création de la signature de ce binaire
+    signature = sign(data, privKey)
+
+    return signature+data
+
+
+#Transformation du package en objet
+@impmagic.loader(
+    {'module': 'dill', 'submodule': ['loads']}
+)
+def unpack(data, pubKey):
+    if len(data)>256:
+        #Récupération de la signature dans le bloc de données
+        signature, data = data[0:256], data[256:]
+
+        #Vérifie si la signature est valide et provient du serveur
+        if verify(data, signature, pubKey):
+            try:
+                #Si la signature est valide, conversion du binaire en objet
+                return loads(data)
+            except:
+                print("Pickle invalid")
+                return
+        else:
+            print("Signature check: Bad return")
+            return
+    else:
+        print("Pickle invalid")
+        return
+

znote/core/server/note.py

@@ -0,0 +1,20 @@
+import __main__
+import impmagic
+
+@impmagic.loader(
+    {'module': 'pony.orm', 'submodule': ['db_session', 'select']}
+)
+def get_note(user_id, workspace=None):
+    notes_list = []
+
+    with db_session:
+        query = __main__.settings.orm.Note.select().where("n.creator_id == user_id", {"user_id": user_id})
+
+        if workspace:
+            query = query.where("n.workspace == workspace", {"workspace": workspace})
+
+        result = query[:]
+
+        return result
+
+    return notes_list

znote/core/server/settings.py

@@ -0,0 +1,148 @@
+import impmagic
+
+class Settings:
+    @impmagic.loader(
+        {'module': '__main__'},
+        {'module': 're'},
+        {'module': 'os'},
+        {'module': 'pyotp'},
+        {'module': 'app.display', 'submodule': ['logs']},
+        {'module': 'core.config', 'submodule': ['Config']},
+    )
+    def __init__(self, config_file=None):
+        self.config_dir = os.path.abspath(os.path.expanduser('~/.config/znote'))
+
+        if not os.path.exists(self.config_dir):
+            os.makedirs(self.config_dir, exist_ok=True)
+
+        if not config_file:
+            config_file = os.path.join(self.config_dir, "config.yml")
+            #config_file = "config.toml"
+
+        self.config = Config(config_file)
+
+        self.verbose = self.config.get('server.verbose', default=True, auto_set=True)
+        
+        self.host = self.config.get('server.host', default="127.0.0.1", auto_set=True)
+        self.port = self.config.get('server.port', default=40017, auto_set=True)
+        self.key_size = self.config.get('server.key_size', default=2048, auto_set=True)
+        self.key_otp = self.config.get('server.key_otp', default='JBSWY3DPEHPK3PXP', auto_set=True)
+
+        #Initialisation de l'OTP pour la connexion initiale
+        if not re.match(r'^[A-Z0-9]{16}$', self.key_otp):
+            print("Clé OTP invalide. Passage sur la clé par défaut", "warning")
+            self.key_otp = 'JBSWY3DPEHPK3PXP'
+        self.totp = pyotp.TOTP(self.key_otp)
+
+        self.data_dir = self.config.get('server.data_dir', default=None, auto_set=False)
+
+        if not self.data_dir:
+            self.data_dir = os.path.join(self.config_dir, "znote.db")
+
+
+    @impmagic.loader(
+        {'module': '__main__'},
+        {'module': 'os'},
+        {'module': 'hashlib'},
+        {'module': 'Crypto.PublicKey', 'submodule': ['RSA']},
+        {'module': 'Crypto', 'submodule': ['Random']},
+        {'module': 'app.display', 'submodule': ['logs']},
+    )
+    def load_key(self):
+        privkey_path = os.path.join(self.config_dir, "server.key")
+        pubkey_path = os.path.join(self.config_dir, "server.pem")
+
+        if not os.path.exists(privkey_path) or not os.path.exists(pubkey_path):
+            try:
+                #Génération de la paire de clé pour les échanges avec le client
+                logs("Création de la paire de clé", "info")
+                rng = Random.new().read
+                rsa_key = RSA.generate(self.key_size, rng)
+                rsa_priv = rsa_key.exportKey("PEM")
+
+                self.PrivKey = rsa_key.exportKey('PEM', pkcs=1)
+
+                with open(privkey_path, "wb") as f:
+                    f.write(self.PrivKey)
+
+                key_pub = rsa_key.publickey()
+                self.PubKey = key_pub.exportKey("PEM")
+                
+                with open(pubkey_path, "wb") as f:
+                    f.write(self.PubKey)
+                
+                logs("Paire de clé créée", "success")
+
+            except Exception as err:
+                logs(f"Erreur lors de la création de la paire de clé: {err}", "error")
+                exit()
+
+        else:
+            try:
+                logs("Chargement de la paire de clé", "info")
+                
+                with open(privkey_path, "rb") as f:
+                    self.PrivKey = f.read()
+                
+                with open(pubkey_path, "rb") as f:
+                    self.PubKey = f.read()
+                
+                logs("Paire de clé chargée", "success")
+
+            except Exception as err:
+                logs(f"Erreur lors du chargement de la paire de clé: {err}", "error")
+                exit()
+
+        #Calcul du hash de la clé du client
+        self.serverhash = hashlib.sha256(self.PubKey).hexdigest()
+
+
+    @impmagic.loader(
+        {'module': '__main__'},
+        {'module': 'os'},
+        {'module': 'model', 'submodule': ['models']},
+        {'module': 'pony.orm','submodule': ['Database']},
+        {'module': 'app.display', 'submodule': ['logs']},
+    )
+    def load_db(self):
+        try:
+            self.orm = Database()
+            models.Table(self.orm)
+            self.orm.bind(provider='sqlite', filename=self.data_dir, create_db=True)
+            self.orm.generate_mapping(create_tables=True)
+
+            logs("Base de données initialisée", "success")
+
+        except Exception as err:
+            logs(f"Erreur lors de l'initialisation de la base de données: {err}", "error")
+            exit()
+
+
+    @impmagic.loader(
+        {'module': 'zpp_color', 'submodule': ['fg', 'attr']},
+    )
+    def init_settings(self):
+        host = input(f"{fg('dark_gray')}host [{fg('cyan')}{self.host}{fg('dark_gray')}]: ")
+        port = input(f"{fg('dark_gray')}port [{fg('cyan')}{self.port}{fg('dark_gray')}]: ")
+        key_size = input(f"{fg('dark_gray')}key_size [{fg('cyan')}{self.key_size}{fg('dark_gray')}]: ")
+        key_otp = input(f"{fg('dark_gray')}key_otp [{fg('cyan')}{self.key_otp}{fg('dark_gray')}]: ")
+        data_dir = input(f"{fg('dark_gray')}data_dir [{fg('cyan')}{self.data_dir}{fg('dark_gray')}]: ")
+        verbose = input(f"{fg('dark_gray')}verbose [{fg('cyan')}{self.verbose}{fg('dark_gray')}]: ")
+
+        if host:
+            self.config.set('server.host', host)
+
+        if port and isinstance(port, int):
+            self.config.set('server.port', int(port))
+
+        if key_size and isinstance(key_size, int): 
+            self.config.set('server.key_size', int(key_size))
+        
+        if key_otp:
+            self.config.set('server.key_otp', key_otp)
+        
+        if data_dir:
+            self.config.set('server.data_dir', data_dir)
+        
+        if verbose:
+            self.config.set('server.verbose', verbose)