VIStk 0.3.12.14__py3-none-any.whl

VIStk/Objects/_Root.py

@@ -0,0 +1,9 @@
+from tkinter import *
+from VIStk.Objects._WindowGeometry import WindowGeometry
+from VIStk.Objects._Window import Window
+
+class Root(Tk, Window):
+    """A wrapper for the Tk class with VIS attributes"""
+    def __init__(self,*args,**kwargs):
+        super().__init__(*args,**kwargs)
+        self.WindowGeometry = WindowGeometry(self)

VIStk/Objects/_SubRoot.py

@@ -0,0 +1,18 @@
+from tkinter import *
+from VIStk.Objects._WindowGeometry import WindowGeometry
+from VIStk.Objects._Window import Window
+
+class SubRoot(Toplevel, Window):
+    """A wrapper for the Toplevel class with VIS attributes"""
+    def __init__(self,*args,**kwargs):
+        super().__init__(*args,**kwargs)
+        self.WindowGeometry = WindowGeometry(self)
+
+    def modalize(self):
+        """Makes the SubWindow modal"""
+        self.focus_force()
+
+        self.transient(self.master)
+        self.grab_set()
+
+        self.master.wait_window(self)

VIStk/Objects/_Window.py

@@ -0,0 +1,24 @@
+from tkinter import *
+
+class Window:
+    """A VIS Window object"""
+    def __init__(self):
+        """Initializes the VIS Window"""
+
+    def fullscreen(self,absolute:bool=False):
+        if absolute is False:
+            try: #On Linux
+                self.wm_attributes("-zoomed", True)
+            except TclError: #On Windows
+                self.state('zoomed')
+        else:
+            self.attributes("-fullscreen", True)
+
+    def unfullscreen(self,absolute:bool=False):
+        if absolute is False:
+            try: #On Linux
+                self.wm_attributes("-zoomed", False)
+            except TclError: #On Windows
+                self.state('normal')
+        else:
+            self.attributes("-fullscreen", False)

VIStk/Objects/_WindowGeometry.py

