dprojectstools 0.0.7__py3-none-any.whl

dprojectstools/__init__.py

@@ -0,0 +1,4 @@
+# xmenu/__init__.py
+#from .commands import command, example, CommandsManager
+#from .secrets import SecretsManager
+#from .crypto import aes_encrypt, aes_decrypt

dprojectstools/backups/__init__.py

@@ -0,0 +1,3 @@
+# xmenu/__init__.py
+from .restic import Restic
+

dprojectstools/backups/restic.py

@@ -0,0 +1,62 @@
+import os
+import subprocess
+from typing import Annotated
+from ..commands import command, CommandsManager
+
+class Restic:
+
+    # vars
+    _repository: str
+    _repository_password: str
+    _aws_access_key_id: str
+    _aws_secret_access_key: str
+    
+    # ctor
+    def __init__(self, repository, repository_password, aws_access_key_id, aws_secret_access_key):
+        self._repository = repository
+        self._repository_password = repository_password
+        self._aws_access_key_id = aws_access_key_id
+        self._aws_secret_access_key = aws_secret_access_key
+
+    # commands
+    @command("Init repository", index = 1)
+    def init(self):
+        return subprocess.run("restic init", env = self._getEnv())
+
+    @command("Backup ", index = 10)
+    def backup(self):
+        return subprocess.run("restic backup ./data ./data2 --verbose", env = self._getEnv())
+
+    @command("List snapshots ", index = 20)
+    def snapshots_list(self):
+        return subprocess.run("restic snapshots", env = self._getEnv())
+    
+    @command("List snapshot contents ")
+    def snapshots_contents(self, 
+            id: Annotated[str, "ID"]
+        ):
+        return subprocess.run("restic ls --long {0}".format(id), env = self._getEnv())
+
+    @command("Restore ")
+    def snapshots_restore(self, 
+            id: Annotated[str, "ID"]
+        ):
+        return subprocess.run("restic restore {0} --target ./restore --verbose".format(id), env = self._getEnv())
+
+    # methods
+    def exec(self, argv):
+        commandsManager = CommandsManager()
+        commandsManager.register(self)
+        return commandsManager.execute(argv)
+    
+    # utils
+    def _getEnv(self):
+        myenv = os.environ.copy()
+        myenv['RESTIC_REPOSITORY'] = self._repository
+        myenv['RESTIC_PASSWORD'] = self._repository_password
+        myenv["AWS_ACCESS_KEY_ID"] = self._aws_access_key_id
+        myenv['AWS_SECRET_ACCESS_KEY'] = self._aws_secret_access_key
+        return myenv
+    
+
+

dprojectstools/commands/__init__.py

@@ -0,0 +1,3 @@
+# xmenu/__init__.py
+from .commands import command, example, CommandsManager
+

dprojectstools/commands/commands.py

