hexif-pyutils 1.0.0__tar.gz

hexif_pyutils-1.0.0/PKG-INFO

@@ -0,0 +1,112 @@
+Metadata-Version: 2.4
+Name: hexif-pyutils
+Version: 1.0.0
+Summary: Super simple python utility library
+Author: HeXif
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/xHeXifx/hexif-pyutils
+Project-URL: Repository, https://github.com/xHeXifx/hexif-pyutils
+Project-URL: Issues, https://github.com/xHeXifx/hexif-pyutils/issues
+Keywords: utilties,utils,python,helpers
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+
+# hexif-pyutils
+
+Super simple Python utilities.
+
+This was mainly put on PyPi so i can install it without cloning it off gitea and then pip installing it off the local path.
+
+## Install
+
+```bash
+pip install hexif-pyutils
+```
+
+## Install (TouchID Helper MacOS)
+
+(If not cloned clone)
+```zsh
+git clone https://github.com/xHeXifx/hexif-pyutils
+```
+
+```zsh
+cd {repo}/macOS/touchid-executable/touchid-helper
+swift build -c release
+```
+
+Find the executable, will be somewhere in ./build and named 'touchid'
+```zsh
+cp {executable location} /usr/local/bin/touchid
+sudo chmod +x /usr/local/bin/touchid
+```
+
+Optional test
+```zsh
+/usr/local/bin/touchid "perform a test"
+```
+
+## Usage
+
+### Logger
+
+```python
+from utils.logger import Logger
+
+log = Logger("app", log_file="app.log")
+log.info("Hello")
+```
+
+What it does: simple logging wrapper with console and file output.
+
+### File helpers
+
+```python
+from utils.file import read, write, get, touch
+
+write("hello", "test.txt")
+print(read("test.txt"))
+print(get("test.txt").name)
+touch("new.txt")
+```
+
+What it does: basic file reading/writing, file metadata lookup, and creating empty files.
+
+### JSON
+
+```python
+from utils.file.json import read, write
+
+write({"name": "hexif"}, "data.json")
+data = read("data.json")
+print(data)
+```
+
+What it does: reads and writes JSON files quickly.
+
+### Shell
+
+```python
+from utils.system.shell import run
+
+result = run("echo hello", capture_output=True, text=True)
+print(result.stdout)
+```
+
+What it does: runs shell commands using Python subprocess.
+
+### Touch ID
+
+```python
+from utils.system.security import askForTouchID
+
+allowed = askForTouchID("confirm action")
+print(allowed)
+```
+
+What it does: checks for the macOS Touch ID helper and asks for confirmation.
+
+## Credits
+
+- https://hexif.vercel.app
+- https://github.com/xHeXifx

hexif_pyutils-1.0.0/README.md

@@ -0,0 +1,99 @@
+# hexif-pyutils
+
+Super simple Python utilities.
+
+This was mainly put on PyPi so i can install it without cloning it off gitea and then pip installing it off the local path.
+
+## Install
+
+```bash
+pip install hexif-pyutils
+```
+
+## Install (TouchID Helper MacOS)
+
+(If not cloned clone)
+```zsh
+git clone https://github.com/xHeXifx/hexif-pyutils
+```
+
+```zsh
+cd {repo}/macOS/touchid-executable/touchid-helper
+swift build -c release
+```
+
+Find the executable, will be somewhere in ./build and named 'touchid'
+```zsh
+cp {executable location} /usr/local/bin/touchid
+sudo chmod +x /usr/local/bin/touchid
+```
+
+Optional test
+```zsh
+/usr/local/bin/touchid "perform a test"
+```
+
+## Usage
+
+### Logger
+
+```python
+from utils.logger import Logger
+
+log = Logger("app", log_file="app.log")
+log.info("Hello")
+```
+
+What it does: simple logging wrapper with console and file output.
+
+### File helpers
+
+```python
+from utils.file import read, write, get, touch
+
+write("hello", "test.txt")
+print(read("test.txt"))
+print(get("test.txt").name)
+touch("new.txt")
+```
+
+What it does: basic file reading/writing, file metadata lookup, and creating empty files.
+
+### JSON
+
+```python
+from utils.file.json import read, write
+
+write({"name": "hexif"}, "data.json")
+data = read("data.json")
+print(data)
+```
+
+What it does: reads and writes JSON files quickly.
+
+### Shell
+
+```python
+from utils.system.shell import run
+
+result = run("echo hello", capture_output=True, text=True)
+print(result.stdout)
+```
+
+What it does: runs shell commands using Python subprocess.
+
+### Touch ID
+
+```python
+from utils.system.security import askForTouchID
+
+allowed = askForTouchID("confirm action")
+print(allowed)
+```
+
+What it does: checks for the macOS Touch ID helper and asks for confirmation.
+
+## Credits
+
+- https://hexif.vercel.app
+- https://github.com/xHeXifx

