quick-ini 3.0__tar.gz → 3.1.4__tar.gz

quick_ini-3.1.4/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 OllieZ-Mods
+
+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.

quick_ini-3.1.4/PKG-INFO

@@ -0,0 +1,72 @@
+Metadata-Version: 2.4
+Name: quick_ini
+Version: 3.1.4
+Summary: A library for reading from and writing to .ini formatted files
+Home-page: https://github.com/olliez-mods/Quick-Ini
+Author: OllieZ-Mods
+Author-email: socksinthewash@gmail.com
+Project-URL: Bug Reports, https://github.com/olliez-mods/Quick-Ini/issues
+Project-URL: Source, https://github.com/olliez-mods/Quick-Ini
+Keywords: ini config configuration parser file
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license-file
+Dynamic: project-url
+Dynamic: requires-python
+Dynamic: summary
+
+# QuickINI
+
+A simple and fast INI file parser for Python with support for loading from URLs and automatic type conversion.
+
+## Installation
+
+```bash
+pip install quickini
+```
+
+## Quick Start
+
+```python
+from quickini import QuickIni
+
+# Load from file
+QuickIni.load_file("config.ini")
+
+# Load from URL
+QuickIni.load_file("https://example.com/config.ini")
+
+# Get values with automatic type conversion
+debug = QuickIni.get_value("debug", False)  # Returns boolean
+port = QuickIni.get_value("port", 8080)     # Returns integer
+
+# Write values back to file
+QuickIni.write_value("new_setting", "value", add_if_not_found=True)
+```
+
+## Features
+
+- Load INI files from local filesystem or URLs
+- Automatic type conversion (int, float, bool, str)
+- Write values back to files
+- Error handling with detailed messages
+- Static class design for easy use across modules

quick_ini-3.1.4/README.md

@@ -0,0 +1,36 @@
+# QuickINI
+
+A simple and fast INI file parser for Python with support for loading from URLs and automatic type conversion.
+
+## Installation
+
+```bash
+pip install quickini
+```
+
+## Quick Start
+
+```python
+from quickini import QuickIni
+
+# Load from file
+QuickIni.load_file("config.ini")
+
+# Load from URL
+QuickIni.load_file("https://example.com/config.ini")
+
+# Get values with automatic type conversion
+debug = QuickIni.get_value("debug", False)  # Returns boolean
+port = QuickIni.get_value("port", 8080)     # Returns integer
+
+# Write values back to file
+QuickIni.write_value("new_setting", "value", add_if_not_found=True)
+```
+
+## Features
+
+- Load INI files from local filesystem or URLs
+- Automatic type conversion (int, float, bool, str)
+- Write values back to files
+- Error handling with detailed messages
+- Static class design for easy use across modules

{quick_ini-3.0 → quick_ini-3.1.4}/pyproject.toml

@@ -1,3 +1,3 @@
-[build-system]
-requires = ["setuptools", "wheel"]
+[build-system]
+requires = ["setuptools", "wheel"]
 build-backend = "setuptools.build_meta"

{quick_ini-3.0 → quick_ini-3.1.4}/quick_ini/__init__.py

@@ -1 +1 @@
-from .quick_ini import QuickIni
+from .quick_ini import QuickIni

{quick_ini-3.0 → quick_ini-3.1.4}/quick_ini/quick_ini.py