@@ -0,0 +1,311 @@
+import inspect
+import types
+from typing import List, get_type_hints
+from dataclasses import dataclass
+
+# global vars
+order = 0
+SEQUENCE_COLOR_RED = "\033[31m"
+SEQUENCE_COLOR_GREEN = "\033[32m"
+SEQUENCE_COLOR_GREEN_DARK = "\033[2;32m"
+SEQUENCE_COLOR_GRAY_LIGHT = "\033[38;5;250m"
+SEQUENCE_COLOR_GRAY_MEDIUM = "\033[38;5;244m"
+SEQUENCE_COLOR_GRAY_DARK = "\033[38;5;238m"
+SEQUENCE_RESET = "\033[0m"
+ 
+
+# decorator (las funciones con este decorator, se catalogaran en el CommandsManager)
+def command(title: str, index: int = 0):
+    def decorator(func):
+        global order
+        order += 1
+        aux = func.__name__ .split("_")
+        setattr(func, "title", title) 
+        setattr(func, "order", order) 
+        setattr(func, "index", index) 
+        return func
+    return decorator
+
+
+# decorator
+def example(example: str):
+    def decorator(func):
+        setattr(func, "example", example) 
+        return func
+    return decorator
+
+
+# data classes
+@dataclass
+class CommandArgument:
+    name: str
+    title: str
+    required: bool
+    type: str
+    default: any
+
+# data classes
+@dataclass
+class Command:
+    name: List[str]
+    title: str
+    arguments: List[CommandArgument]
+    instance: object
+    func: any
+    order:int
+    index: int
+
+
+# Manager
+class CommandsManager:
+
+    def __init__(self, title="", indent = 0):
+        # ctor
+        self._title = title
+        self._indent = indent
+        self._name = ""
+        self._argv = []
+        self._commands = []
+        self.exitCode = 0
+
+    # methods
+    def register(self, instance=None, prefix = ""):
+        if instance is None:
+            for name, obj in inspect.getmembers(__import__('__main__')):
+                if inspect.isfunction(obj) and name.startswith(prefix) and hasattr(obj, "title"):
+                    self.registerFunction(None, obj, prefix)
+        else:
+            for name, obj in inspect.getmembers(type(instance), predicate=inspect.isfunction):
+                if inspect.isfunction(obj) and name.startswith(prefix) and hasattr(obj, "title"):
+                    self.registerFunction(instance, obj, prefix)
+
+    def registerFunction(self, instance, func, prefix = ""):
+        # carga los Commands partiendo de las funciones cargadas en memoria, que empiezan con un determinado prefijo
+        func_name = func.__name__
+        command_name = func_name[len(prefix):].split("_")
+        command_title = getattr(func, "title")
+        command_order = getattr(func, "order")
+        command_index = getattr(func, "index")
+        command_arguments = []        
+        for param_name, param in inspect.signature(func).parameters.items():
+            if param_name == "self":
+                continue
+            # argument name
+            command_argument_name = param_name
+            # argument title
+            command_argument_title = ""
+            if hasattr(param.annotation, "__metadata__"):
+                command_argument_title = param.annotation.__metadata__[0]
+            # argument title
+            command_argument_required = (param.default == inspect.Parameter.empty)
+            # argument type
+            command_argument_type = ""
+            if hasattr(param.annotation, "__metadata__"):
+                command_argument_type = param.annotation.__origin__.__name__
+            # argument default
+            command_argument_default = None
+            if param.default != inspect.Parameter.empty:
+                command_argument_default = param.default
+            # crea CommandArgument
+            command_argument = CommandArgument(command_argument_name, command_argument_title, command_argument_required, command_argument_type, command_argument_default)
+            command_arguments.append(command_argument)
+        # crea Comand
+        command = Command(name=command_name, title=command_title, arguments=command_arguments, instance=instance, func=func, order=command_order, index=command_index)
+        # añade a la lista de Commands
+        self._commands.append(command)
+
+    def sort(self):
+        # ordena los commands por order de declaracion de la funcion
+        self._commands.sort(key=lambda x: x.order)
+
+        # asigna indices
+        command_ant = None
+        index = 0
+        for command in self._commands:
+            if command.index != 0:
+                index = command.index
+            elif command_ant != None and command_ant.name[0] != command.name[0]:
+                index  = int((index + 10) / 10) * 10
+            else: 
+                index += 1
+            command.index = index
+            command_ant = command        
+    
+        self._commands.sort(key=lambda x: x.index)
+
+    def showMenu(self):
+        # sort
+        self.sort()
+        # title
+        if not self._title == "":
+            print(self._title)
+            print("*********")
+        # menu
+        indent = self._indent * "    "
+        while True:
+            # show menu
+            print(indent + "Select an option:")
+            print(indent + "=================")
+            command_ant = None
+            for command in self._commands:
+                if command_ant == None and command.index > 1:
+                    print(indent + f"   : ")
+                if command_ant != None and command_ant.name[0] != command.name[0]:
+                    print(indent + f"   : ")
+                print(indent + f"{command.index:2} : {command.title}")
+                command_ant = command
+            print(indent + f"   : ")
+            # read option
+            command_to_execute = None
+            while command_to_execute == None:
+                opcion = input(f" ? : ")
+                if opcion == "":
+                    return 0
+                try:
+                    opcion_index =int(opcion)
+                    for command in self._commands:
+                        if command.index == opcion_index:
+                            command_to_execute = command
+                            break
+                except:
+                    pass
+                if command_to_execute == None:
+                    print(indent + f"{SEQUENCE_COLOR_RED}     índice no válido: {opcion}{SEQUENCE_RESET}")
+            # prepara argumentos
+            print()
+            exec_args = {}
+            errors = False
+            if len(command_to_execute.arguments) > 0:
+                for argument in command_to_execute.arguments:
+                    argument_attributes = []
+                    if argument.default != None:
+                        argument_attributes.append(f"default es '{argument.default}'")
+                    if argument.required:
+                        argument_attributes.append(f"*")
+                    argument_value = input(f"     {argument.title}{"" if len(argument_attributes) == 0 else f" ({" ".join(argument_attributes)})"}: ").strip()
+                    # valor por defecto
+                    if not argument_value and argument.default != None:
+                        argument_value = argument.default
+                    # valida si es requerido
+                    if argument.required:
+                        if argument_value == "":
+                            print(indent + f"{SEQUENCE_COLOR_RED}     Error: argumento requerido: '{argument.title}'{SEQUENCE_RESET}")
+                            errors = True
+                            break
+                    # convierte el tipo
+                    try:
+                        if argument.type == "int":
+                            argument_value = int(argument_value)
+                        elif argument.type == "float":
+                            argument_value = float(argument_value)
+                        elif argument.type == "List":
+                            argument_value = argument_value.split(",")
+                    except:
+                        print(indent + f"{SEQUENCE_COLOR_RED}     Error: el argumento '{argument.name}' no se ha podido convertir al tipo '{argument.type}': {argument_value}{SEQUENCE_RESET}")
+                        errors = True
+                        break
+                    # set
+                    exec_args[argument.name] = argument_value; 
+            # exec
+            if not errors:
+                # invoke
+                if not command_to_execute.instance is None:
+                    func_bounded = types.MethodType(command_to_execute.func, command_to_execute.instance)
+                    result = func_bounded(**exec_args)
+                else:
+                    result = command_to_execute.func(**exec_args)
+            # empty line
+            print()
+    
+    def showHelp(self):
+        print(f"usage: {self._name} [<command> [<args>]]")
+        print("")
+        print("Commands:")
+        for command in self._commands:
+            line = "  "
+            line += "Adasd"
+            args = []
+            for argument in command.arguments:
+                args.append(f"--{argument.name}")
+                args.append(f"{SEQUENCE_COLOR_GRAY_MEDIUM}<{argument.title}>{SEQUENCE_RESET}")
+            print(f"  {" ".join(command.name):10} {" ".join(args)} {SEQUENCE_COLOR_GREEN_DARK}# {command.title}{SEQUENCE_RESET}")
+             
+    def execute(self, argv):
+        # init 
+        self._name = argv[0]
+        self._argv = argv
+        # ejecuta el comando que toque, segun self._argv
+        if len(self._argv)==1:
+            self.showMenu()
+            return
+        if len(self._argv)==2 and (self._argv[1] == "--help" or self._argv[1] == "-h"):
+            self.showHelp()
+            return
+        # busca el commando a ejecutar
+        command_to_execute = None
+        for command in self._commands:
+            if len(command.name) <= len(argv) - 1:
+                if command.name == argv[1:len(command.name)+1]:
+                    command_to_execute = command
+                    break
+            if command_to_execute:
+                break
+        # si no se ha encontrado, muestra el mesnaje de error
+        if command_to_execute == None:
+            print(f"error: no se ha encontrado el comando")
+            return -1
+        # ejecuta el comando
+        command_args = argv[len(command_to_execute.name)+1:]
+        command_args_dict = {}
+        command_args_errors = False
+        for i in range(0, len(command_args), 2): 
+            if command_args[i].startswith('--'):
+                key = command_args[i][2:]  
+                value = command_args[i + 1] if i + 1 < len(command_args) else None
+                command_args_dict[key] = value
+        # valida que no sobre ningun argumento 
+        for key in command_args_dict.keys():
+            if not key in [argument.name for argument in command_to_execute.arguments]:
+                print(f"error: argumento inválido: --{key}")
+                command_args_errors = True
+        # aañade defaults
+        for argument in command.arguments:
+            if not argument.name in command_args_dict:
+                if argument.default != None:
+                    command_args_dict[argument.name] = argument.default
+        # valida que no falte ningun argumento
+        for argument in command.arguments:
+            if not argument.name in command_args_dict:
+                print(f"error: argumento obligatorio: --{argument.name}")
+                command_args_errors = True
+        # valida que el tipo de argumentos sea correcto
+        if not command_args_errors:
+            for argument in command.arguments:
+                argument_value = command_args_dict[argument.name]
+                try:
+                    if argument.type == "int":
+                        argument_value = int(argument_value)
+                    elif argument.type == "float":
+                        argument_value = float(argument_value)
+                    elif argument.type == "List":
+                        argument_value = argument_value.split(",")
+                    command_args_dict[argument.name] = argument_value
+                except:
+                    print(f"{SEQUENCE_COLOR_RED}error: el argumento '{argument.name}' no se ha podido convertir al tipo '{argument.type}': {argument_value}{SEQUENCE_RESET}")
+                    command_args_errors = True
+                    break
+        # si hay errores
+        if command_args_errors:
+            return -1
+        # invoke
+        if not command_to_execute.instance is None:
+            func_bounded = types.MethodType(command_to_execute.func, command_to_execute.instance)
+            return func_bounded(**command_args_dict)
+        else:
+            return command_to_execute.func(**command_args_dict)
+
+        
+
+    
+    
+

