nuf 0.0.2__py3-none-any.whl

nuf/__init__.py

@@ -0,0 +1,20 @@
+import importlib
+import pkgutil
+
+
+__name__ = "nuf"
+__version__ = "dev_testing"
+
+# Dynamically import all python files (modules) in the current package directory
+for _, module_name, _ in pkgutil.iter_modules(__path__):
+    # Import the module dynamically
+    module = importlib.import_module(f"{__name__}.{module_name}")
+    # Expose the module in the package namespace
+    globals()[module_name] = module
+
+
+
+if __name__ == "__main__":
+    import sys
+    print("You are running the nuf package directly, which is not recommended. Please import this package in your own scripts instead.")
+    sys.exit(1)

nuf/core.py

@@ -0,0 +1,2 @@
+def core_func():
+    return "Hello from core"

nuf/file_utils.py

@@ -0,0 +1,456 @@
+from nuf.message_utils import print_success
+import logging
+import shutil
+import os
+from pathlib import Path
+from typing import Union, List
+
+# Set up logging
+logger = logging.getLogger("nuf.file_utils")
+
+# Custom Exception Hierarchy
+class FileUtilsError(Exception):
+    """Base exception for file_utils operations."""
+    pass
+
+class PathNotFoundError(FileUtilsError):
+    """Raised when a file or directory is not found."""
+    pass
+
+class PermissionDeniedError(FileUtilsError):
+    """Raised when permission is denied for a file or directory operation."""
+    pass
+
+class DirectoryNotEmptyError(FileUtilsError):
+    """Raised when trying to delete a non-empty directory using a strict rmdir."""
+    pass
+
+class OperationFailedError(FileUtilsError):
+    """Raised when an OS or file system operation fails."""
+    pass
+
+# Dummy function for linting
+def file_func() -> str:
+    return "Hello from file_utils"
+
+
+def check_file_exists(path: Union[str, Path]) -> bool:
+    """Checks if a file exists at the given path."""
+    try:
+        return Path(path).is_file()
+    except Exception as e:
+        logger.debug("Failed to check file existence for %s: %s", path, e)
+        return False
+
+
+def check_dir_exists(path: Union[str, Path]) -> bool:
+    """Checks if a directory exists at the given path."""
+    try:
+        return Path(path).is_dir()
+    except Exception as e:
+        logger.debug("Failed to check directory existence for %s: %s", path, e)
+        return False
+
+
+def get_file_size(path: Union[str, Path]) -> int:
+    """Returns the size of the file in bytes.
+    
+    Raises:
+        PathNotFoundError: If the file does not exist.
+        PermissionDeniedError: If access is denied.
+        OperationFailedError: For other OS/filesystem errors.
+    """
+    p = Path(path)
+    try:
+        if not p.is_file():
+            raise PathNotFoundError(f"File not found: {p}")
+        return p.stat().st_size
+    except PathNotFoundError:
+        raise
+    except PermissionError as e:
+        raise PermissionDeniedError(f"Permission denied accessing size of: {p}. Original error: {e}")
+    except OSError as e:
+        raise OperationFailedError(f"Failed to get file size for: {p}. Original error: {e}")
+
+
+def create_dir(path: Union[str, Path], parents: bool = True, exist_ok: bool = True) -> bool:
+    """Creates a directory at the given path.
+    
+    Raises:
+        PermissionDeniedError: If permission is denied.
+        OperationFailedError: If creation fails due to other OS/file system errors.
+    """
+    p = Path(path)
+    try:
+        p.mkdir(parents=parents, exist_ok=exist_ok)
+        return True
+    except PermissionError as e:
+        raise PermissionDeniedError(f"Permission denied creating directory: {p}. Original error: {e}")
+    except OSError as e:
+        raise OperationFailedError(f"Failed to create directory: {p}. Original error: {e}")
+
+
+def delete_dir(path: Union[str, Path], recursive: bool = False) -> bool:
+    """Deletes a directory. If recursive is True, deletes all its contents.
+    
+    Raises:
+        PathNotFoundError: If the directory does not exist.
+        PermissionDeniedError: If permission is denied.
+        DirectoryNotEmptyError: If directory is not empty and recursive is False.
+        OperationFailedError: If deletion fails.
+    """
+    p = Path(path)
+    try:
+        if not p.is_dir():
+            raise PathNotFoundError(f"Directory not found: {p}")
+        
+        if recursive:
+            shutil.rmtree(p)
+        else:
+            p.rmdir()
+        return True
+    except PathNotFoundError:
+        raise
+    except PermissionError as e:
+        raise PermissionDeniedError(f"Permission denied deleting directory: {p}. Original error: {e}")
+    except OSError as e:
+        import errno
+        # Error code for Directory Not Empty is ENOTEMPTY or EEXIST
+        if e.errno in (errno.ENOTEMPTY, errno.EEXIST):
+            raise DirectoryNotEmptyError(f"Directory not empty: {p}. Set recursive=True to delete contents.")
+        raise OperationFailedError(f"Failed to delete directory: {p}. Original error: {e}")
+
+
+def create_file(path: Union[str, Path], exist_ok: bool = True) -> bool:
+    """Creates an empty file at the given path.
+    
+    Raises:
+        PermissionDeniedError: If permission is denied.
+        OperationFailedError: If creation fails.
+    """
+    p = Path(path)
+    try:
+        if p.is_file() and not exist_ok:
+            raise OperationFailedError(f"File already exists: {p}")
+        p.touch(exist_ok=exist_ok)
+        return True
+    except PermissionError as e:
+        raise PermissionDeniedError(f"Permission denied creating file: {p}. Original error: {e}")
+    except OSError as e:
+        raise OperationFailedError(f"Failed to create file: {p}. Original error: {e}")
+
+
+def append_line_to_file(path: Union[str, Path], line: str, encoding: str = 'utf-8') -> bool:
+    """Writes a line to a file (creates parent directories if needed).
+    
+    Raises:
+        PermissionDeniedError: If permission is denied.
+        OperationFailedError: If write operation fails.
+    """
+    p = Path(path)
+    try:
+        if not p.parent.exists():
+            p.parent.mkdir(parents=True, exist_ok=True)
+            
+        with open(p, 'a', encoding=encoding) as file:
+            file.write(line + '\n')
+        return True
+    except PermissionError as e:
+        raise PermissionDeniedError(f"Permission denied writing to file: {p}. Original error: {e}")
+    except OSError as e:
+        raise OperationFailedError(f"Failed to write line to file: {p}. Original error: {e}")
+
+
+def return_lines_from_file(path: Union[str, Path], encoding: str = 'utf-8') -> List[str]:
+    """Returns a list of lines from a file.
+    
+    Raises:
+        PathNotFoundError: If file does not exist.
+        PermissionDeniedError: If permission is denied.
+        OperationFailedError: If read operation fails.
+    """
+    p = Path(path)
+    try:
+        if not p.is_file():
+            raise PathNotFoundError(f"File not found: {p}")
+        with open(p, 'r', encoding=encoding) as file:
+            return file.readlines()
+    except PathNotFoundError:
+        raise
+    except PermissionError as e:
+        raise PermissionDeniedError(f"Permission denied reading file: {p}. Original error: {e}")
+    except (OSError, UnicodeDecodeError) as e:
+        raise OperationFailedError(f"Failed to read lines from file: {p}. Original error: {e}")
+
+
+def stream_files(path: Union[str, Path], recursive: bool = False) -> object:
+    """ Streams a list of filenames from a directory, paths are chosen by extension
+
+    Args:
+        path (Union[str, Path]): The path to the directory to stream files from.
+        recursive (bool): Whether to stream files recursively.
+
+    Raises:
+        PathNotFoundError: If file does not exist.
+        PermissionDeniedError: If permission is denied.
+        OperationFailedError: If read operation fails.
+
+    Yields:
+        Iterator[Path]: An iterator of paths to files.
+    """
+    
+    p = Path(path)
+    if not p.is_dir():
+        raise PathNotFoundError(f"Directory not found: {p}")
+
+    if recursive:
+        files = p.glob("**/*")
+    else:
+        files = p.glob("*")
+
+    for file in files:
+        if file.is_file():
+            yield file
+
+def stream_files_by_extension(path: Union[str, Path], extensions: list, recursive: bool = False) -> object:
+    """ Streams a list of filenames from a directory, paths are chosen by extension
+
+    Args:
+        path (Union[str, Path]): The path to the directory to stream files from.
+        extensions (list): A list of extensions to stream files by.
+        recursive (bool): Whether to stream files recursively.
+
+    Raises:
+        PathNotFoundError: If file does not exist.
+        PermissionDeniedError: If permission is denied.
+        OperationFailedError: If read operation fails.
+
+    """
+    
+    p = Path(path)
+    if not p.is_dir():
+        raise PathNotFoundError(f"Directory not found: {p}")
+
+    if recursive:
+        files = p.glob("**/*")
+    else:
+        files = p.glob("*")
+
+    for file in files:
+        if file.is_file() and file.suffix in extensions:
+            yield file
+
+
+def list_files_by_extension(path: Union[str, Path], extensions: list, recursive: bool = False) -> List[Path]:
+    """ Returns a list of filenames from a directory, paths are chosen by extension
+
+    Args:
+        path (Union[str, Path]): The path to the directory to list files from.
+        extensions (list): A list of extensions to list files by.
+        recursive (bool): Whether to list files recursively.
+
+    Raises:
+        PathNotFoundError: If file does not exist.
+        PermissionDeniedError: If permission is denied.
+        OperationFailedError: If read operation fails.
+
+    """
+    
+    p = Path(path)
+    if not p.is_dir():
+        raise PathNotFoundError(f"Directory not found: {p}")
+
+    if recursive:
+        files = p.glob("**/*")
+    else:
+        files = p.glob("*")
+
+    return [file for file in files if file.is_file() and file.suffix in extensions]
+
+
+def get_files_by_extension(path: Union[str, Path], extensions: list, recursive: bool = False) -> List[Path]:
+    """ Returns a list of filenames from a directory, paths are chosen by extension
+
+    Args:
+        path (Union[str, Path]): The path to the directory to get files from.
+        extensions (list): A list of extensions to get files by.
+        recursive (bool): Whether to get files recursively.
+
+    Raises:
+        PathNotFoundError: If file does not exist.
+        PermissionDeniedError: If permission is denied.
+        OperationFailedError: If read operation fails.
+
+    """
+    
+    p = Path(path)
+    if not p.is_dir():
+        raise PathNotFoundError(f"Directory not found: {p}")
+
+    if recursive:
+        files = p.glob("**/*")
+    else:
+        files = p.glob("*")
+
+    return [file for file in files if file.is_file() and file.suffix in extensions]
+
+def sort_files_by_time(files: list, reverse: bool = False) -> List[Path]:
+    """ Sorts a list of files by time 
+
+    Args:
+        files (list): List of files to sort
+        reverse (bool, optional): Reverse the sort order. Defaults to False.
+
+    Returns:
+        List[Path]: Sorted list of files
+
+    Raises:
+        PermissionDeniedError: If permission is denied.
+        OperationFailedError: If read operation fails.
+
+    """
+    return sorted(files, key=lambda x: x.stat().st_mtime, reverse=reverse)
+
+
+def sort_files_by_size(files: list, reverse: bool = False) -> List[Path]:
+    """ Sorts a list of files by size 
+
+    Args:
+        files (list): List of files to sort
+        reverse (bool, optional): Reverse the sort order. Defaults to False.
+
+    Returns:
+        List[Path]: Sorted list of files
+
+    Raises:
+        PermissionDeniedError: If permission is denied.
+        OperationFailedError: If read operation fails.
+
+    """
+    return sorted(files, key=lambda x: x.stat().st_size, reverse=reverse)
+
+def sort_files_by_name(files: list, reverse: bool = False) -> List[Path]:
+    """ Sorts a list of files by name 
+
+    Args:
+        files (list): List of files to sort
+        reverse (bool, optional): Reverse the sort order. Defaults to False.
+
+    Returns:
+        List[Path]: Sorted list of files
+
+    Raises:
+        PermissionDeniedError: If permission is denied.
+        OperationFailedError: If read operation fails.
+
+    """
+    return sorted(files, key=lambda x: x.name, reverse=reverse)
+
+
+def calculate_checksum_of_file(file_path: Union[str, Path], chunk_size: int = 8192) -> str:
+    """ Calculates the checksum of a file 
+
+    Args:
+        file_path (Union[str, Path]): The path to the file to calculate the checksum of.
+        chunk_size (int, optional): The chunk size to read the file in. Defaults to 8192.
+
+    Returns:
+        str: The checksum of the file.
+
+    Raises:
+        PathNotFoundError: If file does not exist.
+        PermissionDeniedError: If permission is denied.
+        OperationFailedError: If read operation fails.
+
+    """
+    import hashlib
+    p = Path(file_path)
+    if not p.is_file():
+        raise PathNotFoundError(f"File not found: {p}")
+    checksum = hashlib.md5()
+    with open(p, 'rb') as file:
+        while True:
+            chunk = file.read(chunk_size)
+            if not chunk:
+                break
+            checksum.update(chunk)
+    return checksum.hexdigest()
+
+# File deletion functions
+
+def delete_file(file_path: Union[str, Path]) -> None:
+    """ Deletes a file 
+
+    Args:
+        file_path (Union[str, Path]): The path to the file to delete.
+
+    Raises:
+        PathNotFoundError: If file does not exist.
+        PermissionDeniedError: If permission is denied.
+        OperationFailedError: If delete operation fails.
+
+    """
+    p = Path(file_path)
+    if not p.is_file():
+        raise PathNotFoundError(f"File not found: {p}")
+    try:
+        p.unlink()
+    except PermissionError as e:
+        raise PermissionDeniedError(f"Permission denied deleting file: {p}. Original error: {e}")
+    except OSError as e:
+        raise OperationFailedError(f"Failed to delete file: {p}. Original error: {e}")
+
+def obfuscate_file_and_delete(file_path: Union[str, Path], debug: bool = False) -> None:
+    """ Obfuscates a file by overwriting it with random data and then deleting it 
+
+    Args:
+        file_path (Union[str, Path]): The path to the file to obfuscate and delete.
+
+    Raises:
+        PathNotFoundError: If file does not exist.
+        PermissionDeniedError: If permission is denied.
+        OperationFailedError: If obfuscate or delete operation fails.
+
+    """
+    p = Path(file_path)
+    if not p.is_file():
+        raise PathNotFoundError(f"File not found: {p}")
+
+    size = p.stat().st_size
+
+    try:
+        with open(p, 'wb') as file:
+            file.write(os.urandom(size))
+            if debug:
+                print_success(f"Obfuscated file: {p}")
+        p.unlink(missing_ok=False)
+        if debug:
+            print_success(f"Deleted file: {p}")
+    except PermissionError as e:
+        raise PermissionDeniedError(f"Permission denied obfuscating or deleting file: {p}. Original error: {e}")
+    except OSError as e:
+        raise OperationFailedError(f"Failed to obfuscate or delete file: {p}. Original error: {e}")
+
+def send_file_to_trash(file_path: Union[str, Path], debug: bool = False) -> None:
+    """ Sends a file to the trash 
+
+    Args:
+        file_path (Union[str, Path]): The path to the file to send to the trash.
+
+    Raises:
+        PathNotFoundError: If file does not exist.
+        PermissionDeniedError: If permission is denied.
+        OperationFailedError: If send to trash operation fails.
+
+    """
+    import send2trash
+    p = Path(file_path)
+    if not p.is_file():
+        raise PathNotFoundError(f"File not found: {p}")
+    try:
+        send2trash.send2trash(p)
+        if debug:
+            print_success(f"Sent file to trash: {p}")
+    except Exception as e:
+        raise OperationFailedError(f"Failed to send file to trash: {p}. Original error: {e}")
+    

