developer-assistant 0.2.0__tar.gz

developer_assistant-0.2.0/DA/Interface.py

@@ -0,0 +1,241 @@
+import os, sys
+import time
+import platform
+import subprocess
+import shutil
+from pathlib import Path
+from termcolor import colored
+from rich.progress import track
+from rich.console import Console
+from rich.markdown import Markdown
+
+from DA.Modules.projects_manager import ProjectsManager
+from DA.Modules.config_manager import ConfigManager
+from DA.Modules.opener import Opener
+from importlib import resources
+
+class Interface:
+    def __init__(self, color="light_blue"):
+        self.version = "0.2.0"
+        title = f"DA - {self.version}"
+
+        if platform.system() == "Windows":
+            os.system(f'title {title}')
+        else:
+            print(f'\33]0;{title}\a', end='', flush=True)
+
+        self.config = ConfigManager('memory.ini')
+
+        first_run = False
+        if not self.config.memory_ini.exists():
+            self.local_init()
+            self.config = ConfigManager('memory.ini')
+            first_run = True
+
+        self.projects_manager = ProjectsManager()
+
+        self.memory = self.config.load_memory()
+        self.color = self.memory.get('color') or color
+        
+        #==Reusables==
+        self.header = (colored(" Developer Assistant ", f"{self.color}"))
+        self.clear_screen = 'cls' if platform.system() == 'Windows' else 'clear'
+        self.user_path = os.environ.get('USERPROFILE') or os.environ.get('HOME', 'User')
+        
+        if first_run:
+            self.intro()
+
+        self.load()
+    
+    def load(self):
+        temp_log = Path(__file__).parent / "CHANGELOG.tmp"
+
+        if os.path.exists(temp_log):
+            while True:
+                os.system(self.clear_screen)
+                print(colored(f"Temporary changelog detected in:\n{temp_log}\n", "yellow"))
+                print(colored("D", "light_red") + "elete or " + colored("K", "light_red") + "eep?\n")
+                choice = input(f"{self.user_path}> ").lower()
+                if choice == "d":
+                    os.remove(temp_log)
+                    break
+                elif choice == "k":
+                    break
+                else:
+                    print(colored("\nPlease make a valid choice.", "light_red"))
+                    time.sleep(1.5)
+
+        os.system(self.clear_screen)
+        message = (colored("Developer Assistant Ver. ", attrs=["bold"]) + (colored(self.version, f"{self.color}", attrs=["bold"])))
+        status = (colored("Loading, please wait... ", attrs=["blink"]))
+        
+        print(message.center(85))
+        print("")
+        print(status.center(73))
+        
+        for i in track(range(20)):
+            time.sleep(0.10)
+        
+        self.menu()
+        
+    def menu(self):
+        while True:
+            os.system(self.clear_screen)
+            print("Main menu")
+            print(self.header.center(127, "="))
+            print("\nE. Exit\n")
+            print("1. Projects")
+            print("2. Settings\n")
+
+            choice = input(f"{self.user_path}> ").strip()
+
+            if choice.lower() == "e":
+                os.system(self.clear_screen)
+                print(self.header.center(127, "="))
+                print("Bye!")
+                time.sleep(2)
+                raise SystemExit
+
+            elif choice == "1":
+                self.projects()
+
+            elif choice == "2":
+                self.settings()
+            else:
+                print("")
+                print(colored("Unknown option...", "light_red", attrs=["blink"]))
+                time.sleep(2)
+        
+    def projects(self):
+        config = ConfigManager('memory.ini')
+        self.memory = config.load_memory()
+        while True:
+            os.system(self.clear_screen)
+            print("Main menu / Projects")
+            print(self.header.center(127, "="))
+            print("E. Back\n")
+            print(colored("1. The last project:", attrs=["underline"]))
+            print(colored(self.memory.get('last_project'), f"{self.color}"))
+            print("\n2. Start a new project.\n")
+            print(colored("Continue a project.", attrs=["underline"]))
+            print("Pinned:")
+            print("a. " + colored(self.memory.get('pinned_project'), f"{self.color}"))
+            print("b. " + colored(self.memory.get('pinned_project1'), f"{self.color}"))
+            print("c. " + colored(self.memory.get('pinned_project2'), f"{self.color}"))
+
+            print("")
+            choice = input(f"{self.user_path}> ").strip()
+
+            if choice.lower() == "e":
+                return
+
+            elif choice == "1":
+                project = self.memory.get('last_project')
+                if not project:
+                    print(colored("\nLast project has not been defined...", "light_red", attrs=["blink"]))
+                    time.sleep(2)
+                else:
+                    self.projects_manager.load_project(f"{project}")
+
+            elif choice == "2":
+                self.projects_manager.new_project()
+
+            elif choice.lower() in ("a", "b", "c"):
+                #==If the pinned project is empty, return an error message==
+                options_map = {
+                    'a': 'pinned_project',
+                    'b': 'pinned_project1',
+                    'c': 'pinned_project2'
+                }
+                key = options_map.get(choice.lower())
+                project_name = self.memory.get(key)
+                if project_name == "":
+                    print("")
+                    print(colored(f"Project '{choice}' has not been defined...", "light_red", attrs=["blink"]))
+                    time.sleep(2)
+                else:
+                    project = self.memory.get(key)
+                    self.projects_manager.load_project(f"{project}")
+
+            else:
+                print("")
+                print(colored("Unknown option...", "light_red", attrs=["blink"]))
+                time.sleep(2)
+    
+    def settings(self):
+        while True:
+            os.system(self.clear_screen)
+            print("Main menu / Settings")
+            print(self.header.center(127, "="))
+            print("E. Back\n")
+            print(colored("Configuration options", attrs=["underline"]))
+            print("1. Edit pinned projects [WIP]")
+            print("2. Change program's color [WIP]\n")
+            print(colored("Other options", attrs=["underline"]))
+            print("3. Open memory.ini manually")
+            print("4. Open the Projects folder")
+            print("5. Open the Templates folder\n")
+
+            choice = input(f"{self.user_path}> ").strip()
+
+            if choice.lower() == "e":
+                return
+            elif choice == "1":
+                pass
+            elif choice == "2":
+                pass
+            elif choice == "3":
+                Opener.open(self.config.memory_ini)
+            elif choice == "4":
+                Opener.open(self.config.projects_folder)
+            elif choice == "5":
+                Opener.open(self.config.templates_folder)
+            else:
+                print("")
+                print(colored("Unknown option...", "light_red", attrs=["blink"]))
+                time.sleep(2)
+
+    def local_init(self):
+        default_files = resources.files("DA.default")
+        dest = self.config.memory_ini
+
+        for item in default_files.iterdir():
+            if item.name == "default-memory.ini":
+                shutil.copy(item, dest)
+
+        self.config.projects_folder.mkdir(parents=True, exist_ok=True)
+        # Add Test-Project
+        dest = self.config.projects_folder
+        for item in default_files.iterdir():
+            if item.name == "Test-Project.ini":
+                shutil.copy(item, dest)
+
+    def intro(self):
+        os.system(self.clear_screen)
+        print(colored("Welcome to the Developer Assistant\n", f"{self.color}", attrs=["bold"]))
+        print("Here's everything you need to get started:\n")
+
+        time.sleep(2)
+
+        readme_content = resources.files("DA").joinpath("intro.md").read_text()
+
+        MARKDOWN = readme_content
+        console = Console()
+        md = Markdown(MARKDOWN)
+        console.print(md)
+
+        input("\nContinue..." + colored("[Enter]", f"{self.color}"))
+
+        self.menu()
+
+def main():
+    try:
+        app = Interface()
+        app.run()
+    except KeyboardInterrupt:
+        print("\n\n" + colored("Execution interrupted by the user. Exiting...", "magenta", attrs=["bold"]))
+        time.sleep(2)
+        sys.exit(0)
+
+if __name__ == "__main__":
+    main()