@@ -1,229 +1,230 @@
-from urllib.parse import urlparse
-from typing import Type, Any
-import os
-
-class QuickIni:
-    parsed_ini:dict[str,str|int|bool|float|None] = {}
-    loaded_file_path:str=None
-    auto_type_convert_g:bool=True
-    error_message:str = ""
-    web_file:str = None
-
-    @staticmethod
-    def grab_from_url(url:str) -> bool:
-        import urllib.request, urllib.error
-        try:
-            with urllib.request.urlopen(url) as response:
-                if(response.status == 200):
-                    QuickIni.web_file = response.read().decode('utf-8')
-                    return True
-                else:
-                    QuickIni.error_message = f"Failed to download file from {url}, got response: {response.status}"
-                    return False
-        except urllib.error.HTTPError as e:
-            QuickIni.error_message = f"Could not get file from URL: '{e}'"
-            return False
-
-    @staticmethod
-    def is_string_url(stri:str) -> bool:
-        try:
-            res = urlparse(stri)
-            return all([res.scheme, res.netloc])
-        except ValueError:
-            return False
-
-    @staticmethod
-    def get_last_error() -> str:
-        """
-        Returns the last error thrown by the library
-        Returns:
-            str: A formatted error message
-        """
-        return QuickIni.error_message
-
-    @staticmethod
-    def string_to_type(s:str) -> Any:
-        """
-        Convert a string to the appropriate type (int, float, bool, or str).
-
-        Parameters:
-        s (str): The input string to convert.
-
-        Returns:
-        Any: The converted value as int, float, bool, or str, based on the content of `s`.
-            - Returns an int if `s` contains only digits.
-            - Returns a float if `s` is a numeric value with a single decimal point.
-            - Returns a boolean (True or False) if `s` matches the strings "true" or "false" (case-insensitive).
-            - Returns `s` unchanged if no other conditions are met.
-        """
-        if(s.isnumeric()): return int(s)
-        elif(s.count(".") == 1 and s.replace(".", "").isnumeric()): return float(s)
-        elif(s.lower() == "false"): return False
-        elif(s.lower() == "true"): return True
-        return s
-
-    @staticmethod
-    def load_file(file_location:str, auto_type_convert:bool = True, empty_default:Any = None) -> bool:
-        """
-        Load a ini style file from the file system or from a URL.
-        \nUse get_value() or get_all() to access.
-        Args:
-            name (str): The path/URL of the file to load.
-            auto_type_convert (bool): Automaticly convert into recognized types such as True/False, int, float.
-            empty_default (Any): The default value when a value is left blank (overrides auto_type_convert).
-        Returns:
-            bool: True if successfull, False otherwise
-        Example:
-            >>> load_file("../config.ini", empty_default="")
-                True
-        """
-        QuickIni.parsed_ini = {}
-        QuickIni.auto_type_convert_g = auto_type_convert
-
-        f_data:str = None
-
-        # Check if the provided location is a URL
-        if(QuickIni.is_string_url(file_location)):
-            if(not QuickIni.grab_from_url(file_location)):
-                # The grab_from_url sets the error message
-                return False
-            f_data = QuickIni.web_file
-        # Otherwise assume it's a file path
-        else:
-            try:
-                f_data = open(str(file_location), 'r', encoding='utf-8').read()
-            except FileNotFoundError:
-                QuickIni.error_message = f"Could not find file at: '{file_location}'"
-                return False
-            except IOError as e:
-                QuickIni.error_message = f"Error reading file: '{e}'"
-                return False
-
-        lines = f_data.splitlines()
-
-        for line in lines:
-            if(line.startswith("#") or "=" not in line): continue # Ignore comments and lines without "="
-            left, right = line.split("=", 1)
-            if(not right): right = empty_default
-            elif(not auto_type_convert): pass # If we aren't auto converting, skip the conversion
-            else: right = QuickIni.string_to_type(right)
-
-            QuickIni.parsed_ini[left] = right
-
-        QuickIni.loaded_file_path=file_location
-        return True
-
-    @staticmethod
-    def get_value(name:str, default:Any = None, expected_type:Type = None) -> Any:
-        """
-        Returns the value attached to the given name.
-        \nIf no setting is found, it will return the passed in default
-        Args:
-            name (str): The name of the setting
-            default (Any): What will be returned if nothing is found
-            expected_type (Type): Will make sure the returned object is of this Type, otherwise Raise()
-        Return:
-            Any: The value associated with the name
-        Example:
-            >>> get_value("do_debug_logs", False)
-            True
-        """
-        value:Any = QuickIni.parsed_ini.get(name, default)
-        if(expected_type != None):
-            if(not isinstance(value, expected_type)):
-                QuickIni.error_message = f"Expected type '{expected_type.__name__}', instead got '{type(value).__name__}'"
-                raise(ValueError(QuickIni.error_message))
-        return value
-
-    def write_value(key:str, value:Any, add_if_not_found:bool=False, update_locally:bool=True, do_backup:bool=False) -> Any:
-        """
-        Writes a key-value pair to the loaded .ini file, with an optional dry run mode.
-        
-        Parameters:
-        key (str): The key to update or add in the .ini file.
-        value (Any): The value to write, which will be converted to a string.
-        add_if_not_found (bool): If True, adds the key-value pair if the key is not found in the file (default is False).
-        update_localy (bool): If True, updates the parsed_ini dictionary locally with the new key-value pair (default is True).
-        do_backup (bool): If True, creates a backup of the original file before making changes, and removes if successful.
-        
-        Returns:
-        Any: The value written or simulated, with optional type conversion if `auto_type_convert` was enabled.
-
-        Raises:
-        ValueError: If no file path is loaded or if the value cannot be converted to a string.
-        FileNotFoundError: If the specified file cannot be found.
-        PermissionError: If there is an issue with file permissions.
-        IOError: If there is a read or write error.
-
-        Example:
-        >>> write_value("example_key", 42, add_if_not_found=True)
-        42
-        """
-
-        if(not QuickIni.loaded_file_path):
-            QuickIni.error_message = "No loaded file path, was a local file loaded?"
-            raise(ValueError(QuickIni.error_message))
-
-        try: str(value)
-        except(TypeError, ValueError):
-            QuickIni.error_message = "Could not convert value to a string"
-            raise(ValueError(QuickIni.error_message))
-
-        key_value_pair = f"{str(key)}={str(value)}\n"
-
-        try:
-            file = open(str(QuickIni.loaded_file_path), 'r', encoding='utf-8')
-            lines = file.readlines()
-            file.close()
-
-            # Create backup
-            if(do_backup):
-                backup_file = open(f"{str(QuickIni.loaded_file_path)}.backup", 'w', encoding='utf-8')
-                backup_file.writelines(lines)
-                backup_file.close()
-                print("Backup created at", f"{str(QuickIni.loaded_file_path)}.backup")
-
-            key_found=False
-            last_line=""
-            file = open(str(QuickIni.loaded_file_path), 'w')
-            for line in lines:
-                if(not line.startswith("#") and not key_found and line.startswith(f"{key}=")):
-                    last_line = key_value_pair
-                    key_found = True
-                else:
-                    last_line = line
-                file.write(last_line)
-
-            if(not key_found):
-                if(add_if_not_found):
-                    if(not last_line.endswith("\n")):
-                        file.write("\n")
-                    file.write(f"{key_value_pair}")
-                else:
-                    QuickIni.error_message = f"Could not find key '{key}'"
-                    raise(ValueError(QuickIni.error_message))
-
-            file.close()
-
-        except FileNotFoundError as e:
-            QuickIni.error_message = f"Could not find file '{QuickIni.loaded_file_path}'"
-            raise(e)
-        except PermissionError as e:
-            QuickIni.error_message = f"Permission error for file '{QuickIni.loaded_file_path}'"
-            raise(e)
-        except IOError as e:
-            QuickIni.error_message = f"IOError when reading or writting to the file '{QuickIni.loaded_file_path}'"
-            raise(e)
-
-        v = QuickIni.string_to_type(str(value)) if QuickIni.auto_type_convert_g else str(value)
-        if(update_locally):
-            QuickIni.parsed_ini[str(key)] = v
-
-        # Remove backup
-        if(do_backup):
-            try: os.remove(f"{str(QuickIni.loaded_file_path)}.backup")
-            except Exception as e:
-                QuickIni.error_message = "Failed to remove backup file"
-                raise(e)
-
-        return v
+from urllib.parse import urlparse
+from typing import Type, Any, Union, Dict, Optional
+import os
+
+class QuickIni:
+    parsed_ini: Dict[str, Union[str, int, bool, float, None]] = {}
+    loaded_file_path: Optional[str] = None
+    auto_type_convert_g: bool = True
+    error_message: str = ""
+    web_file: Optional[str] = None
+
+    @staticmethod
+    def grab_from_url(url:str) -> bool:
+        import urllib.request, urllib.error
+        try:
+            with urllib.request.urlopen(url) as response:
+                if(response.status == 200):
+                    QuickIni.web_file = response.read().decode('utf-8')
+                    return True
+                else:
+                    QuickIni.error_message = f"Failed to download file from {url}, got response: {response.status}"
+                    return False
+        except urllib.error.HTTPError as e:
+            QuickIni.error_message = f"Could not get file from URL: '{e}'"
+            return False
+
+    @staticmethod
+    def is_string_url(stri:str) -> bool:
+        try:
+            res = urlparse(stri)
+            return all([res.scheme, res.netloc])
+        except ValueError:
+            return False
+
+    @staticmethod
+    def get_last_error() -> str:
+        """
+        Returns the last error thrown by the library
+        Returns:
+            str: A formatted error message
+        """
+        return QuickIni.error_message
+
+    @staticmethod
+    def string_to_type(s:str) -> Any:
+        """
+        Convert a string to the appropriate type (int, float, bool, or str).
+
+        Parameters:
+        s (str): The input string to convert.
+
+        Returns:
+        Any: The converted value as int, float, bool, or str, based on the content of `s`.
+            - Returns an int if `s` contains only digits.
+            - Returns a float if `s` is a numeric value with a single decimal point.
+            - Returns a boolean (True or False) if `s` matches the strings "true" or "false" (case-insensitive).
+            - Returns `s` unchanged if no other conditions are met.
+        """
+        if(s.isnumeric()): return int(s)
+        elif(s.count(".") == 1 and s.replace(".", "").isnumeric()): return float(s)
+        elif(s.lower() == "false"): return False
+        elif(s.lower() == "true"): return True
+        return s
+
+    @staticmethod
+    def load_file(file_location:str, auto_type_convert:bool = True, empty_default:Any = None) -> bool:
+        """
+        Load a ini style file from the file system or from a URL.
+        \nUse get_value() or get_all() to access.
+        Args:
+            name (str): The path/URL of the file to load.
+            auto_type_convert (bool): Automaticly convert into recognized types such as True/False, int, float.
+            empty_default (Any): The default value when a value is left blank (overrides auto_type_convert).
+        Returns:
+            bool: True if successfull, False otherwise
+        Example:
+            >>> load_file("../config.ini", empty_default="")
+                True
+        """
+        QuickIni.parsed_ini = {}
+        QuickIni.auto_type_convert_g = auto_type_convert
+
+        f_data:str = None
+
+        # Check if the provided location is a URL
+        if(QuickIni.is_string_url(file_location)):
+            if(not QuickIni.grab_from_url(file_location)):
+                # The grab_from_url sets the error message
+                return False
+            f_data = QuickIni.web_file
+        # Otherwise assume it's a file path
+        else:
+            try:
+                with open(str(file_location), 'r', encoding='utf-8') as file:
+                    f_data = file.read()
+            except FileNotFoundError:
+                QuickIni.error_message = f"Could not find file at: '{file_location}'"
+                return False
+            except IOError as e:
+                QuickIni.error_message = f"Error reading file: '{e}'"
+                return False
+
+        lines = f_data.splitlines()
+
+        for line in lines:
+            if(line.startswith("#") or "=" not in line): continue # Ignore comments and lines without "="
+            left, right = line.split("=", 1)
+            if(not right): right = empty_default
+            elif(not auto_type_convert): pass # If we aren't auto converting, skip the conversion
+            else: right = QuickIni.string_to_type(right)
+
+            QuickIni.parsed_ini[left] = right
+
+        QuickIni.loaded_file_path=file_location
+        return True
+
+    @staticmethod
+    def get_value(name:str, default:Any = None, expected_type:Type = None) -> Any:
+        """
+        Returns the value attached to the given name.
+        \nIf no setting is found, it will return the passed in default
+        Args:
+            name (str): The name of the setting
+            default (Any): What will be returned if nothing is found
+            expected_type (Type): Will make sure the returned object is of this Type, otherwise Raise()
+        Return:
+            Any: The value associated with the name
+        Example:
+            >>> get_value("do_debug_logs", False)
+            True
+        """
+        value:Any = QuickIni.parsed_ini.get(name, default)
+        if(expected_type != None):
+            if(not isinstance(value, expected_type)):
+                QuickIni.error_message = f"Expected type '{expected_type.__name__}', instead got '{type(value).__name__}'"
+                raise(ValueError(QuickIni.error_message))
+        return value
+
+    def write_value(key:str, value:Any, add_if_not_found:bool=False, update_locally:bool=True, do_backup:bool=False) -> Any:
+        """
+        Writes a key-value pair to the loaded .ini file, with an optional dry run mode.
+        
+        Parameters:
+        key (str): The key to update or add in the .ini file.
+        value (Any): The value to write, which will be converted to a string.
+        add_if_not_found (bool): If True, adds the key-value pair if the key is not found in the file (default is False).
+        update_localy (bool): If True, updates the parsed_ini dictionary locally with the new key-value pair (default is True).
+        do_backup (bool): If True, creates a backup of the original file before making changes, and removes if successful.
+        
+        Returns:
+        Any: The value written or simulated, with optional type conversion if `auto_type_convert` was enabled.
+
+        Raises:
+        ValueError: If no file path is loaded or if the value cannot be converted to a string.
+        FileNotFoundError: If the specified file cannot be found.
+        PermissionError: If there is an issue with file permissions.
+        IOError: If there is a read or write error.
+
+        Example:
+        >>> write_value("example_key", 42, add_if_not_found=True)
+        42
+        """
+
+        if(not QuickIni.loaded_file_path):
+            QuickIni.error_message = "No loaded file path, was a local file loaded?"
+            raise(ValueError(QuickIni.error_message))
+
+        try: str(value)
+        except(TypeError, ValueError):
+            QuickIni.error_message = "Could not convert value to a string"
+            raise(ValueError(QuickIni.error_message))
+
+        key_value_pair = f"{str(key)}={str(value)}\n"
+
+        try:
+            file = open(str(QuickIni.loaded_file_path), 'r', encoding='utf-8')
+            lines = file.readlines()
+            file.close()
+
+            # Create backup
+            if(do_backup):
+                backup_file = open(f"{str(QuickIni.loaded_file_path)}.backup", 'w', encoding='utf-8')
+                backup_file.writelines(lines)
+                backup_file.close()
+                print("Backup created at", f"{str(QuickIni.loaded_file_path)}.backup")
+
+            key_found=False
+            last_line=""
+            file = open(str(QuickIni.loaded_file_path), 'w')
+            for line in lines:
+                if(not line.startswith("#") and not key_found and line.startswith(f"{key}=")):
+                    last_line = key_value_pair
+                    key_found = True
+                else:
+                    last_line = line
+                file.write(last_line)
+
+            if(not key_found):
+                if(add_if_not_found):
+                    if(not last_line.endswith("\n")):
+                        file.write("\n")
+                    file.write(f"{key_value_pair}")
+                else:
+                    QuickIni.error_message = f"Could not find key '{key}'"
+                    raise(ValueError(QuickIni.error_message))
+
+            file.close()
+
+        except FileNotFoundError as e:
+            QuickIni.error_message = f"Could not find file '{QuickIni.loaded_file_path}'"
+            raise(e)
+        except PermissionError as e:
+            QuickIni.error_message = f"Permission error for file '{QuickIni.loaded_file_path}'"
+            raise(e)
+        except IOError as e:
+            QuickIni.error_message = f"IOError when reading or writting to the file '{QuickIni.loaded_file_path}'"
+            raise(e)
+
+        v = QuickIni.string_to_type(str(value)) if QuickIni.auto_type_convert_g else str(value)
+        if(update_locally):
+            QuickIni.parsed_ini[str(key)] = v
+
+        # Remove backup
+        if(do_backup):
+            try: os.remove(f"{str(QuickIni.loaded_file_path)}.backup")
+            except Exception as e:
+                QuickIni.error_message = "Failed to remove backup file"
+                raise(e)
+
+        return v

