kbasic 0.1.37__tar.gz → 0.1.38__tar.gz

{kbasic-0.1.37 → kbasic-0.1.38}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: kbasic
-Version: 0.1.37
+Version: 0.1.38
 Summary: Keyan's basic utility functions.
 Author: Keyan Gootkin
 Author-email: Keyan Gootkin <keyangootkin@gmail.com>

{kbasic-0.1.37 → kbasic-0.1.38}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "kbasic"
-version = "0.1.37"
+version = "0.1.38"
 description = "Keyan's basic utility functions."
 readme = "README.md"
 authors = [

kbasic-0.1.38/src/kbasic/parsing/__init__.py

@@ -0,0 +1,6 @@
+"""
+kbasic.parsing is a module designed to deal with i/o in an object oriented way.
+"""
+from kbasic.parsing.utils import could_be_path, ensure_path
+from kbasic.parsing.basic import File, Folder
+from kbasic.parsing.parser import parse

kbasic-0.1.38/src/kbasic/parsing/basic.py

@@ -0,0 +1,209 @@
+"""the bulk of kbasics path logic lives here."""
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+# >-|===|>                             Imports                             <|===|-<
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+from os import remove
+from os.path import split, splitext, splitroot, exists, isdir, isfile
+from shutil import copy, move, copytree, rmtree
+from typing import Self, Optional
+from glob import glob
+from pathlib import Path as builtinPath
+from kbasic.parsing.utils import ensure_path
+from kbasic.user_input import yesno
+
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+# >-|===|>                           Definitions                           <|===|-<
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+unreadable_file_types: list[str] = ['.gz', '.tar', '.zip']
+
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+# >-|===|>                             Classes                             <|===|-<
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+class File:
+    def __init__(
+        self, path: str | Self,
+        master: Optional[Self] = None, verbose: bool = False
+    ) -> None:
+        """A convenience class to deal with file io
+
+        Args:
+            path (str): the location of the file.
+            master (str, optional): the path to the template to restore this file 
+                                    from if necessary. Defaults to None.
+            verbose (bool, optional): should this file be annoying. Defaults to 
+                                        False.
+        """
+        if path is None: return None
+        if type(path)==type(self):
+            self = path
+            return None
+        self.path: str = str(builtinPath(path).resolve())
+        self.master = master if not isinstance(master, str) else File(master)
+        self.verbose = verbose
+        self.loaded: bool = False
+        parentpath, self.name = split(self.path)
+        self.title, self.extension = splitext(self.name)
+        self.drive, self.root, _ = splitroot(self.path)
+        self.parent = Folder(parentpath)
+        self.grandparent = self.parent.parent
+        self.greatgrandparent = self.parent.parent.parent
+        self.lines = []
+    def __repr__(self) -> str: return self.path
+    def __str__(self) -> str:
+        if not self.loaded: self.read()
+        return "\n".join(self.lines)
+    def __add__(self, other):
+        match other:
+            case list():
+                other.append(self)
+                return other
+            case File(): return [self, other]
+            case _:
+                raise NotImplementedError(
+                f"can't add object of type: {type(other)} to a Folder object: {repr(self)}"
+                )
+    def __radd__(self, other):
+        if other==0: return self
+        return self.__add__(other)
+    @property
+    def exists(self) -> bool:
+        """_summary_
+
+        Returns:
+            bool: _description_
+        """
+        return exists(self.path)
+    def copy(self, destination:str):
+        """_summary_
+
+        Args:
+            destination (str): _description_
+        """
+        copy(self.path, destination)
+    def move(self, destination:str):
+        """_summary_
+
+        Args:
+            destination (str): _description_
+        """
+        move(self.path, destination)
+        self = File(destination, master=self.master)
+    def update(self) -> None:
+        """_summary_
+        """
+        if self.verbose: print(f'updating {self.name}...')
+        assert self.master is not None, "No master copy to update from."
+        if self.exists: self.delete(interactive=False)
+        self.master.copy(self.path)
+        self = File(self.path, master=self.master)
+    def delete(self, interactive=True) -> None:
+        """summary"""
+        if interactive and not yesno(
+            f"Are you sure you want to permanently delete {self.path} and all of its contents?\n"
+            ):
+            return None
+        remove(self.path)
+    def read(self) -> None:
+        """summary"""
+        if not self.exists or self.extension in unreadable_file_types: return []
+        with open(self.path, 'r') as file:
+            self.lines = [f.strip('\n') for f in file.readlines()]
+        self.loaded = True
+    def load(self) -> None:
+        """docstring"""
+        self.read()
+    def save(self, interactive=True):
+        """summary"""
+        if interactive and not yesno(
+            f"Are you sure you want to permanently overwrite {self.path}?\n"
+            ):
+            return None
+        with open(self.path, 'w+') as file:
+            if not file.writable:
+                raise PermissionError(
+                    f"attempted to save unwritable file: {self.path}"
+                    )
+            file.writelines("\n".join(self.lines))
+
+class Folder:
+    def __init__(
+        self, path: str|Self,
+        master: Optional[Self] = None
+    ) -> None:
+        if type(path)==type(self):
+            path = path.path
+        self.path = str()
+        self.master = master if not isinstance(master, str) else Folder(master)
+        self.parentpath, self.name = split(self.path)
+    def __repr__(self) -> str: return self.path
+    def __len__(self) -> int: return len(self.children)
+    def __iter__(self):
+        self.index = 0
+        return self
+    def __next__(self):
+        if self.index < len(self):
+            i = self.index
+            self.index += 1
+            return Folder(self.children[i]) if isdir(self.children[i]) else File(self.children[i])
+        raise StopIteration
+    def __add__(self, other):
+        match other:
+            case str():
+                p = f"{self.path}/{other}"
+                return Path(p)
+            case File(): return self.children+[other]
+            case Folder(): return self.children + other.children
+            case list(): return self.children + other
+            case _:
+                raise NotImplementedError(
+                    f"can't add object of type: {type(other)} to a Folder object: {repr(self)}"
+                    )
+    def __radd__(self, other):
+        if other==0: return [self]
+        return self.__add__(other)
+    @property
+    def parent(self) -> Self:
+        """summary"""
+        return Folder(self.parentpath)
+    @property
+    def exists(self) -> bool:
+        """summary"""
+        return exists(self.path)
+    def glob(self, pattern: str):
+        """summary"""
+        return glob(self.path+pattern)
+    @property
+    def children(self) -> list:
+        """summary"""
+        return self.glob("/*")
+    def ls(self) -> None:
+        """summary"""
+        print("\n".join(self.children))
+    def make(self) -> None:
+        """summary"""
+        ensure_path(self.path)
+    def copy(self, destination:str) -> None:
+        """summary"""
+        copytree(self.path, destination)
+    def revert(self) -> None:
+        """summary"""
+        assert self.master is not None, "No master copy to update from."
+        if self.exists: self.delete(interactive=False)
+        self.master.copy(self.path)
+        self = Folder(self.path, master=self.master)
+    def delete(self, interactive=True) -> None:
+        """summary"""
+        if interactive and not yesno(
+            f"Are you sure you want to permanently delete {self.path} and all of its contents?\n"
+            ):
+            return None
+        rmtree(self.path)
+
+class Path:
+    """
+    A constructor to return either a kbasic.Folder, kbasic.File, or a pathlib.Path.
+    """
+    def __new__(cls, path: str, *args, **kwds):
+        if isdir(path): return Folder(path, *args, **kwds)
+        if isfile(path): return File(path, *args, **kwds)
+        return builtinPath(path)

kbasic-0.1.38/src/kbasic/parsing/log.py

@@ -0,0 +1,22 @@
+"""A logger!"""
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+# >-|===|>                             Imports                             <|===|-<
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+from typing import Callable
+from datetime import datetime
+from kbasic.parsing.basic import File
+
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+# >-|===|>                            Functions                            <|===|-<
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+def default_log_formatter(msg: str) -> str:
+    """prefix datetime.now on all log entries"""
+    return f"{str(datetime.now())}: {msg}"
+
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+# >-|===|>                             Classes                             <|===|-<
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+class Log(File):
+    def __init__(self, path: str, verbose: bool = False) -> None:
+        File.__init__(self, path, verbose=verbose)
+    def __call__(self, msg: str, fmt: Callable[[str], str] = default_log_formatter) -> None: pass

kbasic-0.1.38/src/kbasic/parsing/parser.py

@@ -0,0 +1,31 @@
+"""a handler to take a path and deliver the correct object to the user"""
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+# >-|===|>                             Imports                             <|===|-<
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+from os.path import isfile, isdir
+from kbasic.typing import Array
+from kbasic.parsing.basic import File, Folder
+from kbasic.parsing.toml import TOML
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+# >-|===|>                            Functions                            <|===|-<
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+def parse(path: str | list[str]) -> Folder | File | list[Folder | File]:
+    """take a path or list of paths and turn them into Folder or File objects as appropriate.
+
+    Args:
+        path (str | list[str]): the path you want to be a File/Folder object
+
+    Raises:
+        FileNotFoundError: if you can't match path
+
+    Returns:
+        Folder | File | list[Folder|File]: path(s) as a Folder/File.
+    """
+    match path:
+        case str():
+            if isdir(path): return Folder(path)
+            if isfile(path):
+                return TOML(path) if path.split('.')[-1]=='toml' else File(path)
+        case _ if type(path) in Array.types:
+            return [Folder(p) if isdir(p) else File(p) if isfile(p) else None for p in path]
+    raise FileNotFoundError(f"Unable to parse path(s): {path}")

kbasic-0.1.38/src/kbasic/parsing/toml.py

@@ -0,0 +1,24 @@
+"""implement a toml class that loads the variables into its __dict__"""
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+# >-|===|>                             Imports                             <|===|-<
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+from tomllib import load as tomlload
+from kbasic.parsing.basic import File
+
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+# >-|===|>                             Classes                             <|===|-<
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+class TOML(File):
+    def __init__(
+        self, path: str, 
+        verbose: bool = False
+    ) -> None:
+        File.__init__(self, path, verbose=verbose)
+        if self.exists: self.read()
+    def read(self):
+        """summary"""
+        self.loaded = True
+        with open(self.path, 'rb') as f:
+            self._attrs = tomlload(f)
+        self.__dict__ |= self._attrs
+        self.lines = [f"{k}={v}" for k,v in self._attrs.items()]

kbasic-0.1.38/src/kbasic/parsing/utils.py

@@ -0,0 +1,27 @@
+"""basic utility functions for kbasic.parsing, mostly from os.path"""
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+# >-|===|>                             Imports                             <|===|-<
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+from os import system
+from os.path import isdir
+
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+# >-|===|>                            Functions                            <|===|-<
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+def ensure_path(path: str) -> None:
+    """make sure that a path exists
+
+    Args:
+        path (str): the path you ant to exist
+    """
+    system(f"mkdir -p {path}")
+def could_be_path(path: str) -> bool:
+    """determine if this is anywhere close to a valid path
+
+    Args:
+        path (str): the path (?) to check
+
+    Returns:
+        bool: True if the first two members of the path are valid else False.
+    """
+    return isdir('/'.join(path.split('/')[:3]))

{kbasic-0.1.37 → kbasic-0.1.38}/src/kbasic/vectors.py

@@ -1,10 +1,10 @@
 # !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
 # >-|===|>                             Imports                             <|===|-<
 # !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
-from numpy import array, cos, sin, sqrt, exp
 from typing import Self
 from collections.abc import Generator
-from kbasic.typing import Number, ArrayLike
+from numpy import array, cos, sin, sqrt, exp
+from kbasic.typing import Number, Array
 
 # !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
 # >-|===|>                           Definitions                           <|===|-<
@@ -13,7 +13,7 @@ from kbasic.typing import Number, ArrayLike
 # >-|===|>                            Functions                            <|===|-<
 # !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
 def hamilton_product(q1, q2):
-    a1, b1, c1, d1 = q1 
+    a1, b1, c1, d1 = q1
     a2, b2, c2, d2 = q2
     return array([
         a1*a2 - b1*b2 - c1*c2 - d1*d2,
@@ -24,7 +24,7 @@ def hamilton_product(q1, q2):
 def organize_components(components) -> tuple[float|int]:
     match components:
         case (x, *_) if type(x) in Number.types: return components
-        case (x,) if type(x) in ArrayLike.types: return tuple(x) 
+        case (x,) if type(x) in Array.types: return tuple(x)
         case (Generator(),): return tuple(components[0])
         case (Vector(),): return components[0].components
         case _: raise TypeError(f"{components} cannot be matched")
@@ -36,11 +36,11 @@ class Vector:
     def __init__(self, *components) -> None:
         self.components = organize_components(components)
         self.ndims = self.dim = self.dimensions = len(components) #i always forget which one i choose :)
-    def __repr__(self) -> str: 
+    def __repr__(self) -> str:
         return str(self.components)
-    def __len__(self) -> int: 
+    def __len__(self) -> int:
         return self.dimensions
-    def __abs__(self) -> Number: 
+    def __abs__(self) -> Number:
         return sqrt(sum(array(self.components)**2))
     def __iter__(self) -> Self:
         self._index = 0
@@ -50,16 +50,16 @@ class Vector:
             value = self.components[self._index]
             self._index += 1
             return value
-        except IndexError: raise StopIteration
+        except IndexError as err: raise StopIteration from err
     def __add__(self, other) -> Self:
         match other:
             case Vector(): return type(self)(xs+xo for xs, xo in zip(self.components, other.components))
             case x if type(x) in Number.types: return type(self)(x+other for x in self.components)
-            case x if type(x) in ArrayLike.types: return type(self)(xs+xo for xs, xo in zip(self.components, other))
+            case x if type(x) in Array.types: return type(self)(xs+xo for xs, xo in zip(self.components, other))
     def __sub__(self, other) -> Self:
         match other:
             case x if type(x) in Number.types: return type(self)(x-other for x in self.components)
-            case x if type(x) in ArrayLike.types: return type(self)(xs-xo for xs, xo in zip(self.components, other))
+            case x if type(x) in Array.types: return type(self)(xs-xo for xs, xo in zip(self.components, other))
             case Vector(): return type(self)(xs-xo for xs, xo in zip(self.components, other.components))
     def __mul__(self, other) -> Self|Number:
         match other:
@@ -113,7 +113,7 @@ class R2(Vector):
     def rotate(self, angle):
         r = self.x + 1j*self.y 
         r_rotated = r * exp(1j*angle)    
-        self.__init__(r_rotated.real, r_rotated.imag)    
+        self = R2(r_rotated.real, r_rotated.imag)    
 class R3(Vector):
     def __init__(self, *components):
         self.components: tuple[Number] = organize_components(components)
@@ -132,11 +132,14 @@ class R3(Vector):
         rotation = array(Norm([cos(angle/2), *(axis*sin(angle/2))]).components)
         rotation_inverse = array([rotation[0], *-rotation[1:]])
         rotated_vector = hamilton_product(hamilton_product(rotation, qs), rotation_inverse)[1:]
-        self.__init__(*rotated_vector)
+        self = R3(*rotated_vector)
 class Matrix:
-    def __init__(self, array):
-        self.array = array 
+    def __init__(self, arr):
+        self.array = arr
     def __mul__(self, other):
         match other:
             case Vector():
-                res = [[self.array[i,j]*other.components[i] for i in range(len(other))] for j in range(len(other))]
+                res = [
+                    [self.array[i,j]*other.components[i] for i in range(len(other))] 
+                for j in range(len(other))]
+                return res

kbasic-0.1.37/src/kbasic/parsing.py

@@ -1,219 +0,0 @@
-# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
-# >-|===|>                             Imports                             <|===|-<
-# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
-#pysim imports
-from kbasic.user_input import yesno
-from kbasic.typing import Array, Number
-#nonpysim imports
-from time import time
-from datetime import datetime
-from typing import Self, Optional, Callable
-from numpy import ndarray
-from glob import glob 
-from shutil import copy, move, copytree, rmtree
-from os.path import isdir, isfile, exists, abspath, expanduser, expandvars, \
-                    normpath, splitroot, split, splitext
-from os import system, remove
-import tomllib
-
-# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
-# >-|===|>                           Definitions                           <|===|-<
-# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
-unreadable_file_types: list[str] = ['.gz', '.tar', '.zip']
-
-# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
-# >-|===|>                            Functions                            <|===|-<
-# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
-def clean_path(path: str) -> str:
-    """return an absolute, normalzed, cleaned path with expanded environment 
-    variables and user characters
-
-    Args:
-        path (str): input path sting
-
-    Returns:
-        str: a path
-    """
-    return normpath(expanduser(expandvars(path)))
-def ensure_path(path: str) -> None:
-    """make sure that a path exiss
-
-    Args:
-        path (str): the path you ant to exist
-    """
-    system(f"mkdir -p {path}")
-def could_be_path(path: str) -> bool: 
-    """determine if this is anywhere close to a valid path
-
-    Args:
-        path (str): the path (?) to check
-
-    Returns:
-        bool: True if the first two members of the path are valid else False.
-    """
-    return isdir('/'.join(path.split('/')[:2])) 
-def default_log_formater(msg: str) -> str:
-    return f"{str(datetime.now())}: {msg}"
-def delta_log_formater(msg: str, start_time: Number) -> str:
-    return f"Δt: {(time()-start_time)*1e6:.1f} μs | {msg}"
-# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
-# >-|===|>                             Classes                             <|===|-<
-# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
-class File:
-    def __init__(self, path: str|Self, master=None, verbose:bool=False) -> None:
-        """A convenience class to deal with file io
-
-        Args:
-            path (str): the location of the file.
-            master (str, optional): the path to the template to restore this file 
-                                    from if necessary. Defaults to None.
-            verbose (bool, optional): should this file be annoying. Defaults to 
-                                        False.
-        """
-        if path is None: return None
-        elif type(path)==type(self): 
-            self = path
-            return None
-        self.path: str = clean_path(path)
-        self.master = master if not isinstance(master, str) else File(master)
-        self.verbose = verbose
-        parentpath, self.name = split(self.path)
-        self.title, self.extension = splitext(self.name)
-        self.drive, self.root, tail = splitroot(self.path)
-        self.parent = Folder(parentpath)
-        self.grandparent = self.parent.parent
-        self.greatgrandparent = self.parent.parent.parent
-        self.lines = []
-    def __repr__(self) -> str: return self.path
-    def __str__(self) -> str: return "\n".join(self.lines)
-    def __add__(self, other):
-        match other: 
-            case list():
-                other.append(self)
-                return other
-            case File(): return [self, other]
-             
-            case _: raise NotImplementedError(f"can't add object of type: {type(other)} to a Folder object: {repr(self)}")
-    def __radd__(self, other):
-        if other==0: return self 
-        return self.__add__(other)
-    @property
-    def exists(self) -> bool: return exists(self.path)
-    def copy(self, destination:str): copy(self.path, destination)
-    def move(self, destination:str): 
-        move(self.path, destination)
-        self = File.__init__(destination, master=self.master)
-    def update(self) -> None:
-        if self.verbose: print(f'updating {self.name}...')
-        assert self.master is not None, "No master copy to update from."
-        if self.exists: self.delete(interactive=False)
-        self.master.copy(self.path)
-        self = File(self.path, master=self.master)
-    def delete(self, interactive=True) -> None:
-        if interactive and not yesno(f"Are you sure you want to permanently delete {self.path} and all of its contents?\n"): return None
-        else: remove(self.path)     
-    def read(self) -> None: 
-        if not self.exists: return []
-        with open(self.path, 'r') as file: 
-            self.lines = [f.strip('\n') for f in file.readlines()]   
-    def save(self, interactive=True):
-        if interactive and not yesno(f"Are you sure you want to permanently overwrite {self.path}?\n"):
-            return None
-        with open(self.path, 'w+') as file:
-            if not file.writable: raise PermissionError(f"attempted to save unwritable file: {self.path}")
-            file.writelines("\n".join(self.lines))
-class Log(File):
-    def __init__(self, path: str | Self, verbose: bool = False, fmt: Callable[[str], str] = default_log_formater):
-        File.__init__(self, path, verbose=verbose)
-        self.fmt = fmt
-    def __call__(self, msg: Array|str, *args, **kwds):
-        match msg:
-            case str(): output = [self.fmt(msg, *args, **kwds)]
-            case _ if type(msg) in Array.types: output = [self.fmt(m, *args, **kwds) for m in msg]
-        if self.verbose: print(output)
-        self.lines += output 
-        self.save(interactive=False)
-class TOML(File):
-    def __init__(self, path: str, verbose: bool = False):
-        File.__init__(self, path, verbose=verbose)
-        self.loaded: bool = False
-        if self.exists: self.read()
-    def read(self):
-        self.loaded = True
-        self._attrs = tomllib.load(open(self.path, 'rb'))
-        self.__dict__ |= self._attrs 
-        self.lines = [f"{k}={v}" for k,v in self._attrs.items()]
-class Folder:
-    def __init__(self, path: str|Self, master: Optional[Self]=None) -> None:
-        if type(path)==type(self): 
-            self.__init__(path.path)
-            return None
-        self.path = clean_path(path)
-        self.master = master if not isinstance(master, str) else Folder(master)
-        self.parentpath, self.name = split(self.path)
-    def __repr__(self) -> str: return self.path
-    def __len__(self) -> int: return len(self.children)
-    def __iter__(self):
-        self.index = 0 
-        return self
-    def __next__(self):
-        if self.index < len(self):
-            i = self.index 
-            self.index += 1 
-            return Folder(self.children[i]) if isdir(self.children[i]) else File(self.children[i])
-        else: raise StopIteration
-    def __add__(self, other):
-        match other:
-            case str():
-                p = f"{self.path}/{other}"
-                return Folder(p) if isdir(p) else File(p) if isfile(p) else None
-            case File(): return self.children+[other]
-            case Folder(): return self.children + other.children
-            case list(): return self.children + other
-            case _: raise NotImplementedError(f"can't add object of type: {type(other)} to a Folder object: {repr(self)}")
-    def __radd__(self, other):
-        if other==0: return [self]
-        return self.__add__(other)
-    @property
-    def parent(self) -> Self:
-        return Folder(self.parentpath)
-    @property
-    def exists(self) -> bool: return exists(self.path)
-    @property
-    def children(self) -> list: return glob(self.path+"/*" if self.path!='/' else "/*")
-    def ls(self) -> None: print("\n".join(self.children))
-    def make(self) -> None: ensure_path(self.path)
-    def copy(self, destination:str) -> None: copytree(self.path, destination)
-    def revert(self) -> None:
-        assert self.master is not None, "No master copy to update from."
-        if self.exists: self.delete(interactive=False)
-        self.master.copy(self.path)
-        self = Folder(self.path, master=self.master)
-    def delete(self, interactive=True) -> None:
-        if interactive and not yesno(f"Are you sure you want to permanently delete {self.path} and all of its contents?\n"): 
-            return None
-        rmtree(self.path)
-
-# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
-# >-|===|>                            Functions                            <|===|-<
-# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
-def parse(path: str | list[str]) -> Folder | File | list[Folder | File]:
-    """take a path or list of paths and turn them into Folder or File objects as appropriate.
-
-    Args:
-        path (str | list[str]): the path you want to be a File/Folder object
-
-    Raises:
-        FileNotFoundError: if you can't match path
-
-    Returns:
-        Folder | File | list[Folder|File]: path(s) as a Folder/File.
-    """
-    match path:
-        case str():
-            if isdir(path): return Folder(path)
-            if isfile(path): 
-                return TOML(path) if path.split('.')[-1]=='toml' else File(path)
-        case list() | ndarray():
-            return [Folder(p) if isdir(p) else File(p) if isfile(p) else None for p in path]
-    raise FileNotFoundError(f"Unable to parse path(s): {path}")