filertk 1.0.0__tar.gz

filertk-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Dylan Alves Santos
+
+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.

filertk-1.0.0/PKG-INFO

@@ -0,0 +1,74 @@
+Metadata-Version: 2.4
+Name: filertk
+Version: 1.0.0
+Summary: package used for rewriting certain aspects of text in files
+Author-email: Dylan Santos <dasantos726@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/dylanasantos/filertk
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.14
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: colorama>=0.4.6
+Dynamic: license-file
+
+# filertk 1.0.0
+Filertk is a simple terminal-based system that allows for quick basic file rewrite instructions that would take excessive work by hand, such as renaming variables.\
+\
+**To activate:** simply write "filertk" within your terminal and paste in the file directory you want to modify. Afterwards input your commands when requested.\
+- All file modifications are located in a directory inside of <ins>filertk\results</ins>
+
+## Commands
+filertk has 17 different commands displayed at each launch of the program. These commands are used to specify the desired modifications to the file or to the results directory.
+
+> [!NOTE]
+> The general order of commands used does not matter. However, the identifiers you provide are a first-come-first-serve basis.
+
+### Identifiers
+Identifiers are used to inform filertk what exactly you are referencing in your commands, such as the text you want to find or replace.
+
+- **Name Identifiers "":** Used for specifying the text to match, rewrite, or exclude
+- **Range Identifiers (x-y):** Used for specifying the lines from start-end you want to either exclude or include
+<br><br>
+
+### Special Commands
+- **exit:** closes filertk program
+- **clear_res:** clears the entire file results directory, first displays all files being deleted and requests for permission
+- **clear "filename.ext":** clears the specified file from results directory, first displays file direcotry and requests for permission
+<br><br>
+
+### Reader Commands
+Commands used to inform filertk how the text to match should be interpereted.
+
+> [!NOTE]
+> Reader Commands do not handle casing sensitivity, only character matching, refer to Casing Commands for more info.
+
+- **match "text":** finds any words that contain the text
+- **exact "text":** only finds words that contain the exact text
+- **excluding "text" or (start-end):** excludes any matches of the word found (only used in match type) or ignores lines specified 
+- **from (start-end):** will only read/modify the lines specified (start and end are inclusive)
+<br><br>
+
+### Writer Commands
+Commands used to inform filertk how the matches found should be rewritten.
+
+- **with "text":** removes and replaces the new text only with what matched (ex: demo_1 -> new_1)
+- **replace "text":** removes the entire text with the match found and inserts the new text (ex: demo_1 -> new)
+- **r_append "text":** appends the new text to the end of the match (ex: demo_1 -> demo_1new)
+- **f_append "text":** appends the new text to the front of the match (ex: demo_1 -> newdemo_1)
+<br><br>
+
+### Casing Commands
+Commands used to inform filertk how the text casing should be handled.
+
+- **!ignore_case:** ignores the casing of matches, any and all capitalizations are treated the same via the reader but are replaced by the exact casing of the writer identifier input.
+- **!keep_case:** will attempt to copy the exact casing via index-by-index (this is only recommended for matches and writes of the same size), will automatically lowercase and uppercase all chars regardless if reader and writer identifier sizes match.<br>
+- **!camel_case:** given the exact casing of the user's writer identifier, will replace all words with said input UNLESS the match if full capitalized or lowercased. If so, it will match the casing.
+
+### File Copy Command
+Commands used on how the file modifications should be handled.
+
+- **~h_copy:** creates a copy of the exact file name inside of the results directory. (filertk defaults to this, but will display a warning if defaulted)
+- **~modify:** modifies the original file specified, creates an emergency backup inside of the results directory if the output is unwanted.
+- **~s_copy "filename.ext":** creates a copy of the file with a custom name provided inside of the results directory.

filertk-1.0.0/README.md