hexif_pyutils-1.0.0/hexif_pyutils.egg-info/PKG-INFO

@@ -0,0 +1,112 @@
+Metadata-Version: 2.4
+Name: hexif-pyutils
+Version: 1.0.0
+Summary: Super simple python utility library
+Author: HeXif
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/xHeXifx/hexif-pyutils
+Project-URL: Repository, https://github.com/xHeXifx/hexif-pyutils
+Project-URL: Issues, https://github.com/xHeXifx/hexif-pyutils/issues
+Keywords: utilties,utils,python,helpers
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+
+# hexif-pyutils
+
+Super simple Python utilities.
+
+This was mainly put on PyPi so i can install it without cloning it off gitea and then pip installing it off the local path.
+
+## Install
+
+```bash
+pip install hexif-pyutils
+```
+
+## Install (TouchID Helper MacOS)
+
+(If not cloned clone)
+```zsh
+git clone https://github.com/xHeXifx/hexif-pyutils
+```
+
+```zsh
+cd {repo}/macOS/touchid-executable/touchid-helper
+swift build -c release
+```
+
+Find the executable, will be somewhere in ./build and named 'touchid'
+```zsh
+cp {executable location} /usr/local/bin/touchid
+sudo chmod +x /usr/local/bin/touchid
+```
+
+Optional test
+```zsh
+/usr/local/bin/touchid "perform a test"
+```
+
+## Usage
+
+### Logger
+
+```python
+from utils.logger import Logger
+
+log = Logger("app", log_file="app.log")
+log.info("Hello")
+```
+
+What it does: simple logging wrapper with console and file output.
+
+### File helpers
+
+```python
+from utils.file import read, write, get, touch
+
+write("hello", "test.txt")
+print(read("test.txt"))
+print(get("test.txt").name)
+touch("new.txt")
+```
+
+What it does: basic file reading/writing, file metadata lookup, and creating empty files.
+
+### JSON
+
+```python
+from utils.file.json import read, write
+
+write({"name": "hexif"}, "data.json")
+data = read("data.json")
+print(data)
+```
+
+What it does: reads and writes JSON files quickly.
+
+### Shell
+
+```python
+from utils.system.shell import run
+
+result = run("echo hello", capture_output=True, text=True)
+print(result.stdout)
+```
+
+What it does: runs shell commands using Python subprocess.
+
+### Touch ID
+
+```python
+from utils.system.security import askForTouchID
+
+allowed = askForTouchID("confirm action")
+print(allowed)
+```
+
+What it does: checks for the macOS Touch ID helper and asks for confirmation.
+
+## Credits
+
+- https://hexif.vercel.app
+- https://github.com/xHeXifx

hexif_pyutils-1.0.0/hexif_pyutils.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+README.md
+pyproject.toml
+hexif_pyutils.egg-info/PKG-INFO
+hexif_pyutils.egg-info/SOURCES.txt
+hexif_pyutils.egg-info/dependency_links.txt
+hexif_pyutils.egg-info/top_level.txt
+utils/__init__.py
+utils/logger.py
+utils/file/__init__.py
+utils/file/json.py
+utils/system/__init__.py
+utils/system/security.py
+utils/system/shell.py

hexif_pyutils-1.0.0/hexif_pyutils.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

hexif_pyutils-1.0.0/hexif_pyutils.egg-info/top_level.txt

@@ -0,0 +1 @@
+utils

hexif_pyutils-1.0.0/pyproject.toml