dprojectstools/crypto/__init__.py

@@ -0,0 +1 @@
+from .aes import aes_encrypt, aes_decrypt, password_generate

dprojectstools/crypto/aes.py

@@ -0,0 +1,130 @@
+from pathlib import Path
+from cryptography.fernet import Fernet # pip install cryptography
+from cryptography.hazmat.primitives.kdf.pbkdf2 import PBKDF2HMAC
+from cryptography.hazmat.primitives.hashes import SHA256
+from cryptography.hazmat.primitives import hashes
+from cryptography.hazmat.primitives import padding
+from cryptography.hazmat.backends import default_backend
+from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
+import base64
+import io
+import os
+import struct
+import random
+import hashlib
+import random
+import string
+
+# utils
+def password_generate(min=10, max=32):
+    length = random.randint(min, max)
+    characters = string.ascii_letters + string.digits + string.punctuation
+    password = ''.join(random.choice(characters) for i in range(length))
+    return password
+
+# utils
+def aes_encrypt(text: str, password: str):
+    iterations = 0
+    saltLength = 16
+    ivLength = 16
+    blockSize = 16
+    paddingMode = "PKCS7"
+    cipherMode = "CBC"
+    keySize = 32
+    encoding = "base64"
+    separator = ','
+    version = ""
+    fold = 76
+    # salt
+    salt = os.urandom(saltLength)
+    # iterations
+    iterations = int(random.uniform(50000, 50000))
+    # derive key
+    key = hashlib.pbkdf2_hmac(
+        hash_name='sha256',           # HMAC-SHA256
+        password=password.encode(),   # Password as bytes
+        salt=salt,                    # Salt as bytes
+        iterations=iterations,        # Iteration count
+        dklen=keySize                 # Length of the derived key
+    )
+    # iv
+    iv = os.urandom(ivLength)
+    # ms
+    body_ms = io.BytesIO();
+    # write iv
+    body_ms.write(iv)
+    # write salt
+    body_ms.write(salt)
+    # write iterations
+    body_ms.write(bytearray(iterations.to_bytes(4, byteorder='little')))    
+    # cipher
+    cipher = Cipher(algorithms.AES(key), modes.CBC(iv), backend=default_backend())
+    # encript
+    encryptor = cipher.encryptor()
+    # Pad the plaintext to a multiple of 16 bytes
+    padder = padding.PKCS7(blockSize * 8).padder()
+    padded_plaintext = padder.update(base64.b64encode(salt) + text.encode()) + padder.finalize()
+    #print(padded_plaintext)
+    # crypt
+    ciphertext = encryptor.update(padded_plaintext) + encryptor.finalize()
+    body_ms.write(ciphertext)
+    # read
+    body_ms.seek(0)
+    body = body_ms.read()
+    body_ms.close()
+    # result
+    result = "aes:" + separator + base64.b64encode(body).decode()
+    # fold
+    result = "\n".join(
+        result[i:i + fold] for i in range(0, len(result), fold)
+    )
+    # return    
+    return result
+    
+def aes_decrypt(text: str, password: str):
+    iterations = 0
+    saltLength = 16
+    ivLength = 16
+    blockSize = 16
+    paddingMode = "PKCS7"
+    cipherMode = "CBC"
+    keySize = 32
+    encoding = "base64"
+    separator = ','
+    version = ""
+    # header
+    header = text[:text.index(",")]
+    # body
+    body = text[text.index(",")+1:]
+    body_bytes = base64.b64decode(body)
+    stream = io.BytesIO(body_bytes)
+    # read iv
+    iv = stream.read(ivLength)
+    # read salt
+    salt = stream.read(saltLength)
+    # read iterations
+    iterations = struct.unpack('<I', stream.read(4))[0]
+    # derive key
+    key = hashlib.pbkdf2_hmac(
+        hash_name='sha256',           # HMAC-SHA256
+        password=password.encode(),   # Password as bytes
+        salt=salt,                    # Salt as bytes
+        iterations=iterations,        # Iteration count
+        dklen=keySize              # Length of the derived key
+    )
+    # cipher
+    cipher = Cipher(algorithms.AES(key), modes.CBC(iv), backend=default_backend())
+    # decryptor
+    decryptor = cipher.decryptor()
+    # decrypt
+    decrypted_result = decryptor.update(stream.read()) + decryptor.finalize()
+    # remove padding
+    unpadder = padding.PKCS7(algorithms.AES.block_size).unpadder()
+    decrypted_result = unpadder.update(decrypted_result) + unpadder.finalize()
+    # decode
+    result = decrypted_result.decode()
+    # skip salt
+    result = result[int(saltLength*1.5):]
+    # return    
+    return result
+    