@@ -0,0 +1,59 @@
+# filertk 1.0.0
+Filertk is a simple terminal-based system that allows for quick basic file rewrite instructions that would take excessive work by hand, such as renaming variables.\
+\
+**To activate:** simply write "filertk" within your terminal and paste in the file directory you want to modify. Afterwards input your commands when requested.\
+- All file modifications are located in a directory inside of <ins>filertk\results</ins>
+
+## Commands
+filertk has 17 different commands displayed at each launch of the program. These commands are used to specify the desired modifications to the file or to the results directory.
+
+> [!NOTE]
+> The general order of commands used does not matter. However, the identifiers you provide are a first-come-first-serve basis.
+
+### Identifiers
+Identifiers are used to inform filertk what exactly you are referencing in your commands, such as the text you want to find or replace.
+
+- **Name Identifiers "":** Used for specifying the text to match, rewrite, or exclude
+- **Range Identifiers (x-y):** Used for specifying the lines from start-end you want to either exclude or include
+<br><br>
+
+### Special Commands
+- **exit:** closes filertk program
+- **clear_res:** clears the entire file results directory, first displays all files being deleted and requests for permission
+- **clear "filename.ext":** clears the specified file from results directory, first displays file direcotry and requests for permission
+<br><br>
+
+### Reader Commands
+Commands used to inform filertk how the text to match should be interpereted.
+
+> [!NOTE]
+> Reader Commands do not handle casing sensitivity, only character matching, refer to Casing Commands for more info.
+
+- **match "text":** finds any words that contain the text
+- **exact "text":** only finds words that contain the exact text
+- **excluding "text" or (start-end):** excludes any matches of the word found (only used in match type) or ignores lines specified 
+- **from (start-end):** will only read/modify the lines specified (start and end are inclusive)
+<br><br>
+
+### Writer Commands
+Commands used to inform filertk how the matches found should be rewritten.
+
+- **with "text":** removes and replaces the new text only with what matched (ex: demo_1 -> new_1)
+- **replace "text":** removes the entire text with the match found and inserts the new text (ex: demo_1 -> new)
+- **r_append "text":** appends the new text to the end of the match (ex: demo_1 -> demo_1new)
+- **f_append "text":** appends the new text to the front of the match (ex: demo_1 -> newdemo_1)
+<br><br>
+
+### Casing Commands
+Commands used to inform filertk how the text casing should be handled.
+
+- **!ignore_case:** ignores the casing of matches, any and all capitalizations are treated the same via the reader but are replaced by the exact casing of the writer identifier input.
+- **!keep_case:** will attempt to copy the exact casing via index-by-index (this is only recommended for matches and writes of the same size), will automatically lowercase and uppercase all chars regardless if reader and writer identifier sizes match.<br>
+- **!camel_case:** given the exact casing of the user's writer identifier, will replace all words with said input UNLESS the match if full capitalized or lowercased. If so, it will match the casing.
+
+### File Copy Command
+Commands used on how the file modifications should be handled.
+
+- **~h_copy:** creates a copy of the exact file name inside of the results directory. (filertk defaults to this, but will display a warning if defaulted)
+- **~modify:** modifies the original file specified, creates an emergency backup inside of the results directory if the output is unwanted.
+- **~s_copy "filename.ext":** creates a copy of the file with a custom name provided inside of the results directory.

filertk-1.0.0/pyproject.toml

@@ -0,0 +1,24 @@
+[project]
+name = "filertk"
+version = "1.0.0"
+dependencies = [
+  "colorama>=0.4.6"
+]
+authors = [
+  { name="Dylan Santos", email="dasantos726@gmail.com" },
+]
+description = "package used for rewriting certain aspects of text in files"
+readme = "README.md"
+requires-python = ">=3.14"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent",
+]
+license = "MIT"
+license-files = ["LICEN[CS]E*"]
+
+[project.scripts]
+filertk = "filertk.main:main"
+
+[project.urls]
+Homepage = "https://github.com/dylanasantos/filertk"

filertk-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

filertk-1.0.0/src/filertk/command_reader.py