developer_assistant-0.2.0/DA/Modules/config_manager.py

@@ -0,0 +1,126 @@
+import configparser
+from pathlib import Path
+import shutil
+import time
+
+from platformdirs import user_config_path
+
+from importlib import resources
+
+class ConfigManager:
+    def __init__(self, config_file):
+        self.config = configparser.ConfigParser()
+        
+        #==Path setup==
+        self.internal_dir = Path(__file__).resolve().parents[1]
+        self.global_dir = user_config_path("da-ui")
+        self.global_dir.mkdir(parents=True, exist_ok=True)
+        
+        #==Specific targets==
+        self.memory_ini = self.global_dir / 'memory.ini'
+        self.projects_folder = self.global_dir / "Projects"
+        self.templates_folder = self.global_dir / "Templates"
+        self.new_project_ini = self.projects_folder / config_file
+
+        self.migrate_old_data()
+
+        #==Update last_project in memory.ini==
+        self.update_last_project = Path(config_file).stem
+
+        self.config.read(self.memory_ini)
+
+    def migrate_old_data(self):
+        old_memory = self.internal_dir / "memory.ini"
+        old_projects = self.internal_dir / "Projects"
+
+        if old_memory.exists() and not self.memory_ini.exists():
+            shutil.move(str(old_memory), str(self.memory_ini))
+            print(f"Migrated memory.ini to {self.global_dir}")
+            time.sleep(2)
+
+        if old_projects.exists() and not self.projects_folder.exists():
+            shutil.move(str(old_projects), str(self.projects_folder))
+            print(f"Migrated Projects folder to {self.global_dir}")
+            time.sleep(2)
+
+        if not self.templates_folder.exists():
+            default_templates = resources.files("DA.Templates")
+            user_templates = self.templates_folder
+
+            user_templates.mkdir(parents=True, exist_ok=True)
+
+            for item in default_templates.iterdir():
+                dest = user_templates / item.name
+                if not dest.exists():
+                    shutil.copy(item, dest)
+
+            print(f"Copied default Templates to {self.global_dir}")
+            time.sleep(2)
+
+    def load_memory(self):
+        prj = self.config['ITEMS']
+        return {
+            'last_project': prj.get('last_project'),
+            'pinned_project': prj.get('pinned_project'),
+            'pinned_project1': prj.get('pinned_project1'),
+            'pinned_project2': prj.get('pinned_project2'),
+            'color': self.config.get("CONFIG", "color")
+        }
+
+    def update_memory(self, category: str, variable: str, value: str):
+        memory_parser = configparser.ConfigParser()
+        memory_parser.read(self.memory_ini)
+
+        memory_parser.set(category, variable, value)
+        with open(self.memory_ini, "w", encoding="utf-8") as f:
+            memory_parser.write(f)
+        return
+        
+    def project_ini(self):
+        #==Create new project ini==
+        project_parser = configparser.ConfigParser()
+        project_parser["SETTINGS"] = self.data
+        
+        with open(self.new_project_ini, "w", encoding="utf-8") as f:
+            project_parser.write(f)
+            
+        #==Update last_project in memory.ini==
+        memory_parser = configparser.ConfigParser()
+        memory_parser.read(self.memory_ini)
+        
+        memory_parser.set("ITEMS", "last_project", self.update_last_project)
+        with open(self.memory_ini, "w", encoding="utf-8") as f:
+            memory_parser.write(f)
+        return
+    
+    def load_project(self):
+        #==Return project ini variables==
+        project_parser = configparser.ConfigParser()
+        project_parser.read(self.new_project_ini)
+        '''
+        try:
+            prj = project_parser['SETTINGS']
+        except KeyError:
+            print(f"\nCan't find {self.new_project_ini}")
+            time.sleep(2)
+            return
+        '''
+        prj = project_parser['SETTINGS']
+        return {
+            'path': prj.get('path'),
+            'changelog': prj.get('changelog'),
+            'version': prj.get('version'),
+            'cloud': prj.get('cloud')
+        }
+
+    def update_project(self, variable: str, value: str):
+        project_parser = configparser.ConfigParser()
+        project_parser.read(self.new_project_ini)
+
+        project_parser.set("SETTINGS", variable, value)
+        with open(self.new_project_ini, "w", encoding="utf-8") as f:
+            project_parser.write(f)
+        return
+
+if __name__ == "__main__":
+    ConfigManager()