dprojectstools/secrets/__init__.py

@@ -0,0 +1 @@
+from .secrets import SecretsManager

dprojectstools/secrets/secrets.py

@@ -0,0 +1,109 @@
+from pathlib import Path
+import os
+import json
+import keyring
+from typing import Annotated
+from ..commands import command, CommandsManager
+from ..crypto import aes_decrypt, aes_encrypt, password_generate
+
+# consts
+KEYRING_APP = "dprojectstools"
+
+# class
+class SecretsManager():
+
+
+    # vars
+    _password = None
+    _path = ""
+    _dict = {}
+    
+
+    # ctr
+    def __init__(self, name, password = "keyring:"):
+        folder = Path(os.path.join(Path.home(), ".secrets"))
+        folder.mkdir(parents=True, exist_ok=True)
+        self._path = Path(folder, name + ".json")
+        if not password == "":
+            if password.startswith("keyring:"):
+                username = password[password.index(":") + 1:]
+                if username == "":
+                    username = os.getlogin()
+                password = keyring.get_password(KEYRING_APP, username)
+                if password is None:
+                    password = password_generate()
+                    keyring.set_password(KEYRING_APP, username, password)
+            self._password = password
+            self._path = Path(folder, name + ".json.aes")
+        self._load()
+
+
+    # methods
+    def get(self, name):
+        value = self._dict.get(name)
+        if value is None:
+            value = self.set(name, value)
+        return str(value)
+    
+    def keys(self):
+        return self._dict.keys()
+    
+    def set(self, name, value=None):
+        if value is None:
+            value = input("Enter secret '{0}' value: ".format(name))
+        self._dict[name] = str(value)
+        self._save()
+        return value
+
+    def delete(self, name):
+        del self._dict[name]
+        self._save()
+
+
+    # methods
+    def _load(self):
+        if os.path.isfile(self._path):
+            with open(self._path, "r") as file:
+                text = file.read()
+                if not self._password is None:
+                    text = aes_decrypt(text, self._password);
+                self._dict = json.loads(text)
+        pass
+
+    def _save(self):
+        text = json.dumps(self._dict, indent=4)
+        if not self._password is None:
+            text = aes_encrypt(text, self._password);
+        with open(self._path, "w") as file:
+            file.write(text)
+    
+    
+    # commands
+    @command("List secrets", index = 90)
+    def secrets_list(self):
+        for key in self.keys():
+            print("{0}: {1}".format(key, self.get(key)))
+    @command("Set secret")
+    def secrets_set(self, 
+            name: Annotated[str, "Name"],
+            value: Annotated[str, "Value"]
+        ):
+        self.set(name, value)
+    @command("Get secret")
+    def secrets_get(self, 
+            name: Annotated[str, "Name"]
+        ):
+        value = self.get(name)
+        print(value)
+    @command("Del secret")
+    def secrets_delete(self, 
+            name: Annotated[str, "Name"]
+        ):
+        self.delete(name)
+
+    # methods
+    def exec(self, argv):
+        commandsManager = CommandsManager()
+        commandsManager.register(self)
+        return commandsManager.execute(argv)        
+