quick_ini-3.1.4/quick_ini.egg-info/PKG-INFO

@@ -0,0 +1,72 @@
+Metadata-Version: 2.4
+Name: quick_ini
+Version: 3.1.4
+Summary: A library for reading from and writing to .ini formatted files
+Home-page: https://github.com/olliez-mods/Quick-Ini
+Author: OllieZ-Mods
+Author-email: socksinthewash@gmail.com
+Project-URL: Bug Reports, https://github.com/olliez-mods/Quick-Ini/issues
+Project-URL: Source, https://github.com/olliez-mods/Quick-Ini
+Keywords: ini config configuration parser file
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license-file
+Dynamic: project-url
+Dynamic: requires-python
+Dynamic: summary
+
+# QuickINI
+
+A simple and fast INI file parser for Python with support for loading from URLs and automatic type conversion.
+
+## Installation
+
+```bash
+pip install quickini
+```
+
+## Quick Start
+
+```python
+from quickini import QuickIni
+
+# Load from file
+QuickIni.load_file("config.ini")
+
+# Load from URL
+QuickIni.load_file("https://example.com/config.ini")
+
+# Get values with automatic type conversion
+debug = QuickIni.get_value("debug", False)  # Returns boolean
+port = QuickIni.get_value("port", 8080)     # Returns integer
+
+# Write values back to file
+QuickIni.write_value("new_setting", "value", add_if_not_found=True)
+```
+
+## Features
+
+- Load INI files from local filesystem or URLs
+- Automatic type conversion (int, float, bool, str)
+- Write values back to files
+- Error handling with detailed messages
+- Static class design for easy use across modules