developer_assistant-0.2.0/DA/Modules/opener.py

@@ -0,0 +1,31 @@
+from termcolor import colored
+import subprocess
+import platform
+import os
+import time
+
+class Opener:
+    @staticmethod
+    def open(path):
+        #==Check if path exists==
+        if not os.path.exists(path):
+            print(colored("\nThis path does not exist.", "light_red"))
+            time.sleep(1.5)
+            return
+        #==Open if exists==
+        else:
+            system = platform.system()
+            if system == "Windows":
+                subprocess.Popen(['explorer', path])
+            elif system == "Darwin":
+                subprocess.Popen(['open', path])
+            else:
+                subprocess.Popen(
+                    ['xdg-open', path],
+                    stdout=subprocess.DEVNULL,
+                    stderr=subprocess.DEVNULL
+                )
+            return
+
+if __name__ == "__main__":
+    Opener()

developer_assistant-0.2.0/DA/Modules/projects_manager.py

@@ -0,0 +1,120 @@
+import os, sys
+import time
+from termcolor import colored
+import subprocess
+import platform
+from pathlib import Path
+
+from DA.Modules.config_manager import ConfigManager
+from DA.Modules.version_logic import VersionLogic
+from DA.Modules.opener import Opener
+
+class ProjectsManager:
+    def __init__(self, color="light_blue"):
+        os.system('title Developer Assistant')
+        self.version = "1.0.0-alpha"
+        
+        self.config = ConfigManager('memory.ini')
+        self.memory = self.config.load_memory()
+        self.color = self.memory.get('color') or color
+        
+        #==Reusables==
+        self.header = (colored(" Developer Assistant ", f"{self.color}"))
+        self.clear_screen = 'cls' if platform.system() == 'Windows' else 'clear'
+        self.user_path = os.environ.get('USERPROFILE') or os.environ.get('HOME', 'User')
+    
+    def new_project(self):
+        os.system(self.clear_screen)
+        print(self.header.center(127, "="))
+        print("E. Abort/back\n")
+        
+        name = input("Enter new project name: ")
+        if name.lower() == "e":
+            return
+
+        print("")
+        path = input("Enter project path: ")
+
+        print("")
+        changelog = input("Project changelog path: ")
+
+        print("")
+        version = input("Current project version: ")
+
+        print("")
+        cloud = input("Cloud service (OneDrive/Azure/Dropbox/Google Drive): ")
+
+        print("")
+        confirm = input("Confirm(Y) or abort(E): ")
+        if confirm.lower() == "e":
+            return
+            
+        elif confirm.lower() == "y":
+            self.new_manager = ConfigManager(f"{name}.ini")
+            self.new_manager.data = {
+                "path": path,
+                "changelog": changelog,
+                "version": version,
+                "cloud": cloud
+            }
+            self.new_manager.project_ini()
+
+            return
+            
+        else:
+            print("")
+            print(colored("Unknown option, try again...", "light_red", attrs=["blink"]))
+            time.sleep(2)
+            return
+            
+    def load_project(self, project):
+        while True:
+            chosen_project = f"{project}"
+            self.load_manager = ConfigManager(f"{project}.ini")
+            try:
+                self.setting = self.load_manager.load_project()
+            except KeyError:
+                print(colored(f"\nCan't find {chosen_project}.ini", "light_red"))
+                time.sleep(2)
+                return
+
+            self.version_logic = VersionLogic()
+
+            project_ini_path = self.load_manager.projects_folder / f"{chosen_project}.ini"
+
+            os.system(self.clear_screen)
+            print("Main menu / Projects / Project menu")
+            print(self.header.center(127, "="))
+            print("E. Back\n")
+            print(colored("Chosen project:", attrs=["underline"]))
+            print(colored(chosen_project, f"{self.color}"))
+            print("\n1. Open project folder.")
+            print("2. Update the changelog.")
+            print("3. Backup to the cloud. [WIP]")
+            print("4. Open project configurations.\n")
+
+            choice = input(f"{self.user_path}> ").strip()
+
+            if choice.lower() == "e":
+                return
+
+            elif choice == "1":
+                path = self.setting.get('path')
+                folder = Path(path)
+                Opener.open(folder)
+
+            elif choice == "2":
+                self.version_logic.project_menu(chosen_project)
+
+            # elif choice == "3":
+
+            elif choice == "4":
+                Opener.open(project_ini_path)
+
+            else:
+                print("")
+                print(colored("Unknown option...", "light_red", attrs=["blink"]))
+                time.sleep(2)
+        
+if __name__ == "__main__":
+    ProjectsManager()