bumped version

README.md

@@ -1,7 +1,14 @@
 # Python Programs and Scripts Repository
 
 ![Python](https://img.shields.io/badge/python-3670A0?style=for-the-badge&logo=python&logoColor=ffdd54)  
-Collection of my python scripts and programs. Containing tools to manipulate the behavior of the system.
+Collection of my python scripts and programs. Containing tools to
+manipulate the behavior of the system.  
+
+## Wanna Do´s
+
+- Program which creates an file containing a version and  
+- Creating a Module which loads configuration files  
+- GUI auto-clicker which accepts command line activation  
 
 ## tempbox
 
@@ -10,8 +17,9 @@ directory.
 
 After execution, all contents within the folder get removed.
 
-
 ## refit
 
-A file and folder manipulation tool. The aim is to unify various steps from moving to creating and deleting
+A file and folder manipulation tool. The aim is to unify various steps
-directories and folder with one tool.
+from moving to creating and deleting directories and folder with one
+tool.  
+

pyvers/src/pyvers.py

@@ -0,0 +1,211 @@
+import json
+import os
+import argparse
+import sys
+
+# ======================================================================
+# Constantes
+FILE_NAME = "version.json"
+# ======================================================================
+
+# ======================================================================
+# Parser
+parser = argparse.ArgumentParser(
+    prog="pyvers",
+    description="xD",
+)
+
+parser.add_argument(
+    "config",
+    help="The location of the config file to edit.",
+    type=str,
+)
+parser.add_argument(
+    "--patch",
+    help="Bumps the patch version by one.",
+    action="store_true",
+)
+parser.add_argument(
+    "--minor",
+    help="Bumps the minor version by one.",
+    action="store_true",
+)
+parser.add_argument(
+    "--major",
+    help="Bumps the major version by one.",
+    action="store_true",
+)
+
+args = parser.parse_args()
+# ======================================================================
+
+
+# ======================================================================
+# Functions
+def create_version_file(file_path) -> None:
+    """Creates a version.json file with all versions set to 0 at the
+    input location.
+
+    Args:
+        file_path: (str): Path with file name.
+
+    Example:
+    >>>create_version_file(/path/to/file)
+    file:
+    {
+        "minor": 0,
+        "major": 0,
+        "patch": 0
+    }"""
+
+    # Defining the dictionary with the initial version numbers.
+    initial_version = {"minor": 0, "major": 0, "patch": 0}
+
+    # Opening/creating the file to write the dictionary as json to it.
+    file = open(file_path, "x")
+    file.write(json.dumps(initial_version, indent=4))
+    print("File written successfully.")
+    return
+
+
+def load_version(input_path) -> dict[str, int]:
+    """Opens the given file and returns its contents."""
+    # Open given path and loading the files contents into a variable
+    file_path = open(input_path)
+    prog_version = json.load(file_path)
+    return prog_version
+
+
+def pretty_version(input_path) -> None:
+    """Prints the version in a prettifyed format."""
+    prog_version = load_version(input_path)
+    pretty_version = (
+        f"{prog_version['major']}.{prog_version['minor']}.{prog_version['patch']}"
+    )
+    print(pretty_version)
+
+
+def bump_patch(version_file) -> None:
+    """Bumps the patch number of the given file by one."""
+    # Get the version as dictionary
+    version = load_version(version_file)
+
+    # Adding one to the version from the file and updating
+    # the dictionary
+    new_version = version["patch"] + 1
+    version.update({"patch": new_version})
+
+    # Opening the file and overwriting its contents.
+    with open(version_file, "w") as f:
+        f.write(json.dumps(version, indent=4))
+
+
+def bump_minor(version_file) -> None:
+    """Bumps the minor version number of the given file by one."""
+    # Get the version as dictionary
+    version = load_version(version_file)
+
+    # Adding one to the version from the file and updating
+    # the dictionary
+    new_version = version["minor"] + 1
+    version.update({"minor": new_version})
+
+    # Opening the file and overwriting its contents.
+    with open(version_file, "w") as f:
+        f.write(json.dumps(version, indent=4))
+
+
+def bump_major(version_file) -> None:
+    """Bumps the major version number of the given file by one."""
+    # Get the version as dictionary
+    version = load_version(version_file)
+
+    # Adding one to the version from the file and updating
+    # the dictionary
+    new_version = version["major"] + 1
+    version.update({"major": new_version})
+
+    # Opening the file and overwriting its contents.
+    with open(version_file, "w") as f:
+        f.write(json.dumps(version, indent=4))
+
+
+def version_bumper(version_file, major_version, minor_version, patch) -> None:
+    """Decides what version to bump, based on the users passed flags"""
+    if patch:
+        bump_patch(version_file)
+    if minor_version:
+        bump_minor(version_file)
+    if major_version:
+        bump_major(version_file)
+
+
+def check_for_file(input_path: str) -> bool:
+    """Checks if the file 'version.json' exists at the given path.
+
+    Args:
+        input_path ( str ): Path to check for the file.
+
+    Example:
+        >>>check_for_file(".")
+        'False'
+        >>>check_for_file("version.json")
+        'True'
+        >>>check_for_file("./version.json")
+        'True'
+    """
+    if FILE_NAME in input_path:
+        file_path = os.path.expanduser(input_path)
+        if os.path.exists(file_path):
+            return True
+        else:
+            return False
+    elif os.path.exists(os.path.join(input_path, FILE_NAME)):
+        return True
+    else:
+        return False
+
+
+def request_to_create():
+    """Prompts the user if he wants to create the file and exits if the
+    user declines or presses any other character instead of 'y/Y'"""
+
+    PROMPT = "The file does not exist, do you want to create it? [y/n]"
+    PROMPT += "\n>>>"
+
+    response = input(PROMPT)
+    if "y" in response or "Y" in response:
+        file_path = os.path.join(
+            os.path.expanduser(args.config),
+            FILE_NAME,
+        )
+        create_version_file(file_path)
+        return
+    else:
+        parser.print_help()
+        sys.exit(1)
+
+
+# ======================================================================
+# Dispatching
+if check_for_file(args.config):
+    file_path = os.path.join(os.path.expanduser(args.config), FILE_NAME)
+    if args.patch or args.minor or args.major:
+        version_bumper(
+            version_file=file_path,
+            major_version=args.major,
+            minor_version=args.minor,
+            patch=args.patch,
+        )
+    else:
+        pretty_version(file_path)
+
+if check_for_file(args.config) is False:
+    request_to_create()
+    file_path = os.path.join(os.path.expanduser(args.config), FILE_NAME)
+    version_bumper(
+        version_file=file_path,
+        major_version=args.major,
+        minor_version=args.minor,
+        patch=args.patch,
+    )

refit/README.md

@@ -1,24 +1,27 @@
 # refit
 
-`refit` is a file, directory manipulation and creation tool.
+`refit` is a file and directory manipulation tool. Currently it can
+create a flat folder and file structure
+as well as an linear directory structure.
 
 ## ToDos
 
 1. folder and file creation  
 1.1 simple file and folder creation  
 1.2 recursive file and folder creation  
-1.3 file in folder creation  
 2. file movement  
-2.1 apply a pattern what to move to where  
+2.1 file deletion  
-3. file removal  
-3.1 remove all files like '*.tar'  
 
 - implement config file containing version, default names and other
 configurations  
 - make file and directory creation start counting at 1 instead of 0  
+- Add security check which benchmarks the creation of folders and files
+before the first execution in order to prevent either python, the file
+system or the system in general to crash.  
 
 ## Changelog
 
+<2025-10-16> V0.3.9 - Changed how the version is read  
 <2025-10-05> V0.3.8 - Added file extension to file creation mode  
 <2025-10-05> V0.3.7 - Added custom naming for level and branch in
 recursive mode  

refit/src/modules/librefit.py

@@ -1,5 +1,6 @@
 import os
 import sys
+import json
 
 from .refit_logger import logger
 
@@ -153,15 +154,30 @@ def get_current_path(path) -> str:
             sys.exit(1)
 
 
-def create_linear_directories(input_path, target_depth, current_depth, name):
+def create_linear_directories(
-    """Creates the linear directories for the x*y pattern"""
+    input_path: str, target_depth: int, current_depth: int, name
+):
+    """Creates the linear directories for the x*y pattern
+
+    If no name is given the name of the level is defaulted to 'level'.
+    Otherwise it takes the second input of the --name argument. In the
+    end it appends the number of the folder.
+
+    Args:
+        input_path ( str ): _The current working directory.
+        target_depth ( int ): _The depth on how deepo directories are created._
+        current_depth ( int ): _The current depth of the folder creation._
+        name ( list[str] | None ): _The name of the level directories._
+    """
 
-    # TODO: - add dynamic name input
-    #       - add docstring
     # logger.debug(
     #     f"FUNC: create_linear_directories(entered) VALUES: path='{input_path}', target_depth='{target_depth}', current_depth='{current_depth}'"
     # )
 
+    # TODO: Find a way on how to specify the type in the function call
+    # and let the if statement pass.
+
+    # Get base directory name
     if name is None:
         base_name = "level"
     else:
@@ -169,42 +185,93 @@ def create_linear_directories(input_path, target_depth, current_depth, name):
 
     if current_depth > target_depth:
         return
-
+    # Create directory name
     directory_name = (
         base_name
         + "_"
         + get_standard_name_number(current_depth, get_int_length(target_depth))
     )
+
+    # Create the path where to create directory
     path = os.path.join(input_path, directory_name)
 
     os.mkdir(path)
 
+    # Recursive call of itself
     create_linear_directories(path, target_depth, current_depth + 1, name)
 
 
-def create_parallel_directories(input_path, target_depth, width, name):
+def create_parallel_directories(input_path: str, target_depth: int, width: int, name):
-    """Creates directories after the pattern x*y"""
+    """Creates the branches which house the levels.
 
-    # TODO: - add dynamic name input
+    As input it takes the input_path and the width from which it creates
-    #       - add docstring
+    the branches of the structure. Afterwards it passes the target_depth
-    logger.debug(
+    to another function to create the levels of each branch.
-        f"FUNC: create_parallel_directories(entered) VALUES: path='{input_path}', target_depth='{target_depth}', width='{width}', name={name}"
+    If 'None' is passed to the '--name' argument, the default name 'branch'
-    )
+    gets used as base directory name.
+
+    Args:
+        input_path ( str ): _The current working directory.
+        target_depth ( int ): _The depth on how deepo directories are created._
+        width ( int ): _The ammount of branches to create._
+        name ( list[str] | None ): _The name of the level directories._
+
+    """
+
+    # logger.debug(
+    #     f"FUNC: create_parallel_directories(entered) VALUES: path='{input_path}', target_depth='{target_depth}', width='{width}', name={name}"
+    # )
+
+    # TODO: Find a way on how to specify the type in the function call
+    # and let the if statement pass.
+
+    # Get base directory name
     if name is None:
         base_name = "branch"
     else:
         base_name = name[0]
 
     for i in range(width):
+        # Create directory name
         directory_name = (
             base_name + "_" + get_standard_name_number(i, get_int_length(width))
         )
+
+        # Create the path where to create directory
         path = os.path.join(input_path, directory_name)
         os.mkdir(path)
 
+        # Recursive call of itself
         create_linear_directories(
             input_path=path,
             target_depth=target_depth,
             current_depth=0,
             name=name,
         )
+
+
+def get_version_from_file(input_path) -> str:
+    """Returns the version of the program.
+
+    The function accepts an path to a version file as a string and it
+    returns it version number formatted.
+
+    Arg:
+        input_path (str):   The absolute or relative path to the
+                            version file.
+
+    Example:
+        >>>get_version_from_file("/path/to/file.json")
+        '0.2.1'"""
+    # Expands the input path
+    expanded_path = os.path.expanduser(input_path)
+
+    # Opening the file and  reading its contents, saving as as an dict.
+    file_path = open(expanded_path)
+    prog_version = json.load(file_path)
+
+    # Formatting the output before returning the string again
+    pretty_version = (
+        f"{prog_version['major']}.{prog_version['minor']}.{prog_version['patch']}"
+    )
+    return pretty_version

refit/src/modules/refit_logger.py

@@ -27,6 +27,3 @@ def handle_exception(exec_type, exec_value, exec_traceback):
 
 
 sys.excepthook = handle_exception
-
-# logger.debug(f"Log path:\t{log_dir}")
-# logger.debug(f"Log file:\t{log_file}")

refit/src/refit.py

@@ -1,53 +1,23 @@
 import argparse
 import sys
-import os
-import configparser
 
 from modules.refit_logger import logger
 from modules.refit_create import Refit_Create
+from modules.librefit import get_version_from_file
 
-
+# NOTE: The final version file needs a dedicated place to live in
-CONFIG_FILE = "version.cfg"
+# so the version number is always readable, independent from where it
-
+# is executed
-
+REFIT_VERSION = get_version_from_file("~/Documents/git/python/refit/src/version.json")
-def read_version_config():
-    # logger.debug(f"Start read_version_config() with config file: {CONFIG_FILE}")
-    config = configparser.ConfigParser()
-    config.read(CONFIG_FILE)
-
-    if not os.path.exists(CONFIG_FILE):
-        # logger.error(
-        #     f"FUNC: read_version_config() MSG: Could not find config file '{CONFIG_FILE}'"
-        # )
-        return "x.x.x"
-
-    if "VERSION" not in config:
-        # logger.error(f"Could not find VERSION-variable in config file '{CONFIG_FILE}'")
-        return "x.x.x"
-
-    try:
-        v = config["VERSION"]
-        major = v.get("major", "0")
-        minor = v.get("minor", "0")
-        patch = v.get("patch", "0")
-        # logger.debug(f"Config file read successfully. Version: {major}.{minor}.{patch}")
-        return f"{major}.{minor}.{patch}"
-    except Exception:
-        # logger.warning("Couldn not read version from config file")
-        return "x.x.x"
-
-
-REFIT_VERSION = f"Refit Beta {read_version_config()}"
 
 # ---------------------------ARGPARSE  START---------------------------
 
 # Main Parser
 parser = argparse.ArgumentParser(
-    prog="Refit",
+    prog="refit",
-    description="This is a file and directory manipulation tool.\
+    description="""This is a file and directory manipulation tool. It can create, move and delete files and directories as well as renaming them""",
-    it can create, move and delete files and directories as well as \
-    renaming them",
     epilog=REFIT_VERSION,
+    formatter_class=argparse.RawDescriptionHelpFormatter,
 )
 
 # Main Parser Arguments
@@ -55,30 +25,51 @@ parser = argparse.ArgumentParser(
 # Create Parser
 subparser = parser.add_subparsers(
     title="Commands",
-    dest="create",
     required=False,
 )
 
 # Create Parser Arguments
-create_parser = subparser.add_parser("create", help="creates a new file/folder")
+create_parser = subparser.add_parser(
-create_parser.add_argument("-n", type=int, help="number of items")
+    name="create",
-create_parser.add_argument("-i", "--input", help="input file")
+    description="The create sub command lets you create files, folders and directory structures.",
+    help="The create sub command lets you create files, folders and directory structures.",
+)
+create_parser.add_argument(
+    "-n",
+    metavar="COUNT",
+    type=int,
+    help="Number of items",
+)
+create_parser.add_argument(
+    "-i",
+    "--input",
+    metavar="PATH",
+    help="Input path. If not specified the current directory is used.",
+)
 create_parser.add_argument(
     "--name",
     nargs="*",
     help="the name of the folder you want to create\n Default: directory",
 )
 create_parser.add_argument(
-    "--filemode", action="store_true", help="creates files instead of directories"
+    "--filemode",
+    action="store_true",
+    help="creates files instead of directories",
 )
 create_parser.add_argument(
     "-r",
     "--recursive",
+    metavar="INT",
     type=int,
     nargs=2,
-    help="Sets the recursive mode for folders to true. First argumet is for the depth and the second for the width.",
+    help="""Sets the recursive mode for folders to true. First argumet
+    is for the depth and the second for the width.""",
+)
+create_parser.add_argument(
+    "-e",
+    type=str,
+    help="File extension which gets appended to the end of the file name.",
 )
-create_parser.add_argument("-e", help="File extension")
 create_parser.set_defaults(command_class=Refit_Create)
 
 args = parser.parse_args()

refit/src/version.cfg

@@ -1,5 +0,0 @@
-[VERSION]
-major = 0
-minor = 3
-patch = 7
-

refit/src/version.json

@@ -0,0 +1,5 @@
+{
+    "minor": 3,
+    "major": 0,
+    "patch": 9
+}