{quick_ini-3.0 → quick_ini-3.1.4}/quick_ini.egg-info/SOURCES.txt

@@ -1,3 +1,4 @@
+LICENSE
 README.md
 pyproject.toml
 setup.py
@@ -6,4 +7,6 @@ quick_ini/quick_ini.py
 quick_ini.egg-info/PKG-INFO
 quick_ini.egg-info/SOURCES.txt
 quick_ini.egg-info/dependency_links.txt
-quick_ini.egg-info/top_level.txt
+quick_ini.egg-info/top_level.txt
+tests/__init__.py
+tests/test_quickini.py

{quick_ini-3.0 → quick_ini-3.1.4}/quick_ini.egg-info/top_level.txt

@@ -1 +1,2 @@
 quick_ini
+tests

{quick_ini-3.0 → quick_ini-3.1.4}/setup.cfg

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

quick_ini-3.1.4/setup.py

@@ -0,0 +1,35 @@
+from setuptools import setup, find_packages
+
+with open("README.md", "r", encoding="utf-8") as fh:
+    long_description = fh.read()
+
+setup(
+    name="quick_ini",
+    version="3.1.4",
+    description="A library for reading from and writing to .ini formatted files",
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    author="OllieZ-Mods",
+    author_email="socksinthewash@gmail.com",
+    url="https://github.com/olliez-mods/Quick-Ini",
+    packages=find_packages(),
+    classifiers=[
+        "Development Status :: 4 - Beta",
+        "Intended Audience :: Developers",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: OS Independent",
+        "Programming Language :: Python :: 3",
+        "Programming Language :: Python :: 3.7",
+        "Programming Language :: Python :: 3.8",
+        "Programming Language :: Python :: 3.9",
+        "Programming Language :: Python :: 3.10",
+        "Programming Language :: Python :: 3.11",
+        "Programming Language :: Python :: 3.12",
+    ],
+    python_requires=">=3.7",
+    keywords="ini config configuration parser file",
+    project_urls={
+        "Bug Reports": "https://github.com/olliez-mods/Quick-Ini/issues",
+        "Source": "https://github.com/olliez-mods/Quick-Ini",
+    },
+)