@@ -0,0 +1,187 @@
+import re
+from enum import Enum
+
+class ReadType(Enum):
+    """Enum of all reader OrderTypes"""
+    MATCH = 1
+    EXACT = 2
+
+class WriteType(Enum):
+    """Enum of all Writer OrderTypes"""
+    WITH = 1
+    REPLACE = 2
+    R_APPEND = 3
+    F_APPEND = 4
+
+class CopyType(Enum):
+    """Enum of all Copy OrderTypes"""
+    HARD = 1
+    SOFT = 2
+    MODIFY = 3
+
+class IdentifierType(Enum):
+    """Enum of all identifier OrderTypes"""
+    READER = 1
+    WRITER = 2
+    FROM = 3
+    EXCLUDING = 4
+
+class CaseType(Enum):
+    """Enum of all Casing OrderTypes"""
+    KEEP = 1
+    IGNORE = 2
+    CAMEL = 3
+
+class OrderType(Enum):
+    READER = 1
+    WRITER = 2
+    COPY = 3
+    IDN = 4
+    CASE = 5
+
+OrderType.Read = ReadType
+OrderType.Write = WriteType
+OrderType.Copy = CopyType
+OrderType.Idn = IdentifierType
+OrderType.Case = CaseType
+
+class CommandReader:
+    TOKEN_PATTERN = r'"[^"]*"|\S+'
+
+    EXIT_CMD = "exit"
+    FULL_CLEAR_CMD = "clear_res"
+    CLEAR_CMD = "clear"
+
+    ARG_TYPES = {
+        "match": ReadType.MATCH,
+        "exact": ReadType.EXACT,
+
+        "excluding": IdentifierType.EXCLUDING,
+        "from": IdentifierType.FROM,
+
+        "with": WriteType.WITH,
+        "replace": WriteType.REPLACE,
+        "r_append": WriteType.R_APPEND,
+        "f_append": WriteType.F_APPEND,
+
+        "!keep_case": CaseType.KEEP,
+        "!ignore_case": CaseType.IGNORE,
+        "!camel_case": CaseType.CAMEL,
+
+        "~h_copy": CopyType.HARD,
+        "~modify": CopyType.MODIFY,
+        "~s_copy": CopyType.SOFT
+    }
+
+    def __init__(self, commands: list[str]):
+        """Tokenizes & verifies commands given to terminal"""
+        self.__args = commands
+        self.__instructions = { OrderType.IDN: {}}
+        self.__identifier_queue: list[IdentifierType] = []
+
+        self.set_instructions()
+
+
+    @staticmethod
+    def is_name(potential_name: str) -> bool:
+        """Used for checking if a name identifier token is provided"""
+        if(len(potential_name) <= 2): return False
+
+        if(potential_name[0] == '"' and potential_name[-1] == '"'): return True
+            
+        return False
+
+
+    @staticmethod
+    def is_range(potential_range: str) -> bool:
+        """Used for checking if a range identifier token is provided"""
+
+        if(potential_range[0] == "(" and potential_range[-1] == ")"): return True
+        
+        return False
+
+
+    @staticmethod
+    def get_range_nums(range_token: str) -> list[int, int]:
+        """grabs ranges for FROM identifier, returns [start, end]"""
+
+        numbers = re.findall(r'\d+', range_token)
+        numbers = [int(num) for num in numbers]
+
+        if(len(numbers) != 2):
+            raise ValueError(
+                "CommandReader get_rane_nums() was given an invalid amount of range values provided for FROM, received: " 
+                + len(numbers))
+
+        return numbers
+
+
+    def handle_identifier(self, idn: str) -> None:
+        """handles identifier queue status & allocation of identifiers with corresponding type"""
+
+        if(len(idn) < 3):
+            raise ValueError("CommandReader handle_identifier() found an identifier with not enough characters.\n"
+                + "[identifier: " + idn + "]\n"
+                + "make sure identifiers have a starting and ending quotation, with all characters inbetween")
+
+        if(self.__identifier_queue == 0):
+            raise ValueError("CommandReader handle_identifier() found an identifier but did not know where to place it\n"
+                + "\t[identifier: " + idn + "]\n"
+                + "make sure your identifiers have an identifier type (readers, writers, from, excluding) before writing them")
+
+        if(idn[0] != '"' or idn[-1] != '"'):
+            raise ValueError("CommandReader handle_identifier found an identifier lacking proper quotations.\n" 
+                + "\t[identifier: " + idn + "]\n"
+                + "make sure all identifiers have leading and trailing quotations, with all characters inbetween")
+
+        self.__instructions[OrderType.IDN][self.__identifier_queue[0]] = idn[1 : -1] #to remove quotations from checks
+        self.__identifier_queue.pop(0)
+
+
+    def set_instructions(self):
+        """Reads through the args list and updates the instructions dictionary"""
+
+        for arg in self.__args:
+            arg_type = CommandReader.ARG_TYPES.get(arg)
+
+            if(arg_type):
+                match arg_type:
+                    case ReadType():
+                        self.__instructions[OrderType.READER] = arg_type
+                        self.__identifier_queue.append(OrderType.READER)
+
+                    case WriteType():
+                        self.__instructions[OrderType.WRITER] = arg_type
+                        self.__identifier_queue.append(OrderType.WRITER)
+
+                    case CopyType():
+                        self.__instructions[OrderType.COPY] = arg_type
+
+                        if(arg_type == CopyType.SOFT):
+                            self.__identifier_queue.append(OrderType.COPY)
+
+                    case IdentifierType():
+                        self.__identifier_queue.append(arg_type)
+
+                    case CaseType():
+                        self.__instructions[OrderType.CASE] = arg_type
+
+            elif(CommandReader.is_name(arg)):
+                self.handle_identifier(arg)
+
+            elif(CommandReader.is_range(arg)):
+                if(self.__identifier_queue[0] == IdentifierType.EXCLUDING):
+                    self.__instructions[OrderType.IDN][IdentifierType.EXCLUDING] = CommandReader.get_range_nums(arg)
+                    self.__identifier_queue.pop(0)
+                else:
+                    self.__instructions[OrderType.IDN][IdentifierType.FROM] = CommandReader.get_range_nums(arg)
+                    self.__identifier_queue.pop(0)
+
+            else:
+                raise ValueError("CommandReader set_instructions() detected an unexpected token, only use the token types specified"
+                    + " or ensure text specifications use \" before and after (ex: \"text\")\n"
+                    + "\t[token interpereted: " + arg + "]")
+
+
+    def get_instructions(self):
+        return self.__instructions