nuf/format_utils.py

@@ -0,0 +1,95 @@
+from typing import Union
+from pathlib import Path
+
+
+
+def format_func() -> str:
+    return "Hello from format_utils"
+
+def format_bytes(size_bytes: int, decimal_places: int = 2) -> str:
+    """Converts a number of bytes to a human-readable string representation (e.g. KB, MB, GB)."""
+    if size_bytes < 0:
+        raise ValueError("Size in bytes cannot be negative")
+    
+    if size_bytes == 0:
+        return "0 B"
+    
+    units = ["B", "KB", "MB", "GB", "TB", "PB", "EB"]
+    size = float(size_bytes)
+    unit_idx = 0
+    while size >= 1024.0 and unit_idx < len(units) - 1:
+        size /= 1024.0
+        unit_idx += 1
+        
+    return f"{size:.{decimal_places}f} {units[unit_idx]}"
+
+
+def clamp(value: float, min_value: float, max_value: float) -> float:
+    """Clamps a value to a specified range."""
+    return max(min_value, min(value, max_value))
+    
+def random_string(length: int = 10, include_special_characters: bool = False) -> str:
+    """Generates a random string of the specified length."""
+    import string
+    import random
+
+    if include_special_characters:
+        return ''.join(random.choices(string.ascii_letters + string.digits + string.punctuation, k=length))
+    else:
+        return ''.join(random.choices(string.ascii_letters + string.digits, k=length))
+
+
+
+# Time Format Functions
+def format_time_diff(seconds: float) -> str:
+    """Converts a time difference in seconds to a human-readable string (e.g. 1h30m 12s)."""
+    if seconds < 0:
+        raise ValueError("Time difference cannot be negative")
+
+    parts = []
+    
+    # Calculate hours
+    hours, remainder = divmod(seconds, 3600)
+    if hours > 0:
+        parts.append(f"{int(hours)}h")
+    
+    # Calculate minutes
+    minutes, seconds = divmod(remainder, 60)
+    if minutes > 0:
+        parts.append(f"{int(minutes)}m")
+    
+    # Calculate seconds (with milliseconds if needed)
+    if seconds > 0 or not parts:
+        if seconds >= 1:
+            parts.append(f"{int(seconds)}s")
+        else:
+            parts.append(f"{seconds:.3f}s")
+    
+    return " ".join(parts)
+
+def format_timestamp(timestamp: float, output_format: str = "%d-%m-%Y %H:%M:%S") -> str:
+    """Formats a timestamp (seconds since epoch) into a human-readable date/time string."""
+    import datetime
+    return datetime.datetime.fromtimestamp(timestamp).strftime(output_format)
+
+
+
+# File Age Functions
+def get_file_age_in_seconds(file_path: Union[str, Path]) -> float:
+    """Returns the age of the file in seconds."""
+    p = Path(file_path)
+    if not p.is_file():
+        raise FileNotFoundError(f"File not found: {p}")
+    return p.stat().st_mtime
+
+def get_file_age_in_minutes(file_path: Union[str, Path]) -> float:
+    """Returns the age of the file in minutes."""
+    return get_file_age_in_seconds(file_path) / 60
+
+def get_file_age_in_hours(file_path: Union[str, Path]) -> float:
+    """Returns the age of the file in hours."""
+    return get_file_age_in_seconds(file_path) / 3600
+
+def get_file_age_in_days(file_path: Union[str, Path]) -> float:
+    """Returns the age of the file in days."""
+    return get_file_age_in_seconds(file_path) / 86400