@@ -0,0 +1,133 @@
+from tkinter import *
+from typing import Literal
+
+query = Tk()
+try: #On Linux
+    query.wm_attributes("-zoomed", True)
+except TclError: #On Windows
+    query.state('zoomed')
+query.update()
+global hs, ws
+ws = query.winfo_width()-2#Unclear about this offset
+hs = query.winfo_height()-9#Might be operating system specific
+query.destroy()
+print(f"Screen has usable size of {ws}x{hs}")
+
+class WindowGeometry():
+    """Handles geometry relations and sizing/resizing for windows"""
+    def __init__(self,window:Tk|Toplevel):
+        """Creates a window geometry object and automatically extracts the size and location
+        
+        Args:
+            window (Tk|Toplevel): The window to access geometry of
+        """
+        self.window:Tk|Toplevel = window
+        self.getGeometry()
+        window.WindowGeometry = self
+
+    def getGeometry(self, respect_size:bool=False):
+        """Sets the internal geometry of object to match the window"""
+        geo_str = self.window.geometry()
+        geo_list = geo_str.split("x")
+        ng_list = [int(geo_list[0])]
+        for i in geo_list[1].split("+"):
+            ng_list.append(int(i))
+        
+        if respect_size:
+            self.geometry = [self.window.winfo_width(), self.window.winfo_height(), ng_list[2], ng_list[3]]
+        else:
+            self.geometry = ng_list
+
+    def stripGeometry(self,objects:tuple[Literal["w","h","x","y"]]|Literal["all"]):
+        """Returns integer values of the requested items"""
+        geo_str = self.window.geometry()
+        geo_list = geo_str.split("x")
+        ng_list = [int(geo_list[0])]
+        for i in geo_list[1].split("+"):
+            ng_list.append(int(i))
+        
+        geo_list = []
+        if objects == "all":
+            geo_list = ng_list
+        else:
+            if "w" in objects: geo_list.append(ng_list[0])
+            if "h" in objects: geo_list.append(ng_list[1])
+            if "x" in objects: geo_list.append(ng_list[2])
+            if "y" in objects: geo_list.append(ng_list[3])
+
+        return geo_list
+
+
+    def setGeometry(self,width:int=None,height:int=None,x:int=None,y:int=None,align:Literal["center","n","ne","e","se","s","sw","w","nw"]=None,size_style:Literal["pixels","screen_relative","window_relative"]=None,window_ref:Tk|Toplevel=None):
+        """Sets the geometry of the window"""
+        global hs, ws
+        ox, oy = 0, 0
+
+        if width is None: width = self.geometry[0]
+        if height is None: height = self.geometry[1]
+
+        #Check if aligning or using coordinates
+        if align is None:
+            if x is None: x = self.geometry[2]
+            if y is None: y = self.geometry[3]
+        else:
+            x = None
+            y = None
+        
+        #No adjustment needs to be made if pixels are given
+
+        if size_style == "window_relative":
+            if not window_ref is None:
+                _ws = window_ref.winfo_width()
+                _hs = window_ref.winfo_height()
+
+                if not _ws is None: ws = _ws
+                if not _hs is None: hs = _hs
+
+                geo_ref = WindowGeometry(window_ref).stripGeometry(("x","y"))
+                
+                ox = geo_ref[0]
+                oy = geo_ref[1]
+
+            #Will always hand over relative sizing to screen relative
+            size_style = "screen_relative"
+
+        if size_style == "screen_relative":
+            if not width == self.geometry[0]:
+                width = ws*width/100
+                
+            if not height == self.geometry[1]:
+                height = hs*height/100
+
+        if not align is None:
+            match align:
+                case "center":
+                    x = ws/2 - width/2 + ox
+                    y = hs/2 - height/2 + oy
+                case "n":
+                    x = ws/2 - width/2 + ox
+                    y = 0 + oy
+                case "ne":
+                    x = ws - width + ox
+                    y = 0 + oy
+                case "e":
+                    x = ws - width + ox
+                    y = hs/2 - height/2 + oy
+                case "se":
+                    x = ws - width + ox
+                    y = hs - height + oy
+                case "s":
+                    x = ws/2 - width/2 + ox
+                    y = hs - height + oy
+                case "sw":
+                    x = 0 + ox
+                    y = hs - height + oy
+                case "w":
+                    x = 0 + ox
+                    y = hs/2 - height/2 + oy
+                case "nw":
+                    x = 0 + ox
+                    y = 0 + oy
+
+        self.geometry = [int(width), int(height), int(x-7), int(y)]
+        self.window.geometry('%dx%d+%d+%d' % tuple(self.geometry))

VIStk/Objects/__init__.py

@@ -0,0 +1,6 @@
+from VIStk.Objects._WindowGeometry import *
+from VIStk.Objects._Root import *
+from VIStk.Objects._SubRoot import *
+from VIStk.Objects._Window import *
+
+__all__ = ["WindowGeometry","Root","SubRoot","Window"]

VIStk/Structures/VINFO.py