@@ -0,0 +1,29 @@
+[build-system]
+requires = ["setuptools>=61"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "hexif-pyutils"
+version = "1.0.0"
+description = "Super simple python utility library"
+readme = "README.md"
+requires-python = ">=3.9"
+
+authors = [{name = "HeXif"}]
+
+license = "MIT"
+
+keywords = [
+    "utilties",
+    "utils",
+    "python",
+    "helpers"
+]
+
+[project.urls]
+Homepage = "https://github.com/xHeXifx/hexif-pyutils"
+Repository = "https://github.com/xHeXifx/hexif-pyutils"
+Issues = "https://github.com/xHeXifx/hexif-pyutils/issues"
+
+[tool.setuptools.packages.find]
+include = ["utils*"]

hexif_pyutils-1.0.0/setup.cfg

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

hexif_pyutils-1.0.0/utils/__init__.py

@@ -0,0 +1,3 @@
+from . import file
+from . import system
+from . import logger

hexif_pyutils-1.0.0/utils/file/__init__.py

@@ -0,0 +1,77 @@
+from ..file import json
+
+from pathlib import Path as _Path
+from os.path import isfile as _isfile
+from os.path import exists as _exists
+from typing import Any as _Any
+
+class File:
+    def __init__(self, filename: str|_Path):
+        if not isinstance(filename, _Path):
+            filename = _Path(filename)
+        self.path = filename
+        self.exists = self.path.exists()
+
+        self.is_file = self.path.is_file()
+        self.is_dir = self.path.is_dir()
+        self.is_symlink = self.path.is_symlink()
+
+        self.name = self.path.name
+        self.stem = self.path.stem
+        self.extension = self.path.suffix
+        self.parent = self.path.parent
+        self.absolute = self.path.absolute()
+        self.resolved = self.path.resolve()
+
+        self.size_bytes = self.path.stat().st_size
+        self.size_kb = self.size_bytes / 1024
+        self.size_mb = self.size_bytes / 1024**2
+        self.size_gb = self.size_bytes / 1024**3
+        
+
+def read(filename: str|_Path) -> str|None:
+    """Read contents of a file"""
+    try:
+        if _isfile(filename):
+            with open(filename, 'r') as f:
+                return f.read()
+        else:
+            raise FileNotFoundError(f"File '{filename}' does not exist.")
+    except Exception as e:
+        raise Exception(f"Failed to read file {filename}") from e
+    
+def write(data: _Any, filename: str|_Path) -> bool|None:
+    """Opens file as 'w' and writes data
+    
+    Args:
+        data: Information to write
+        filename: File to write to
+
+    Returns:
+        bool (True): If completed successfully
+        None: If fails and raises Exception
+    """
+    try:
+        with open(filename, 'w') as f:
+            f.write(data)
+        return True
+    except Exception as e:
+        raise Exception(f"Failed to write to file {filename}") from e
+
+def get(file: str|_Path) -> File|None:
+    """Get information on a file
+    
+    Returns:
+        File: If file is found
+        None: If file is not found
+    """
+    if _exists(file):
+        return File(file)
+    else:
+        raise FileNotFoundError()
+
+def touch(file: str|_Path) -> None:
+    """Touch (create) a empty file"""
+    if _exists(file):
+        return None
+    

hexif_pyutils-1.0.0/utils/file/json.py

@@ -0,0 +1,57 @@
+import json
+from pathlib import Path
+import os
+
+def read(filename: str|Path) -> dict|list|None:
+    """Read file with open 'r' and returns json.load()"""
+    try:
+        if os.path.isfile(filename):
+            with open(filename, 'r') as f:
+                return json.load(f)
+        else:
+            raise FileNotFoundError(f"File '{filename}' does not exist.")
+    except Exception as e:
+        raise Exception(f"Failed to read file {filename}") from e
+    
+def write(data: dict|list, filename: str|Path, indent=4) -> bool|None:
+    """Write dict/list data with 'f' to json file
+    
+    Args:
+        data: JSON data to write
+        filename: File to write to
+        indent: Indentation to use in the file
+    
+    Returns:
+        bool (True): If operation completes successfully
+        None: If operation fails and raises Exception
+    """
+    try:
+        with open(filename, 'w') as f:
+            json.dump(data, f, indent=indent)
+        return True
+    except Exception as e:
+        raise Exception(f"Failed to write to file {filename}") from e
+
+def extract_dict_obj(text: str) -> dict | None:
+    """Finds and returns a dict from a string
+    Args:
+        text (str): The text you wish to extract object from
+
+    Returns:
+        dict: If object was extracted
+        None: If no object found
+    """
+    text = text.strip()
+    try:
+        obj = json.loads(text)
+        return obj if isinstance(obj, dict) else None
+    except Exception:
+        pass
+    start, end = text.find("{"), text.rfind("}")
+    if start == -1 or end == -1 or end <= start:
+        return None
+    try:
+        obj = json.loads(text[start:end + 1])
+        return obj if isinstance(obj, dict) else None
+    except Exception:
+        return None

hexif_pyutils-1.0.0/utils/logger.py

@@ -0,0 +1,78 @@
+import logging as _logging
+from pathlib import Path as _Path
+
+
+import logging as _logging
+from pathlib import Path as _Path
+
+
+class Logger:
+    """Wrapper around Python's logging.Logger."""
+
+    def __init__(
+        self,
+        name: str | None = None,
+        log_file: str | _Path | None = None,
+        level: int = _logging.INFO,
+        console: bool = True,
+    ):
+        self.logger = _logging.getLogger(name)
+        self.logger.setLevel(level)
+
+        if not self.logger.handlers:
+            formatter = _logging.Formatter(
+                "%(asctime)s [%(levelname)s] %(name)s: %(message)s"
+            )
+
+            if console:
+                console_handler = _logging.StreamHandler()
+                console_handler.setFormatter(formatter)
+                self.logger.addHandler(console_handler)
+
+            if log_file is not None:
+                file_handler = _logging.FileHandler(
+                    log_file,
+                    encoding="utf-8"
+                )
+                file_handler.setFormatter(formatter)
+                self.logger.addHandler(file_handler)
+
+    def debug(self, msg, *args, **kwargs):
+        self.logger.debug(msg, *args, **kwargs)
+
+    def info(self, msg, *args, **kwargs):
+        self.logger.info(msg, *args, **kwargs)
+
+    def warning(self, msg, *args, **kwargs):
+        self.logger.warning(msg, *args, **kwargs)
+
+    def error(self, msg, *args, **kwargs):
+        self.logger.error(msg, *args, **kwargs)
+
+    def critical(self, msg, *args, **kwargs):
+        self.logger.critical(msg, *args, **kwargs)
+
+    def exception(self, msg, *args, **kwargs):
+        self.logger.exception(msg, *args, **kwargs)
+
+    def log(self, level, msg, *args, **kwargs):
+        self.logger.log(level, msg, *args, **kwargs)
+
+    def setLevel(self, level):
+        self.logger.setLevel(level)
+
+    def addHandler(self, handler):
+        self.logger.addHandler(handler)
+
+    def removeHandler(self, handler):
+        self.logger.removeHandler(handler)
+
+    def hasHandlers(self):
+        return self.logger.hasHandlers()
+
+    def isEnabledFor(self, level):
+        return self.logger.isEnabledFor(level)
+
+def _appendToLog(content: str, log: Logger):
+    with open(log.logFile, 'a') as f:
+        f.write(content + "\n")

hexif_pyutils-1.0.0/utils/system/__init__.py

@@ -0,0 +1,2 @@
+from ..system import shell
+from ..system import security

hexif_pyutils-1.0.0/utils/system/security.py

@@ -0,0 +1,31 @@
+import subprocess
+from pathlib import Path
+
+class TouchIDError(Exception):
+    pass
+
+def ensureTouchID() -> bool:
+    """Checks if macos touchid executable exists"""
+    exePath = Path('/usr/local/bin/touchid')
+    return exePath.exists()
+
+
+def askForTouchID(reason: str = "confirm a action") -> bool:
+    if not ensureTouchID():
+        raise TouchIDError("touchid executable is not installed")
+    result = subprocess.run(
+        ["touchid", reason],
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+        text=True,
+    )
+
+    if result.returncode == 0:
+        return True
+    if result.returncode == 1:
+        return False
+
+    if result.returncode == 2:
+        raise TouchIDError(
+            result.stderr.strip() or "Touch ID is unavailable"
+        )

hexif_pyutils-1.0.0/utils/system/shell.py

@@ -0,0 +1,20 @@
+import subprocess as _sbp
+
+def run(command: str, **kwargs) -> _sbp.CompletedProcess | None:
+    """Run a command with subprocess.
+
+    Args:
+        command: Command to execute as a string.
+        **kwargs: Additional arguments passed to subprocess.run().
+
+    Returns:
+        The command's stdout if capture_output=True, otherwise None.
+
+    Raises:
+        RuntimeError: If the command returns a non-zero exit code.
+        subprocess.CalledProcessError: If check=True and the command fails.
+    """
+    return _sbp.run(
+        command.split(),
+        **kwargs
+    )