nuf/message_utils.py

@@ -0,0 +1,42 @@
+import colorama
+from colorama import Fore, Style
+
+# Initialize colorama (safe to call multiple times, handles Windows ANSI translation)
+colorama.init(autoreset=True)
+
+
+COLOUR_TABLE = {
+    "default": Style.RESET_ALL,
+    "info": Fore.BLUE,
+    "success": Fore.GREEN,
+    "warning": Fore.YELLOW,
+    "error": Fore.RED,
+    "critical": Fore.RED + Style.BRIGHT,
+    "debug": Style.DIM,
+}
+
+def message_func() -> str:
+    return "Hello from message_utils"
+
+
+def bracketed_message_string(label: str, style: str = "default") -> str:
+    return f"[{COLOUR_TABLE[style]}{label}{COLOUR_TABLE['default']}]"
+    
+def print_warning(message: str, prefix_label: str = "WARNING") -> None:
+    print(f"{bracketed_message_string(prefix_label, 'warning')} {message}")
+
+def print_error(message: str, prefix_label: str = "ERROR") -> None:
+    print(f"{bracketed_message_string(prefix_label, 'error')} {message}")
+
+def print_success(message: str, prefix_label: str = "SUCCESS") -> None:
+    print(f"{bracketed_message_string(prefix_label, 'success')} {message}")
+
+def print_info(message: str, prefix_label: str = "INFO") -> None:
+    print(f"{bracketed_message_string(prefix_label, 'info')} {message}")
+
+def print_debug(message: str, prefix_label: str = "DEBUG") -> None:
+    print(f"{bracketed_message_string(prefix_label, 'debug')} {message}")
+
+def print_critical(message: str, prefix_label: str = "CRITICAL") -> None:
+    print(f"{bracketed_message_string(prefix_label, 'critical')} {message}")
+