@@ -0,0 +1,139 @@
+import os
+import json
+import zipfile
+import shutil
+import subprocess
+
+#Copied from source
+#https://stackoverflow.com/a/75246706
+def unzip_without_overwrite(src_path, dst_dir):
+    with zipfile.ZipFile(src_path, "r") as zf:
+        for member in zf.infolist():
+            file_path = os.path.join(dst_dir, member.filename)
+            if not os.path.exists(file_path):
+                zf.extract(member, dst_dir)
+
+def getPath():
+    """Searches for .VIS folder and returns from path.cfg
+    """
+    sto = 0
+    while True:
+        try:
+            step=""
+            for i in range(0,sto,1): #iterate on sto to step backwards and search for project info
+                step = "../" + step
+            if os.path.exists(step+".VIS/"):
+                return open(step+".VIS/path.cfg","r").read().replace("\\","/") #return stored path
+            else:
+                if os.path.exists(step):
+                    sto += 1
+                else:
+                    return None #return none if cant escape more
+        except:
+            return None #if failed return none
+        
+def validName(name:str):
+    """Checks if provided path is a valid filename
+    """
+    if " " in name:
+        print("Cannot have spaces in file name.")
+        return False
+    if "/" in name or "\\" in name:
+        print("Cannot have filepath deliminator in file name.")
+        return False
+    if "<" in name or ">" in name or ":" in name or '"' in name or "|" in name or "?" in name or "*" in name:
+        print('Invlaid ASCII characters for windows file creation, please remove all <>:"|?* from file name.')
+        return False
+    if name.split(".")[0] in ["CON","PRN","AUX","NUL","COM1","COM2","COM3","COM4","COM5","COM6","COM7","COM8","COM9","LPT1","LPT2","LPT3","LPT4","LPT5","LPT6","LPT7","LPT8","LPT9"]:
+        print(f"Filename {name} reserved by OS.")
+        return False
+    if "" == name:
+        print("Must provide a name for file.")
+        return False
+    else:
+        return True
+    
+
+class VINFO():
+    """Overarching control structure within the /.VIS/ folder
+    """
+    def __init__(self):
+        if getPath() == None:
+            wd = os.getcwd()
+            os.mkdir(wd+"\\.VIS")
+            open(wd+"/.VIS/path.cfg","w").write(wd) if os.path.exists(wd+"/.VIS/path.cfg") else open(wd+"/.VIS/path.cfg", 'a').write(wd)
+            print(f"Stored project path in path.cfg as {wd} in {wd}/.VIS/path.cfg")
+
+            unzip_without_overwrite("Form.zip",wd)
+            print(f"Copied structure to {wd}")
+
+            shutil.copytree("./Templates",wd+"/.VIS/Templates",dirs_exist_ok=True)
+            print(f"Loaded default templates into {wd}/.VIS/Templates/")
+
+           
+            #DO NOT MESS WITH THE TEMPLATE HEADERS
+
+            title = input("Enter a name for the VIS project: ")
+            self.title = title
+            info = {}
+            info[self.title] = {}
+            info[self.title]["Screens"]={}
+            info[self.title]["defaults"]={}
+            info[self.title]["defaults"]["icon"]="VIS"#default icon
+            self.d_icon = "VIS"
+            self[self.title]["metadata"]={}
+            comp = input("What company is this for(or none)? ")
+            if not comp in ["none","None"]:
+                info[self.title]["metadata"]["company"] = comp
+                self.company = comp
+            else:
+                info[self.title]["metadata"]["company"] = None
+                self.company = None
+
+            version = input("What is the initial version for the project (0.0.1 default): ")
+            vers = version.split(".")
+            if len(vers)==3:
+                if vers[0].isnumeric() and vers[1].isnumeric() and vers[2].isnumeric():
+                    self.version = version
+                else:
+                    self.version = "0.0.1"
+            else:
+                self.version = "0.0.1"
+            info[self.title]["metadata"]["version"] = self.version
+
+            with open(wd+"/.VIS/project.json","w") as f:
+                f.write("{}")
+                json.dump(info,f,indent=4)
+            print(f"Setup project.json for project {self.title} in {wd}/.VIS/")
+
+
+        #Need to get current python location where VIS is installed
+        self.p_vis = subprocess.check_output('python -c "import os, sys; print(os.path.dirname(sys.executable))"').decode().strip("\r\n")+"\\Lib\\site-packages\\VIS\\"
+
+
+        self.p_project = getPath()
+        self.p_vinfo = self.p_project + "/.VIS"
+        self.p_sinfo = self.p_vinfo + "/project.json"
+        with open(self.p_sinfo,"r") as f: 
+            info = json.load(f)
+            self.title = list(info.keys())[0]
+            self.version = info[self.title]["metadata"]["version"]
+            self.company = info[self.title]["metadata"]["company"]
+            
+        self.screenlist = []
+        self.p_screens = self.p_project +"/Screens"
+        self.p_modules = self.p_project +"/modules"
+        self.p_templates = self.p_vinfo + "/Templates"
+        self.p_icons = self.p_project + "/Icons"
+        self.p_images = self.p_project + "/Images"
+        
+    def setVersion(self,version:str):
+        """Sets a new project version
+        """
+        with open(self.p_sinfo,"r") as f: 
+            info = json.load(f)
+
+        info[self.title]["metadata"]["version"] = version
+
+        with open(self.p_sinfo,"w") as f:
+            json.dump(info,f,indent=4)