quick_ini-3.1.4/tests/__init__.py

@@ -0,0 +1 @@
+# Tests package

quick_ini-3.1.4/tests/test_quickini.py

@@ -0,0 +1,91 @@
+import unittest
+import tempfile
+import os
+from quick_ini import QuickIni
+
+
+class TestQuickIni(unittest.TestCase):
+    
+    def setUp(self):
+        """Set up test fixtures before each test method."""
+        # Create a temporary INI file for testing
+        self.test_content = """# Test configuration
+debug=true
+port=8080
+timeout=30.5
+name=TestApp
+empty_value=
+
+# Array example
+parts=
+|one
+|two
+|three
+"""
+        self.temp_file = tempfile.NamedTemporaryFile(mode='w', suffix='.ini', delete=False)
+        self.temp_file.write(self.test_content)
+        self.temp_file.close()
+        
+    def tearDown(self):
+        """Clean up after each test method."""
+        if os.path.exists(self.temp_file.name):
+            os.unlink(self.temp_file.name)
+    
+    def test_load_file(self):
+        """Test loading an INI file."""
+        result = QuickIni.load_file(self.temp_file.name)
+        self.assertTrue(result)
+        
+    def test_get_value_string(self):
+        """Test getting string values."""
+        QuickIni.load_file(self.temp_file.name)
+        value = QuickIni.get_value("name")
+        self.assertEqual(value, "TestApp")
+        
+    def test_get_value_boolean(self):
+        """Test getting boolean values."""
+        QuickIni.load_file(self.temp_file.name)
+        value = QuickIni.get_value("debug")
+        self.assertTrue(value)
+        self.assertIsInstance(value, bool)
+        
+    def test_get_value_integer(self):
+        """Test getting integer values."""
+        QuickIni.load_file(self.temp_file.name)
+        value = QuickIni.get_value("port")
+        self.assertEqual(value, 8080)
+        self.assertIsInstance(value, int)
+        
+    def test_get_value_float(self):
+        """Test getting float values."""
+        QuickIni.load_file(self.temp_file.name)
+        value = QuickIni.get_value("timeout")
+        self.assertEqual(value, 30.5)
+        self.assertIsInstance(value, float)
+        
+    def test_get_value_default(self):
+        """Test getting default values for missing keys."""
+        QuickIni.load_file(self.temp_file.name)
+        value = QuickIni.get_value("missing_key", "default")
+        self.assertEqual(value, "default")
+        
+    def test_write_value(self):
+        """Test writing values to file."""
+        QuickIni.load_file(self.temp_file.name)
+        result = QuickIni.write_value("new_key", "new_value", add_if_not_found=True)
+        self.assertEqual(result, "new_value")
+        
+        # Verify it was written
+        value = QuickIni.get_value("new_key")
+        self.assertEqual(value, "new_value")
+        
+    def test_error_handling(self):
+        """Test error handling for missing files."""
+        result = QuickIni.load_file("nonexistent_file.ini")
+        self.assertFalse(result)
+        error = QuickIni.get_last_error()
+        self.assertIn("Could not find file", error)
+
+
+if __name__ == '__main__':
+    unittest.main()