filertk-1.0.0/src/filertk/file_manager.py

@@ -0,0 +1,335 @@
+import shutil
+import re
+
+from colorama import Fore, Style
+
+from pathlib import Path
+
+from .command_reader import CommandReader, OrderType
+
+class DataFormatter:
+    """Used for cleaner and easier access of individual lines and words inside said lines"""
+
+    def __init__(self, line_number=0, words=""):
+        self.line_number = line_number
+        self.words: list[str] = [text for text in re.split(r'(\s+)', words) if text]
+
+
+ 
+class WordMatches:
+    """Used for cleaner and easier access of individual word matches"""
+
+    def __init__(self, word: str, line_number=0, cpos=0):
+        self.word = word
+        self.line_number = line_number
+        self.cpos = cpos
+
+    
+
+class FileManager:
+    """Reviews tokenized instructions and documents changes to file"""
+
+    RESULTS_DIR = Path(__file__).resolve().parent / "results"
+    ACCEPT_ANY_CASE = (OrderType.Case.KEEP, OrderType.Case.IGNORE, OrderType.Case.CAMEL)
+
+    def __init__(self, original: Path, commands: CommandReader):
+        self.__path = original
+        self.__commands = commands.get_instructions()
+
+        self.__original_data: list[DataFormatter] = []
+        self.read_original()
+
+        self.__matches: list[WordMatches] = []
+        self.__instance_changes_ctr = 0
+        self.__camel_ref = self.__commands[OrderType.IDN][OrderType.WRITER] if self.__commands.get(OrderType.CASE) == OrderType.Case.CAMEL else None
+
+        self.interperit_matcher(self.__commands.get(OrderType.READER))
+        self.interperit_writer(self.__commands.get(OrderType.WRITER))
+        self.write_to_file()
+
+
+
+    def __search_match(self, word: str) -> bool:
+        """searches for a match based off of casing condition issued and whether it matches the text"""
+
+        case_rule = self.__commands.get(OrderType.CASE)
+
+        match(self.__commands[OrderType.READER]):
+            case(OrderType.Read.MATCH):
+                if(case_rule in FileManager.ACCEPT_ANY_CASE):
+                    return self.__commands[OrderType.IDN][OrderType.READER].lower() in word.lower()
+
+                else:
+                    return self.__commands[OrderType.IDN][OrderType.READER] in word
+
+            case(OrderType.Read.EXACT):
+                return self.__commands[OrderType.IDN][OrderType.READER] == word
+            
+        raise ValueError("file_manager __search_match() was called with an invalid READER type")
+
+
+
+    def __get_word_index(self, word: str) -> int:
+        """returns index of match if found inside of word"""
+        
+        search: str = self.__commands[OrderType.IDN][OrderType.READER]
+        
+        case_rule = self.__commands.get(OrderType.CASE)
+        if(case_rule in FileManager.ACCEPT_ANY_CASE): 
+            return word.lower().find(search.lower())
+
+        return word.find(search)
+
+
+
+    def __set_match_casing(self, word: str) -> str:
+        """checks if the match inside a word provided is either fully capitalized or lowercased, and returns a string according to said capitalization"""
+
+        match_index = self.__get_word_index(word)
+        word_match = word[match_index : match_index + len(self.__commands[OrderType.IDN][OrderType.READER])]
+
+        if(word_match.isupper()):
+            return self.__commands[OrderType.IDN][OrderType.WRITER].upper()
+
+        if(word_match.islower()):
+            return self.__commands[OrderType.IDN][OrderType.WRITER].lower()
+
+        return self.__commands[OrderType.IDN][OrderType.WRITER]
+
+    
+
+    def __with_formatter(self, word: str) -> str:
+        """returns the modified word under the with formatting context"""
+
+        replacement = ""
+        index = self.__get_word_index(word)
+        to_insert = self.__commands[OrderType.IDN][OrderType.WRITER]
+
+        if(index > -1):
+            replacement = word[0 : index] + to_insert + word[index + len(self.__commands[OrderType.IDN][OrderType.READER]) : ]
+            self.__instance_changes_ctr += 1
+
+            return replacement
+        
+        raise ValueError("file_manager __with_formatter() was ordered to modify a word that does not match reader [unexpected behavior]"
+            + "\tpossibly an error with match detection?\n" +
+            "[reader idn: " + self.__commands[OrderType.IDN][OrderType.READER] + " word: " + word)
+
+
+
+    def __replace_formatter(self, word: str) -> str:
+        """returns the modified word under the replace formatting context"""
+
+        index = self.__get_word_index(word)
+        to_insert = self.__commands[OrderType.IDN][OrderType.WRITER]
+
+        if(index > -1):
+            self.__instance_changes_ctr += 1
+            return to_insert
+
+        raise ValueError("file_manager __replace_formatter() was ordered to modify a word that does not match reader [unexpected behavior]"
+            + "\tpossibly an error with match detection?\n" +
+            "[reader idn: " + self.__commands[OrderType.IDN][OrderType.READER] + " word: " + word)
+
+
+
+    def __append_formatter(self, word: str) -> str:
+        """returns the modified word under the append formatting context"""
+
+        replacement = ""
+        index = self.__get_word_index(word)
+        to_insert = self.__commands[OrderType.IDN][OrderType.WRITER]
+
+        if(index > -1):
+            word_end = index + len(word)
+
+            if(self.__commands.get(OrderType.Write.R_APPEND)):
+                replacement = word[0 : word_end] + to_insert + word[(word_end + len(to_insert)) : ]
+            else:
+                replacement = word[0 : index] + to_insert + word[index + len(to_insert) : ]
+
+            self.__instance_changes_ctr += 1
+            return replacement
+
+        raise ValueError("file_manager __append_formatter() was ordered to modify a word that does not match reader [unexpected behavior]"
+            + "\tpossibly an error with match detection?\n" +
+            "[reader idn: " + self.__commands[OrderType.IDN][OrderType.READER] + " word: " + word)
+
+
+
+    def __update_keep_casing(self, match: WordMatches) -> WordMatches:
+        """Updates the casing of writer to properly replace text off of KEEP request, returns match inserted (no changes)"""
+        
+        idn: dict[OrderType] = self.__commands[OrderType.IDN]
+        original_word: str = self.__original_data[match.line_number - 1].words[match.cpos]
+
+        new_writer_word = idn[OrderType.WRITER]
+
+        if(original_word.isupper()): #picks up on capitalizations automatically
+            idn[OrderType.WRITER] = new_writer_word.upper()
+            return match
+
+        for i in range(min(len(original_word), len(idn[OrderType.WRITER]))):
+            writer_char = new_writer_word[i]
+            original_char = original_word[i]
+            
+            if(original_char.isalpha() and writer_char.isalpha()):
+                if(original_char.isupper()):
+                    new_writer_word =  new_writer_word[ : i] + writer_char.upper() + new_writer_word[i + 1: ]
+                else:
+                    new_writer_word = new_writer_word[ : i] + writer_char.lower() + new_writer_word[i + 1: ]
+
+        idn[OrderType.WRITER] = new_writer_word
+        return match
+
+
+
+    def __update_camel_casing(self, match: WordMatches) -> WordMatches:
+        """Updates the casing of the new writing text to match if it is any sort of camel type, including Titles, StanDard, lowercase, and FULL_CAPS"""
+
+        capital_ctr = 0
+        idn: str = self.__commands[OrderType.IDN]
+
+        idn[OrderType.WRITER] = self.__camel_ref
+        original_word: str = self.__original_data[match.line_number - 1].words[match.cpos]
+
+        casing_change = self.__set_match_casing(match.word)
+
+        if(casing_change != idn[OrderType.WRITER]):
+            idn[OrderType.WRITER] = casing_change
+            return match
+
+        for i in range(len(original_word)):
+            original_char = original_word[i]
+
+            if(original_char.isupper()):
+                capital_ctr += 1
+
+            if(capital_ctr > 1): #any text with > 1 capitalized chars is presumed to be a CamelCase of some sort
+                break
+        return match
+
+
+
+    def __create_backup(self) -> Path:
+        """used for creating backup files of original file"""
+
+        backup_path = self.RESULTS_DIR / (self.__path.stem + "_backup" + self.__path.suffix)
+        shutil.copy2(self.__path, backup_path)
+
+        return backup_path
+
+
+    
+    def read_original(self):
+        """reads thorugh the original file provided"""
+        line_num = 0
+
+        with open(self.__path, 'r') as file:
+            for line in file:
+                line_num += 1
+                self.__original_data.append(DataFormatter(line_num, line))
+
+
+
+    def interperit_matcher(self, match_type: OrderType.Read):
+        """scans file for matches based off of match type specifier to be modified later"""
+
+        validator = lambda arg: False
+
+        range_based = self.__commands[OrderType.IDN].get(OrderType.Idn.FROM)
+        excluding = self.__commands[OrderType.IDN].get(OrderType.Idn.EXCLUDING)
+
+        excluding_handler = lambda _, __: False
+        if(isinstance(excluding, str)):
+            excluding_handler = lambda arg, _: excluding == arg #range arg in unwated in word exclude type
+
+        elif(isinstance(excluding, list)):
+            excluding_handler = lambda _, arg: arg < excluding[0] or arg > excluding[1] #word arg is unwanted in range exclude type
+
+
+        for data in self.__original_data:
+            for word_pos in range(len(data.words)):
+                word = data.words[word_pos]
+
+                if(range_based and (data.line_number < range_based[0] or data.line_number > range_based[1])):
+                    break
+
+                if(excluding_handler(word, data.line_number)):
+                    continue
+                
+                if(self.__search_match(word)): 
+                    self.__matches.append(WordMatches(word, data.line_number, word_pos))
+
+
+
+    def interperit_writer(self, write_type: OrderType.WRITER):
+        """modifies matches found in file to specified write type"""
+
+        formatter: str = None
+        match(write_type):
+            case OrderType.Write.WITH:
+                formatter = lambda match: self.__with_formatter(match.word)
+
+            case OrderType.Write.REPLACE:
+                formatter = lambda match: self.__replace_formatter(match.word)
+
+            case OrderType.Write.APPEND:
+                formatter = lambda match: self.__append_formatter(match.word)
+
+        handler: str = formatter
+        if(self.__commands.get(OrderType.CASE) == OrderType.Case.KEEP):
+            if(len(self.__commands[OrderType.IDN][OrderType.WRITER]) != len(self.__commands[OrderType.IDN][OrderType.READER])):
+                print(Fore.YELLOW + "WARNING: !casing_kp [keep casing to match] request was made, but reader and writer identifiers differ in size.\n" \
+                + "\tResults may not be as expected due to size mismatch." + Style.RESET_ALL)
+
+            handler = lambda match: formatter(self.__update_keep_casing(match))
+
+        if(self.__commands.get(OrderType.CASE) == OrderType.Case.CAMEL):
+            handler = lambda match: formatter(self.__update_camel_casing(match))
+            
+        for match in self.__matches:
+            match_result: WordMatches = WordMatches(word=handler(match))
+
+            while(self.__search_match(match_result.word)):
+                match_result.word = handler(match_result)
+
+            self.__original_data[match.line_number - 1].words[match.cpos] = match_result.word
+        
+        print(f"{Fore.GREEN}{self.__instance_changes_ctr} instance changes made in \033]8;;{self.__path}\033\\'{self.__path}\033]8;;\033\\'")
+
+
+    def write_to_file(self):
+        """takes all data collected & modified from original file & writes it into instructed file"""
+
+        file_mode = self.__commands.get(OrderType.COPY)
+        file_path: Path
+
+        if(not file_mode):
+            print(Fore.YELLOW + "WARNING: FileManager write_to_file() detected no copy command from command list.\n"
+                + "\tFileManager write_to_file() is defaulting to hard copy [~h_copy]" + Style.RESET_ALL)
+            
+            file_mode = OrderType.Copy.HARD
+
+        match(file_mode):
+            case OrderType.Copy.HARD:
+                file_path = FileManager.RESULTS_DIR / self.__path.name
+
+            case OrderType.Copy.SOFT:
+                requested_name = self.__commands[OrderType.IDN].get(OrderType.COPY)
+
+                if(not requested_name):
+                    raise ValueError("FileManager write_to_file() was provided with ~s_copy() but recieved no identifier for file name; did you specify one?\n"
+                        + "\t~s_copy requires a name for the file, make sure you wrote one!")
+                file_path = FileManager.RESULTS_DIR / requested_name
+
+            case OrderType.Copy.MODIFY:
+                file_path = self.__path
+                backup = self.__create_backup()
+
+                print(Fore.GREEN + "~modify copy type created a backup file at:", backup)
+
+        with open(file_path, 'w') as file:
+            for data in self.__original_data:
+                for word in data.words:
+                    file.write(word)