VIStk/Structures/__init__.py

@@ -0,0 +1,6 @@
+from VIStk.Structures.project import *
+from VIStk.Structures.release import *
+from VIStk.Structures.screen import *
+from VIStk.Structures.VINFO import *
+
+__all__ = ["Project", "Release", "Screen", "VINFO"]

VIStk/Structures/project.py

@@ -0,0 +1,92 @@
+import json
+from VIStk.Structures.VINFO import *
+from VIStk.Structures.screen import *
+
+class Project(VINFO):
+    """VIS Project Object
+    """
+    def __init__(self):
+        """Initializes or load a VIS project
+        """
+        super().__init__()
+        with open(self.p_sinfo,"r") as f:
+            info = json.load(f)
+            self.name = list(info.keys())[0]
+
+            for screen in list(info[self.name]["Screens"].keys()):
+                scr = Screen(screen,
+                             info[self.name]["Screens"][screen]["script"],
+                             info[self.name]["Screens"][screen]["release"],
+                             info[self.name]["Screens"][screen].get("icon"),
+                             exists=True)
+                self.screenlist.append(scr)
+            self.d_icon = info[self.name]["defaults"]["icon"]
+    
+    def newScreen(self,screen:str) -> int:
+        """Creates a new screen with some prompting
+
+        Returns:
+            0 Failed
+            1 Success
+        """
+        #Check for valid filename  
+        if not validName(screen):
+            return 0
+        
+        with open(self.p_sinfo,"r") as f:
+            info = json.load(f) #Load info
+
+        name = self.title
+        if info[name]["Screens"].get(screen) == None: #If Screen does not exist in VINFO
+            while True: #ensures a valid name is used for script
+                match input(f"Should python script use name {screen}.py? "):
+                    case "Yes" | "yes" | "Y" | "y":
+                        script = screen + ".py"
+                        break
+                    case _:
+                        script = input("Enter the name for the script file: ").strip(".py")+".py"
+                        if validName(script):
+                            break
+
+            match input("Should this screen have its own .exe?: "):
+                case "Yes" | "yes" | "Y" | "y":
+                    release = True
+                case _:
+                    release = False
+            ictf =input("What is the icon for this screen (or none)?: ")
+            icon = ictf.strip(".ico") if ".ICO" in ictf.upper() else None
+            desc = input("Write a description for this screen: ")
+            self.screenlist.append(Screen(screen,script,release,icon,False,desc))
+
+            return 1
+        else:
+            print(f"Information for {screen} already in project.")
+            return 1
+
+    def hasScreen(self,screen:str) -> bool:
+        """Checks if the project has the correct screen
+        """
+        for i in self.screenlist:
+            if i.name == screen:
+                return True
+        return False
+    
+    def getScreen(self,screen:str) -> Screen:
+        """Returns a screen object by its name
+        """
+        for i in self.screenlist:
+            if i.name == screen:
+                return i
+        return None
+
+    def verScreen(self,screen:str) -> Screen:
+        """Verifies a screen exists and returns it
+
+        Returns:
+            screen (Screen): Verified screen
+        """
+        if not self.hasScreen(screen):
+            self.newScreen(screen)
+        scr = self.getScreen(screen)
+        return scr
+

VIStk/Structures/release.py