quick_ini-3.0/PKG-INFO

@@ -1,8 +0,0 @@
-Metadata-Version: 2.1
-Name: quick_ini
-Version: 3.0
-Summary: A library for reading from and writting to .ini formatted files
-Home-page: https://github.com/olliez-mods/Quick-Ini
-Author: OllieZ-Mods
-Author-email: socksinthewash@gmail.com
-Description-Content-Type: text/markdown

quick_ini-3.0/quick_ini.egg-info/PKG-INFO

@@ -1,8 +0,0 @@
-Metadata-Version: 2.1
-Name: quick_ini
-Version: 3.0
-Summary: A library for reading from and writting to .ini formatted files
-Home-page: https://github.com/olliez-mods/Quick-Ini
-Author: OllieZ-Mods
-Author-email: socksinthewash@gmail.com
-Description-Content-Type: text/markdown

quick_ini-3.0/setup.py

@@ -1,13 +0,0 @@
-from setuptools import setup, find_packages
-
-setup(
-    name="quick_ini",
-    version="3.0",
-    description="A library for reading from and writting to .ini formatted files",
-    long_description=open('README.md').read(),
-    long_description_content_type="text/markdown",
-    author="OllieZ-Mods",
-    author_email="socksinthewash@gmail.com",
-    url="https://github.com/olliez-mods/Quick-Ini",
-    packages=find_packages()
-)