nuf-0.0.2.dist-info/METADATA

@@ -0,0 +1,57 @@
+Metadata-Version: 2.4
+Name: nuf
+Version: 0.0.2
+Summary: A versatile multi-file utility module, a series of useful code that is referenced from various projects that i repeatedly use.
+Author: Nathan Falvey
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: colorama
+Requires-Dist: send2trash
+Requires-Dist: pathlib
+Dynamic: license-file
+
+# nates-useful-functions-python-module (nuf)
+
+A versatile, multi-file utility module that aggregates a series of useful Python code referenced repeatedly across various projects. 
+
+## Package Structure
+
+The package is structured as follows under the `src` directory:
+- `src/nuf/__init__.py`: Initializes the package and dynamically imports all Python files/modules in its directory.
+- `src/nuf/core.py`: Core functionality.
+- `src/nuf/file_utils.py`: Utilities for working with files.
+- `src/nuf/message_utils.py`: Utilities for messaging and logs.
+- `src/nuf/format_utils.py`: Utilities for formatting and time conversions.
+
+## Dynamic Importing
+
+This module automatically discovers and imports all Python files present inside the `src/nuf/` folder. When you add a new Python file (e.g. `src/nuf/new_helper.py`), it is automatically available as `nuf.new_helper` without needing to modify `__init__.py`.
+
+## Usage
+
+Here is a quick example of how to import and use the package:
+
+```python
+import nuf
+
+# Access functions from core.py
+print(nuf.core.core_func())
+
+# Access functions from file_utils.py
+print(nuf.file_utils.file_func())
+
+# Access functions from message_utils.py
+print(nuf.message_utils.message_func())
+```
+
+## Running Tests
+
+To run the local verification test suite, run:
+
+```bash
+python test_nuf.py
+```