@@ -0,0 +1,165 @@
+from VIStk.Structures.project import *
+from VIStk.Structures.VINFO import *
+from VIStk.Structures.screen import *
+import subprocess
+import shutil
+from os.path import exists
+import time
+import datetime
+
+info = {}
+
+class Release():
+    """A VIS Release object"""
+    def __init__(self, project :Project, version:str="",type:str="",note:str=""):
+        """Creates a Release object to release or examine a releaes of a project"""
+        self.project = project
+        self.version = version
+        self.type = type
+        self.note = note
+
+    def build(self):
+        """Build project spec file for release
+        """
+        
+        print(f"Creating project.spec for {self.project.name}")
+
+        with open(self.project.p_vinfo+"/Templates/spec.txt","r") as f:
+            spec = f.read()
+        with open(self.project.p_vinfo+"/Templates/collect.txt","r") as f:
+            collect = f.read()
+        
+        spec_list = []
+        name_list = []
+        os.mkdir(self.project.p_vinfo+"/Build")
+        for i in self.project.screenlist:
+            if i.release:
+                name_list.append(i.name)
+                if not i.icon == None:
+                    icon = i.icon
+                else:
+                    icon = self.project.d_icon
+                spec_list.append(spec.replace("$name$",i.name))
+                spec_list[len(spec_list)-1] = spec_list[len(spec_list)-1].replace("$icon$",icon)
+                spec_list[len(spec_list)-1] = spec_list[len(spec_list)-1].replace("$file$",i.script)
+
+                #build metadata
+                with open(self.project.p_templates+"/version.txt","r") as f:
+                    meta = f.read()
+
+                #Update Overall Project Version
+                vers = self.project.version.split(".")
+                major = vers[0]
+                minor = vers[1]
+                patch = vers[2]
+                meta = meta.replace("$M$",major)
+                meta = meta.replace("$m$",minor)
+                meta = meta.replace("$p$",patch)
+
+                #Update Screen Version
+                vers = i.s_version.split(".")
+                major = vers[0]
+                minor = vers[1]
+                patch = vers[2]
+                meta = meta.replace("$sM$",major)
+                meta = meta.replace("$sm$",minor)
+                meta = meta.replace("$sp$",patch)
+
+                if self.project.company != None:
+                    meta = meta.replace("$company$",self.project.company)
+                    meta = meta.replace("$year$",str(datetime.datetime.now().year))
+                else:
+                    meta = meta.replace("            VALUE \"CompanyName\",      VER_COMPANYNAME_STR\n","")
+                    meta = meta.replace("            VALUE \"LegalCopyright\",   VER_LEGALCOPYRIGHT_STR\n","")
+                    meta = meta.replace("#define VER_LEGAL_COPYRIGHT_STR     \"Copyright © $year$ $company$\\0\"\n\n","")
+                meta = meta.replace("$name$",i.name)
+                meta = meta.replace("$desc$",i.desc)
+                
+                with open(self.project.p_vinfo+f"/Build/{i.name}.txt","w") as f:
+                    f.write(meta)
+                spec_list[len(spec_list)-1] = spec_list[len(spec_list)-1].replace("$meta$",self.project.p_vinfo+f"/Build/{i.name}.txt")
+                spec_list.append("\n\n")
+
+        insert = ""
+        for i in name_list:
+            insert=insert+"\n\t"+i+"_exe,\n\t"+i+"_a.binaries,\n\t"+i+"_a.zipfiles,\n\t"+i+"_a.datas,"
+        collect = collect.replace("$insert$",insert)
+        collect = collect.replace("$version$",self.project.name+"-"+self.version) if not self.version == "" else collect.replace("$version$",self.project.name)
+        
+        header = "# -*- mode: python ; coding: utf-8 -*-\n\n\n"
+
+        with open(self.project.p_vinfo+"/project.spec","w") as f:
+            f.write(header)
+        with open(self.project.p_vinfo+"/project.spec","a") as f:
+            f.writelines(spec_list)
+            f.write(collect)
+
+        print(f"Finished creating project.spec for {self.project.title} {self.version if not self.version =="" else "current"}")#advanced version will improve this
+
+    def clean(self):
+        """Cleans up build environment to save space
+        """
+        print("Cleaning up build environment")
+        shutil.rmtree(self.project.p_vinfo+"/Build")
+        print("Appending Screen Data To Environment")
+        if self.version == " ":
+            if exists(f"{self.project.p_project}/dist/{self.project.title}/Icons/"): shutil.rmtree(f"{self.project.p_project}/dist/{self.project.title}/Icons/")
+            if exists(f"{self.project.p_project}/dist/{self.project.title}/Images/"): shutil.rmtree(f"{self.project.p_project}/dist/{self.project.title}/Images/")
+            shutil.copytree(self.project.p_project+"/Icons/",f"{self.project.p_project}/dist/{self.project.title}/Icons/",dirs_exist_ok=True)
+            shutil.copytree(self.project.p_project+"/Images/",f"{self.project.p_project}/dist/{self.project.title}/Images/",dirs_exist_ok=True)
+        else:
+            if exists(f"{self.project.p_project}/dist/{self.project.title}/Icons/"): shutil.rmtree(f"{self.project.p_project}/dist/{self.project.name}/Icons/")
+            if exists(f"{self.project.p_project}/dist/{self.project.title}/Images/"): shutil.rmtree(f"{self.project.p_project}/dist/{self.project.name}/Images/")
+            shutil.copytree(self.project.p_project+"/Icons/",f"{self.project.p_project}/dist/{self.project.title}-{self.version.strip(" ")}/Icons/",dirs_exist_ok=True)
+            shutil.copytree(self.project.p_project+"/Images/",f"{self.project.p_project}/dist/{self.project.title}-{self.version.strip(" ")}/Images/",dirs_exist_ok=True)
+        print(f"\n\nReleased new{self.version}build of {self.project.title}!")
+
+    def newVersion(self):
+        """Updates the project version, PERMANENT, cannot be undone
+        """
+        old = str(self.project.version)
+        vers = self.project.version.split(".")
+        if self.version == "Major":
+            vers[0] = str(int(vers[0])+1)
+            vers[1] = str(0)
+            vers[2] = str(0)
+        if self.version == "Minor":
+            vers[1] = str(int(vers[1])+1)
+            vers[2] = str(0)
+        if self.version == "Patch":
+            vers[2] = str(int(vers[2])+1)
+
+        self.project.setVersion(f"{vers[0]}.{vers[1]}.{vers[2]}")
+        self.project = VINFO()
+        print(f"Updated Version {old}=>{self.project.version}")
+
+    def makeRelease(self):
+        """Releases a version of your project
+        """
+        match self.version:
+            case "a":
+                self.build("alpha")
+                subprocess.call(f"pyinstaller {self.project.p_vinfo}/project.spec --noconfirm --distpath {self.project.p_project}/dist/ --log-level FATAL")
+                self.clean(" alpha ")
+            case "b":
+                self.build("beta")
+                subprocess.call(f"pyinstaller {self.project.p_vinfo}/project.spec --noconfirm --distpath {self.project.p_project}/dist/ --log-level FATAL")
+                self.clean(" beta ")
+            case "c":
+                self.newVersion(type)
+                self.build()
+                subprocess.call(f"pyinstaller {self.project.p_vinfo}/project.spec --noconfirm --distpath {self.project.p_project}/dist/ --log-level FATAL")
+                self.clean()
+            case "sync":
+                self.build("alpha")
+                subprocess.call(f"pyinstaller {self.project.p_vinfo}/project.spec --noconfirm --distpath {self.project.p_project}/dist/ --log-level FATAL")
+                self.clean(" alpha ")
+                self.build("beta")
+                subprocess.call(f"pyinstaller {self.project.p_vinfo}/project.spec --noconfirm --distpath {self.project.p_project}/dist/ --log-level FATAL")
+                self.clean(" beta ")
+                self.build()
+                subprocess.call(f"pyinstaller {self.project.p_vinfo}/project.spec --noconfirm --distpath {self.project.p_project}/dist/ --log-level FATAL")
+                self.clean()
+                print("\t- alpha\n\t- beta\n\t- current")
+            case _:
+                print(f"Could not release Project Version {self.version}")