filertk-1.0.0/src/filertk/main.py

@@ -0,0 +1,143 @@
+import re 
+import sys
+
+from colorama import Fore, Style
+
+from pathlib import Path 
+
+from .file_manager import FileManager 
+from .command_reader import CommandReader
+
+INSTRUCTIONS = """fileformatter cmdlet: 
+    SPECIAL: 
+        exit: exit program early 
+        clear_res: clears results file
+        clear "file.ext": deletes file from results/
+
+    READ TYPES: 
+        match "text": find words that contain the text 
+        exact "text": words that only meet the exact input 
+        excluding "text" or (num): do not include items of the exact syntax or line number (use for match or from) 
+        from (start-end): only modify lines specified 
+
+    WRITE TYPES: 
+        with "text": removes only the text that matches with new text 
+        replace "text": replaces matches with new text 
+        r_append "text": appends text to the end of the matches
+        f_append "text": appends text to the front of the matches
+
+    CASING TYPES:
+        !keep_case: finds read matches ignoring casing and writes to the same casing style as the replacing text
+        !ignore_case: finds read matches ignoring casing, writes each match the same as write casing specified
+        !camel_case: with the exact casing of the write provided, it is utilized on all camel cased matches, otherwise fully lowercased/uppercased
+
+    FILE COPY TYPES:
+        ~h_copy: creates a copy of the same file name in results folder [defaulted to this]
+        ~modify: modified the original file (a backup is creates in results/) 
+        ~s_copy "name": creates a copy of the same file with a custom name 
+
+    Writing Commands: 
+        simply combine the commands you want in no necessary order, for example: 
+            from (1-10) excluding "var_name2" match "var_name" with "new_name" ~h_copy 
+"""
+
+def full_res_clear() -> None:
+    """Clears every file inside of the results folder"""
+
+    to_delete = [] 
+
+    for file_path in FileManager.RESULTS_DIR.iterdir(): 
+        print("\trequested delete: ", file_path) 
+        to_delete.append(file_path) 
+
+    validate = input("Are you sure you want to delete all these files? [Y/N]: ").strip() 
+
+    if(validate.lower() == "y"): 
+        for file in to_delete: 
+            file.unlink(missing_ok=True) 
+            print('\t' + str(file) + " deleted successfuly") 
+        print(f"{Fore.GREEN}All files in results deleted!{Style.RESET_ALL}") 
+    else: 
+        print(f"{Fore.GREEN}clear_res was canceled{Style.RESET_ALL}") 
+
+
+def specify_res_clear(args: list[str]) -> None:
+    """Analyzes the tokenized input provided to allocate the file name specified"""
+
+    if(len(args) < 2): 
+        print(f"{Fore.YELLOW}filertk clear command was used, but could not find a file identifier{Style.RESET_ALL}")
+        return
+
+    if(len(args) > 2):
+        print(f"{Fore.YELLOW}filertk clear command was used with too many identifiers; only provide the clear command, and the file name inside the reuslts folder{Style.RESET_ALL}")
+        return
+    
+    file_idn = args[0] if args[0] != CommandReader.CLEAR_CMD else args[1]
+    if(not CommandReader.is_name(file_idn)):
+        print(f"{Fore.YELLOW}file identifier requires quotations around to ensure it's properly retrieved, make sure there is double quotes both at the front and end of your file's name{Style.RESET_ALL}")
+
+    else:
+        to_clear: Path = FileManager.RESULTS_DIR / file_idn[1 : -1]
+
+        if(to_clear.exists):
+            to_clear.unlink(missing_ok=True)
+            print(f"{Fore.GREEN}{to_clear} successfully deleted{Style.RESET_ALL}")
+
+        else:
+            print(f"{Fore.YELLOW}{to_clear} file was not found; are you sure you typed it correctly?{Style.RESET_ALL}")
+    return
+
+
+def read_input(instructions: str, expect_file_dir=False) -> str: 
+    user_input = input(instructions)
+    result: list[str] = re.findall(CommandReader.TOKEN_PATTERN, user_input)
+
+    if(CommandReader.EXIT_CMD in result):
+        print("exit called, closing filertk...")
+        sys.exit()
+
+    if(CommandReader.FULL_CLEAR_CMD in result):
+        full_res_clear()
+        return
+
+    if(CommandReader.CLEAR_CMD in result):
+        specify_res_clear(result)
+        return
+
+    if(expect_file_dir): 
+        if(CommandReader.is_name(user_input)):
+            return user_input[1 : -1]
+        return user_input
+    
+    return result
+
+
+def main(): 
+    print(INSTRUCTIONS) 
+
+    user_input: str
+    file_path: Path
+
+    while(True):
+        user_input = read_input("Enter a file directory: ", expect_file_dir=True)
+
+        if(user_input):
+            file_path = Path(user_input)
+            if(file_path.exists()): break
+        else:
+            continue
+
+        print(f"{Fore.YELLOW}\nInvalid file path provided! Make sure your file path is correct\n" 
+            + f"\t[provided path: {file_path}{Style.RESET_ALL}]") 
+
+    print("path", file_path, "accepted") 
+
+    args: list[str] | bool = None
+    while(not args):
+        args = read_input("Enter command instructions:$// ")
+
+    reader = CommandReader(args) 
+    manager = FileManager(file_path, reader) 
+
+if __name__ == "__main__": 
+    main() 