dprojectstools-0.0.7.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Marc Delòs Poch
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

dprojectstools-0.0.7.dist-info/METADATA

@@ -0,0 +1,16 @@
+Metadata-Version: 2.2
+Name: dprojectstools
+Version: 0.0.7
+Summary: A set of development tools
+Author-email: Marc Delos <marcdp@dprojects.com>
+Project-URL: Homepage, https://github.com/marcdp/dprojectstools
+Project-URL: Issues, https://github.com/marcdp/dprojectstools/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+# dprojectstools
+A set of development tools

dprojectstools-0.0.7.dist-info/RECORD

@@ -0,0 +1,14 @@
+dprojectstools/__init__.py,sha256=_RjYtKMfjjsymn9dV5noeotczZkhk928Fxo9h675EOE,164
+dprojectstools/backups/__init__.py,sha256=NV15vstbHrGns8LgKWYA3ssnjjjlluU-s29gI7APmlg,51
+dprojectstools/backups/restic.py,sha256=Hjyzt6FXf9FtJb2YdFzahn9JeHOyD93GlqiE420nO9o,2023
+dprojectstools/commands/__init__.py,sha256=VZmFrfX6F6NleK3z4pIA6GmuM9pygQxUOEXleVqJB3E,80
+dprojectstools/commands/commands.py,sha256=UDU41t6oNRxFTrK9I8YqWI5UZD3_w1WKcDDjvaZWE18,12882
+dprojectstools/crypto/__init__.py,sha256=CAPzDNcUXRa9zBM5CKzcMjtkuOCQojhaKp4GJ0JtcqE,62
+dprojectstools/crypto/aes.py,sha256=qTJ-eHzRUB8UalnqJPkG62k3oxuy76QiEoZBFdSMpic,4186
+dprojectstools/secrets/__init__.py,sha256=1-v3UV1A-FP_o1vcccii1T1wSXsj6nGWxWvxWzFmdBE,37
+dprojectstools/secrets/secrets.py,sha256=Acl6nargoLesu1ZQ2zG6-ycLomTNowzyees2LQ5ILSs,3175
+dprojectstools-0.0.7.dist-info/LICENSE,sha256=wog66J88bXIo-u2Axc3ia6UllVLpcW-TAsIoFX9DAr4,1094
+dprojectstools-0.0.7.dist-info/METADATA,sha256=MXduNnTIp_PX0Y49566BO41S2hc7FvWRLG81VelYAEs,567
+dprojectstools-0.0.7.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+dprojectstools-0.0.7.dist-info/top_level.txt,sha256=Rfed2TC6kuHWz0giVwl_Sc-ffhFooCeD4rlP84wr0hw,15
+dprojectstools-0.0.7.dist-info/RECORD,,

dprojectstools-0.0.7.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (75.8.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

dprojectstools-0.0.7.dist-info/top_level.txt

@@ -0,0 +1 @@
+dprojectstools