nuf-0.0.2.dist-info/RECORD

@@ -0,0 +1,10 @@
+nuf/__init__.py,sha256=pdX0Vuk0aHB3vbVGIQ3Kkga7isd9UieG7VB3gTTZZRI,602
+nuf/core.py,sha256=XermFsGus5ll1Fhx4d-hrH9s6l5UNbLwEwabD4DAz-I,46
+nuf/file_utils.py,sha256=v9SaPlhnDwQK_ehLEr6z0DgKVyEljBJGl9efKKTov5Y,14991
+nuf/format_utils.py,sha256=i_5Es-IT_J0dIJpgvLSe5z9w5byeeVxgIefLV9QDHFE,3121
+nuf/message_utils.py,sha256=150hOxllP2iev-YuFGfvOYIKORhOJTgzwkJEwXPFSpI,1477
+nuf-0.0.2.dist-info/licenses/LICENSE,sha256=8ig6042tksnVSfS8Zo2jFgRtE3-OPBFIi8qdPf3kJ20,1091
+nuf-0.0.2.dist-info/METADATA,sha256=Nw_jcZSgCyBAQ2bYfOL4rNg9ywPqKBYdhk0E7-hNsSE,1850
+nuf-0.0.2.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+nuf-0.0.2.dist-info/top_level.txt,sha256=mZxQgjMoy7GkS8ALAxzoI9GG1AdyF2iQNAjIs8qv9Ss,4
+nuf-0.0.2.dist-info/RECORD,,

nuf-0.0.2.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

nuf-0.0.2.dist-info/licenses/LICENSE

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

nuf-0.0.2.dist-info/top_level.txt

@@ -0,0 +1 @@
+nuf