filertk-1.0.0/src/filertk.egg-info/PKG-INFO

@@ -0,0 +1,74 @@
+Metadata-Version: 2.4
+Name: filertk
+Version: 1.0.0
+Summary: package used for rewriting certain aspects of text in files
+Author-email: Dylan Santos <dasantos726@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/dylanasantos/filertk
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.14
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: colorama>=0.4.6
+Dynamic: license-file
+
+# filertk 1.0.0
+Filertk is a simple terminal-based system that allows for quick basic file rewrite instructions that would take excessive work by hand, such as renaming variables.\
+\
+**To activate:** simply write "filertk" within your terminal and paste in the file directory you want to modify. Afterwards input your commands when requested.\
+- All file modifications are located in a directory inside of <ins>filertk\results</ins>
+
+## Commands
+filertk has 17 different commands displayed at each launch of the program. These commands are used to specify the desired modifications to the file or to the results directory.
+
+> [!NOTE]
+> The general order of commands used does not matter. However, the identifiers you provide are a first-come-first-serve basis.
+
+### Identifiers
+Identifiers are used to inform filertk what exactly you are referencing in your commands, such as the text you want to find or replace.
+
+- **Name Identifiers "":** Used for specifying the text to match, rewrite, or exclude
+- **Range Identifiers (x-y):** Used for specifying the lines from start-end you want to either exclude or include
+<br><br>
+
+### Special Commands
+- **exit:** closes filertk program
+- **clear_res:** clears the entire file results directory, first displays all files being deleted and requests for permission
+- **clear "filename.ext":** clears the specified file from results directory, first displays file direcotry and requests for permission
+<br><br>
+
+### Reader Commands
+Commands used to inform filertk how the text to match should be interpereted.
+
+> [!NOTE]
+> Reader Commands do not handle casing sensitivity, only character matching, refer to Casing Commands for more info.
+
+- **match "text":** finds any words that contain the text
+- **exact "text":** only finds words that contain the exact text
+- **excluding "text" or (start-end):** excludes any matches of the word found (only used in match type) or ignores lines specified 
+- **from (start-end):** will only read/modify the lines specified (start and end are inclusive)
+<br><br>
+
+### Writer Commands
+Commands used to inform filertk how the matches found should be rewritten.
+
+- **with "text":** removes and replaces the new text only with what matched (ex: demo_1 -> new_1)
+- **replace "text":** removes the entire text with the match found and inserts the new text (ex: demo_1 -> new)
+- **r_append "text":** appends the new text to the end of the match (ex: demo_1 -> demo_1new)
+- **f_append "text":** appends the new text to the front of the match (ex: demo_1 -> newdemo_1)
+<br><br>
+
+### Casing Commands
+Commands used to inform filertk how the text casing should be handled.
+
+- **!ignore_case:** ignores the casing of matches, any and all capitalizations are treated the same via the reader but are replaced by the exact casing of the writer identifier input.
+- **!keep_case:** will attempt to copy the exact casing via index-by-index (this is only recommended for matches and writes of the same size), will automatically lowercase and uppercase all chars regardless if reader and writer identifier sizes match.<br>
+- **!camel_case:** given the exact casing of the user's writer identifier, will replace all words with said input UNLESS the match if full capitalized or lowercased. If so, it will match the casing.
+
+### File Copy Command
+Commands used on how the file modifications should be handled.
+
+- **~h_copy:** creates a copy of the exact file name inside of the results directory. (filertk defaults to this, but will display a warning if defaulted)
+- **~modify:** modifies the original file specified, creates an emergency backup inside of the results directory if the output is unwanted.
+- **~s_copy "filename.ext":** creates a copy of the file with a custom name provided inside of the results directory.

filertk-1.0.0/src/filertk.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+LICENSE
+README.md
+pyproject.toml
+src/filertk/__init__.py
+src/filertk/command_reader.py
+src/filertk/file_manager.py
+src/filertk/main.py
+src/filertk.egg-info/PKG-INFO
+src/filertk.egg-info/SOURCES.txt
+src/filertk.egg-info/dependency_links.txt
+src/filertk.egg-info/entry_points.txt
+src/filertk.egg-info/requires.txt
+src/filertk.egg-info/top_level.txt

filertk-1.0.0/src/filertk.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

filertk-1.0.0/src/filertk.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+filertk = filertk.main:main

filertk-1.0.0/src/filertk.egg-info/requires.txt

@@ -0,0 +1 @@
+colorama>=0.4.6

filertk-1.0.0/src/filertk.egg-info/top_level.txt

@@ -0,0 +1 @@
+filertk