kbasic 0.1.39__tar.gz → 0.1.40__tar.gz

{kbasic-0.1.39 → kbasic-0.1.40}/PKG-INFO

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

{kbasic-0.1.39 → kbasic-0.1.40}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "kbasic"
-version = "0.1.39"
+version = "0.1.40"
 description = "Keyan's basic utility functions."
 readme = "README.md"
 authors = [
@@ -26,4 +26,4 @@ dev = [
 ]
 
 [tool.pytest.ini_options]
-addopts = "-v --maxfail=1 --cov=kbasic"
+addopts = "-v --maxfail=1 --cov=kbasic --import-mode=importlib"

{kbasic-0.1.39 → kbasic-0.1.40}/src/kbasic/Tex.py

@@ -1,27 +1,28 @@
-# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
-# >-|===|>                             Imports                             <|===|-<
-# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+# >-|===|>                                    Imports                                     <|===|-<
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
 from fractions import Fraction
-import warnings 
-# Syntax warnings show up everytime you \something so we ignore all of em, hope this doesn't fuck anything up!
+import warnings
+# Syntax warnings show up everytime you \something so we ignore all of em, 
+# hope this doesn't fuck anything up!
 warnings.filterwarnings(action='ignore', category=SyntaxWarning)
 from pylatexenc.latex2text import LatexNodes2Text
 
-# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
-# >-|===|>                           Definitions                           <|===|-<
-# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+# >-|===|>                                  Definitions                                   <|===|-<
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
 l2t = LatexNodes2Text().latex_to_text
 
-# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
-# >-|===|>                            Functions                            <|===|-<
-# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+# >-|===|>                                   Functions                                    <|===|-<
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
 def texfraction(num) -> str: 
     f = Fraction(str(num))
     return r"$\frac{" + str(f.numerator) + "}{" + str(f.denominator) + r"}$"
 
-# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
-# >-|===|>                             Classes                             <|===|-<
-# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+# >-|===|>                                    Classes                                     <|===|-<
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
 class Tex(str):
     def __init__(self, x: str) -> None:
         x = x.strip(' $')

{kbasic-0.1.39 → kbasic-0.1.40}/src/kbasic/array.py

@@ -1,8 +1,9 @@
+"""pure array operations"""
 # !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
 # >-|===|>                             Imports                             <|===|-<
 # !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
-from kbasic.typing import Number, ArrayLike, NDArray
 from typing import Callable
+from kbasic.typing import Number, ArrayLike, NDArray
 from numpy import argmin, any, all, absolute, hypot, logspace, log10, where, \
                   nanmean, nanmin, nanmax, sqrt, linspace, nanstd, array, isnan, \
                   isfinite, arange, mgrid, r_, c_, zeros, delete, unravel_index
@@ -97,7 +98,7 @@ def interpolate2d(
         data: ArrayLike, factor: int, 
         method: str = 'linear',
         periodic: bool = True
-) -> NDArray:
+    ) -> NDArray:
     """interpolate 2d data on a regular grid by an even factor
 
     Args:
@@ -125,7 +126,7 @@ def kspec1d(
         image: ArrayLike, 
         bins: int = 100, 
         return_bin_edges: bool = False
-        ) -> tuple[NDArray, NDArray, NDArray]:
+    ) -> tuple[NDArray, NDArray, NDArray]:
     """Take a 2d image and turn it into a 1d fft
 
     Args:
@@ -151,9 +152,10 @@ def kspec1d(
     if not return_bin_edges: return kx, ks, kerr
     return kgrid, kx, ks, kerr
 def kspec3d(
-        cube: ArrayLike, 
+        cube: ArrayLike,
         parallel_axis: int = 0
-        ) -> tuple[NDArray]:
+    ) -> tuple[NDArray]:
+    """docstring"""
     # Set up parallel axis
     n_par = cube.shape[parallel_axis]
     parallel = arange(-(n_par//2), n_par//2+1)
@@ -179,4 +181,4 @@ def kspec3d(
             ) for i in range(n_perp-1)
         ] for j in tqdm(range(n_par), position=1, total=n_par)
     ])
-    return parallel[n_par//2:], perp, k.T[:, n_par//2:]
+    return parallel[n_par//2:], perp, k.T[:, n_par//2:]

{kbasic-0.1.39 → kbasic-0.1.40}/src/kbasic/bar.py

@@ -1,26 +1,21 @@
-# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
-# >-|===|>                             Imports                             <|===|-<
-# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
-from kbasic.typing import Number
-from kbasic.strings import green, yellow, black
+"""progress bar code"""
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+# >-|===|>                                    Imports                                     <|===|-<
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
 from collections.abc import Iterable
 from contextlib import contextmanager
 import inspect
+from kbasic.typing import Number
+from kbasic.strings import green, yellow, black
 from tqdm import tqdm
 
-# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
-# >-|===|>                              Types                              <|===|-<
-# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
-# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
-# >-|===|>                           Definitions                           <|===|-<
-# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
-# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
-# >-|===|>                            Functions                            <|===|-<
-# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
-def bar(
-        x: Number, total: Number, 
-        width: int = 20, border: str = "|", block: str = "▉", color: str = 'white'
-) -> str:
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+# >-|===|>                                   Functions                                    <|===|-<
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+def bar_string(
+        x: Number, total: Number,
+        width: int = 20, border: str = "|", block: str = "▉", color: bool = True
+    ) -> str:
     """create a string representing a progress bar set at 100 * x / total % full.
 
     Args:
@@ -35,8 +30,9 @@ def bar(
     """
     full = int((x/total) * width // 1)
     empty = width - full
-    bar = border + (full-1)*green(block) + yellow(block) + empty*black(block, "faint") + border 
-    return bar
+    if color: output = (full-1)*green(block) + yellow(block) + empty*black(block, "faint")
+    else: output = (full-1)*block + empty*" "
+    return border + output + border
 @contextmanager
 def redirect_to_tqdm():
     """maybe make print statements show up below the bar without fucking everything up?
@@ -48,7 +44,7 @@ def redirect_to_tqdm():
         # If tqdm.tqdm.write raises error, use builtin print
         try:
             tqdm.write(*args, **kwargs)
-        except:
+        except Exception:
             old_print(*args, ** kwargs)
 
     try:
@@ -61,23 +57,19 @@ def progress_bar(iterator: Iterable, **kwargs):
     """tqdm with print redirected to tqdm.write
     """
     with redirect_to_tqdm():
-        for x in tqdm(iterator, **kwargs):
-            yield x
+        yield from tqdm(iterator, **kwargs)
 def verbose_bar(iterator: Iterable, verbose: bool, **kwargs):
     """just a progress bar if verbose is true.
     """
     return progress_bar(iterator, **kwargs) if verbose else iterator
 
-# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
-# >-|===|>                            Decorators                           <|===|-<
-# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
-# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
-# >-|===|>                             Classes                             <|===|-<
-# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+# >-|===|>                                    Classes                                     <|===|-<
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
 class ProgressBar(tqdm):
     def __init__(self, *args, **kwargs):
         super().__init__(self, *args, **kwargs)
         self.iter = self.initial
-    def update(self, iter: int): 
+    def update(self, iter: int):
         super().update(n=iter-self.iter)
-        self.iter = iter
+        self.iter = iter

{kbasic-0.1.39 → kbasic-0.1.40}/src/kbasic/parsing/basic.py

@@ -2,14 +2,16 @@
 # !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
 # >-|===|>                             Imports                             <|===|-<
 # !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
-from os import remove
-from os.path import split, splitext, splitroot, exists, isdir, isfile, abspath
+from os import remove, system, walk
+from os.path import split, splitext, splitroot, exists, isdir, isfile, abspath, \
+    expanduser, expandvars, basename
 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
+from kbasic.strings import cyan
 from kbasic.typing import Array
 
 # !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
@@ -34,24 +36,27 @@ class File:
             verbose (bool, optional): should this file be annoying. Defaults to 
                                         False.
         """
+        self.loaded: bool = False
         if path is None: return None
         if type(path)==type(self):
-            self = path
-            return None
-        self.path: str = abspath(str(builtinPath(path).resolve()))
-        self.master = master if not isinstance(master, str) else File(master)
+            self.path = path.path
+        else:
+            self.path: str = abspath(expandvars(expanduser(path)))
+        self.master = 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.lines = []
-    def __repr__(self) -> str: 
+    def __repr__(self) -> str:
         return self.path
     def __str__(self) -> str:
         if not self.loaded: self.read()
         return "\n".join(self.lines)
+    def __eq__(self, other) -> bool:
+        if type(other) != File: return False
+        return (self.path == other.path) & (self.lines == other.lines)
     def __add__(self, other):
         match other:
             case list():
@@ -74,32 +79,35 @@ class File:
         """
         return exists(self.path)
     @property
-    def writeable(self) -> bool:
+    def writable(self) -> bool:
         """whether or not we can write this type of file with this object"""
-        return self.extension in unreadable_file_types
-    def copy(self, destination:str):
+        return self.extension not in unreadable_file_types
+    def copy(self, destination: Optional[str] = None):
         """_summary_
 
         Args:
             destination (str): _description_
         """
+        if destination is None: destination = str(self.parent / f"{self.title}-copy{self.extension}")
         copy(self.path, destination)
+        return File(destination, verbose=self.verbose, master=self)
     def move(self, destination:str):
         """_summary_
 
         Args:
             destination (str): _description_
         """
+        if self.verbose: print(cyan(f'moving {self.path} to {destination}...'))
         move(self.path, destination)
-        self = File(destination, master=self.master)
-    def update(self) -> None:
+        self.__init__(destination, master=self.master)
+    def update(self) -> None: # think of a better name for this function
         """_summary_
         """
-        if self.verbose: print(f'updating {self.name}...')
+        if self.verbose: print(cyan(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)
+        self.__init__(self.path, master=self.master)
     def delete(self, interactive=True) -> None:
         """summary"""
         if interactive and not yesno(
@@ -112,6 +120,7 @@ class File:
         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()]
+            if self.lines==['']: self.lines = []
         self.loaded = True
     def load(self) -> None:
         """docstring"""
@@ -123,21 +132,28 @@ class File:
             ):
             return None
         with open(self.path, 'w+') as file:
-            if not file.writable:
+            if not self.writable:
                 raise PermissionError(
                     f"attempted to save unwritable file: {self.path}"
                     )
-            file.writelines("\n".join(self.lines))
+            if len(self.lines) > 0: file.writelines("\n".join(self.lines))
+            return None
     def write(self, text: str | Array, interactive=False) -> None:
         """add text to this File.lines then save the file"""
         match text:
-            case str(): 
+            case str():
                 self.lines.append(text)
-            case _ if type(text) in Array.types: 
+            case _ if type(text) in Array.types:
                 self.lines += list(text)
-            case _: 
-                raise TypeError(f"must supply either string or an array of strings\nwas given text of type: {type(text)}")
+            case _:
+                raise TypeError(f"""
+                    must supply either string or an array of strings
+                    was given text of type: {type(text)}
+                """)
         self.save(interactive=interactive)
+    def touch(self) -> None:
+        """summary"""
+        system(f"touch {self.path}")
 
 class Folder:
     def __init__(
@@ -147,10 +163,17 @@ class Folder:
         if path is None: return None
         if type(path)==type(self):
             path = path.path
-        self.path = abspath(str(builtinPath(path).resolve()))
+        self.path = abspath(expandvars(expanduser(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 __str__(self) -> str:
+        output = []
+        for root, dirs, files in walk(self.path):
+            level = root.replace(self.path, '').count('/')
+            output.append(f'{'----'*level}{basename(root)}')
+            for f in files: output.append(f'|{'----'*(level+1)}> {f}')
+        return '\n'.join(output)
     def __len__(self) -> int: return len(self.children)
     def __iter__(self):
         self.index = 0
@@ -159,16 +182,18 @@ class Folder:
         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])
+            return 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
+                return Path(f"{self.path}/{other}")
+            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)}"
@@ -176,32 +201,35 @@ class Folder:
     def __radd__(self, other):
         if other==0: return [self]
         return self.__add__(other)
-    def __div__(self, other):
+    def __truediv__(self, other):
         match other:
             case str(): return Path(f"{self.path}/{other}")
     @property
     def parent(self) -> Self:
         """summary"""
-        return Folder(self.parentpath)
+        return Folder(self.parentpath) if len(self.parentpath) > 3 else None
     @property
     def exists(self) -> bool:
         """summary"""
         return exists(self.path)
     def glob(self, pattern: str):
         """summary"""
-        return glob(self.path+pattern)
+        return glob(self.path+'/'+pattern)
     @property
     def children(self) -> list:
         """summary"""
-        return self.glob("/*")
+        return [Path(p) for p in self.glob("*")]
     def ls(self) -> None:
         """summary"""
-        print("\n".join(self.children))
+        print("\n".join([p.path for p in self.children]))
     def make(self) -> None:
         """summary"""
         ensure_path(self.path)
     def copy(self, destination:str) -> None:
         """summary"""
+        if destination is None: destination = str(self.parent / f"{self.name}-copy")
+        copy(self.path, destination)
+        return File(destination, verbose=self.verbose, master=self)
         copytree(self.path, destination)
     def revert(self) -> None:
         """summary"""

{kbasic-0.1.39 → kbasic-0.1.40}/src/kbasic/shell.py

@@ -1,27 +1,25 @@
-# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
-# >-|===|>                             Imports                             <|===|-<
-# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
-from kbasic.bar import redirect_to_tqdm
-from kbasic.audio import success
-from kbasic.environment import isAnvil 
-if isAnvil: from kbasic.environment.anvil import anvil_user
-from typing import Any
+"""utilities for interacting with shell"""
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+# >-|===|>                                    Imports                                     <|===|-<
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
 from subprocess import check_output, DEVNULL
-from tqdm import tqdm
 from time import sleep
 import asyncio
+from tqdm import tqdm
+from kbasic.bar import redirect_to_tqdm
+from kbasic.audio import success
+from kbasic.environment import isAnvil
+if isAnvil: from kbasic.environment.anvil import anvil_user
 
-# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
-# >-|===|>                              Types                              <|===|-<
-# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
-# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
-# >-|===|>                           Definitions                           <|===|-<
-# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+# >-|===|>                                  Definitions                                   <|===|-<
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
 bad: list[str] = ['\x1b[31m', '\x1b[34m', '\x1b[m']
 _USERNAME_: str = "x-kgootkin" if not isAnvil else anvil_user
-# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
-# >-|===|>                            Functions                            <|===|-<
-# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+# >-|===|>                                   Functions                                    <|===|-<
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
 def parse_shell_output(output: str | list[str]) -> str | list[str]:
     """take the output of a shell command and make it nice
 
@@ -79,12 +77,9 @@ def anvil_queue(username=_USERNAME_):
     return anvil(f"squeue -u {username}")
 qs = anvil_queue
 
-# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
-# >-|===|>                            Decorators                           <|===|-<
-# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
-# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
-# >-|===|>                             Classes                             <|===|-<
-# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!== 
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+# >-|===|>                                    Classes                                     <|===|-<
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
 class AnvilJob:
     def __init__(self, queue_row: str, sep="DISTINCTSEPERATOR") -> None:
         self.sep = sep
@@ -125,7 +120,11 @@ async def get_anvil_jobs_async(username=_USERNAME_):
     if type(q)==str: return []
     return [AnvilJob(x) for x in q[1:]]
 async def get_anvil_sim_iter(name: str, username=_USERNAME_):
-    iter = int(await asyncio.to_thread(anvil, f"ls /anvil/scratch/{username}/sims/{name}/Output/Fields/Magnetic/Total/x/")[-1][5:-3])
+    """docstring"""
+    iter = int(await asyncio.to_thread(
+        anvil,
+        f"ls /anvil/scratch/{username}/sims/{name}/Output/Fields/Magnetic/Total/x/"
+    )[-1][5:-3])
     return iter
 class AnvilQueue:
     def __init__(self, username=_USERNAME_):

{kbasic-0.1.39 → kbasic-0.1.40}/src/kbasic/strings.py

@@ -1,3 +1,4 @@
+# pylint: skip-file
 # !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
 # >-|===|>                             Imports                             <|===|-<
 # !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==

{kbasic-0.1.39 → kbasic-0.1.40}/src/kbasic/typing.py

@@ -10,7 +10,7 @@
 # !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
 from numpy import int8, uint8, int16, uint16, int32, uint32, int64, uint64, \
                   float16, float32, float64, longdouble, complex64, complex128, \
-                  clongdouble
+                  clongdouble, ndarray
 from numpy.typing import NDArray, ArrayLike
 from collections.abc import Callable, Generator
 from typing import Any
@@ -18,7 +18,7 @@ from typing import Any
 # >-|===|>                              Types                              <|===|-<
 # !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
 class Array:
-    types: list = [NDArray, list, set, tuple, Generator]
+    types: list = [NDArray, ndarray, list, set, tuple, Generator]
 class Number:
     types: list = [
         int, int8, uint8, int16, uint16, int32, uint32, int64, uint64, 

{kbasic-0.1.39 → kbasic-0.1.40}/src/kbasic/user_input.py

@@ -1,19 +1,34 @@
-# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
-# >-|===|>                             Imports                             <|===|-<
-# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
-from kbasic.typing import Number
+"""handle user inputs"""
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+# >-|===|>                                    Imports                                     <|===|-<
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
 from typing import Any
+from contextlib import contextmanager
+from tempfile import TemporaryFile
+import sys
+from kbasic.typing import Number
 
-# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
-# >-|===|>                            Functions                            <|===|-<
-# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+# >-|===|>                                   Functions                                    <|===|-<
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+@contextmanager
+def simulate_user_input(*user_input: tuple[str]):
+    """change stdin to simulate the user entering a string"""
+    with TemporaryFile(mode='a+') as answers:
+        answers.write("\n".join(user_input))
+        answers.seek(0)
+        orig = sys.stdin
+        sys.stdin = answers
+        yield
+        sys.stdin = orig
 def parse_user_input(response: str, sep: str = ',') -> Any:
+    """turn user supplied strings into appropriate python objects"""
     try: return Number(response)
-    except ValueError: i=0
+    except ValueError: _ = None
     match response:
-        case str(x) if ',' in x: 
+        case str(x) if ',' in x:
             return tuple(parse_user_input(xi.strip(), sep=sep) for xi in response.split(sep))
-        case _: 
+        case _:
             return response.lower().strip()
 def yesno(prompt: str):
     """
@@ -38,6 +53,7 @@ def yesno(prompt: str):
                 raise ValueError("need a response with either y or n in it.")
 
         return retry_yesno()
-def interactive_set_attribute(obj: Any, attr: str, default_answer: str = "") -> None:
+def interactive_set_attribute(obj: Any, attr: str) -> None:
+    """prompt the user to set an objects attribute"""
     res: Any = parse_user_input(input(f"Set a value for {repr(obj)}.{attr}:\n\t"))
-    setattr(obj, attr, res)
+    setattr(obj, attr, res)

kbasic-0.1.40/src/kbasic/vectors.py

@@ -0,0 +1,214 @@
+"""Implement vector classes for vector analysis"""
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+# >-|===|>                                    Imports                                     <|===|-<
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+from typing import Self
+from collections.abc import Generator
+from functools import total_ordering
+from numpy import array, cos, sin, sqrt, exp, sum
+from kbasic.typing import Number, Array
+
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+# >-|===|>                                   Functions                                    <|===|-<
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+def hamilton_product(q1, q2):
+    """the hamilton product between two quaternions"""
+    a1, b1, c1, d1 = q1
+    a2, b2, c2, d2 = q2
+    return array([
+        a1*a2 - b1*b2 - c1*c2 - d1*d2,
+        a1*b2 + b1*a2 + c1*d2 - d1*c2,
+        a1*c2 - b1*d2 + c1*a2 + d1*b2,
+        a1*d2 + b1*c2 - c1*b2 + d1*a2
+    ], dtype=float)
+
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+# >-|===|>                                    Classes                                     <|===|-<
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+class VectorBase:
+    def __init__(self, *components) -> None:
+        match components[0]:
+            case x if type(x) in Number.types:
+                self.components = components
+            case x if type(x) in Array.types:
+                self.components = tuple(array(x) for x in components)
+            case Generator():
+                self.components = tuple(components[0])
+            case x: raise TypeError(f"given components of type: {type(x)}")
+        #i always forget which one i choose :)
+        self.ndims = self.dim = self.dimensions = len(components)
+    def __repr__(self) -> str:
+        return f"Vector{str(self.components)}"
+    def __len__(self) -> int:
+        return len(self.components[0]) if type(self.components[0]) in Array.types else 1
+    def __abs__(self) -> Number:
+        return sqrt(sum(array(self.components)**2, axis=0))
+    def __eq__(self, other) -> bool:
+        match other:
+            case VectorBase():
+                if len(self) > 1 or len(other) > 1:
+                    return all(all(s==o) for s,o in zip(self, other))
+                return all(s==o for s, o in zip(self, other))
+            case x if type(x) in Array.types:
+                return all(all(s==o) for s, o in zip(self, other))
+            case _:
+                return False
+    def __getitem__(self, item):
+        match item:
+            case int():
+                return Vector(c[item] for c in self.components)
+            case (int(), *_):
+                return [Vector(c[i] for c in self.components) for i in item]
+            case slice():
+                start = item.start if item.start else 0
+                stop = item.stop if item.stop else len(self)
+                step = item.step if item.step else 1
+                return [Vector(c[i] for c in self.components) for i in range(start, stop, step)]
+    def __iter__(self) -> Self:
+        self._index = 0
+        return self
+    def __next__(self) -> Number:
+        try:
+            value = self.components[self._index]
+            self._index += 1
+            return value
+        except IndexError as err: raise StopIteration from err
+    def __add__(self, other) -> Self:
+        match other:
+            case VectorBase():
+                return Vector(xs+xo for xs, xo in zip(self.components, other.components))
+            case x if type(x) in Number.types:
+                return Vector(xi+other for xi in self)
+            case x if type(x) in Array.types:
+                return Vector(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)
+            case x if type(x) in Array.types:
+                return type(self)(xs-xo for xs, xo in zip(self.components, other))
+            case VectorBase():
+                return type(self)(xs-xo for xs, xo in zip(self.components, other.components))
+    def __mul__(self, other) -> Self|Number:
+        match other:
+            case VectorBase():
+                return sum(list(c1*c2 for c1,c2 in zip(self, other)), axis=0)
+            case x if type(x) in Number.types:
+                return type(self)(c*other for c in self)
+            case x if type(x) in Array.types:
+                return type(self)(c1*c2 for c1, c2 in zip(self, other))
+    def __truediv__(self, other) -> Self:
+        match other:
+            case VectorBase():
+                return Vector(c1 / c2 for c1, c2 in zip(self, other))
+            case x if type(x) in Number.types:
+                return type(self)(c / other for c in self)
+            case x if type(x) in Array.types:
+                return type(self)(c1 / c2 for c1, c2 in zip(self, other))
+    def __floordiv__(self, other) -> Self:
+        match other:
+            case x if type(x) in Number.types:
+                return type(self)(c//other for c in self)
+            case x if type(x) in Array.types:
+                return type(self)(c1//c2 for c1, c2 in zip(self, other))
+    def __radd__(self, other) -> Self:
+        match other:
+            case 0: return self
+            case _: return self.__add__(other)
+    def __rsub__(self, other) -> Self:
+        match other:
+            case 0: return self
+            case _: return self.__sub__(other)
+    def __rmul__(self, other) -> Self|Number:
+        match other:
+            case 0: return self
+            case _: return self.__mul__(other)
+    def __rtruediv__(self, other) -> Self:
+        match other:
+            case x if type(x) in Number.types:
+                return type(self)(other/c for c in self)
+            case x if type(x) in Array.types:
+                return type(self)(c2/c1 for c1, c2 in zip(self, other))
+    def __rfloordiv__(self, other) -> Self:
+        match other:
+            case x if type(x) in Number.types:
+                return type(self)(other//c for c in self)
+            case x if type(x) in Array.types:
+                return type(self)(c2//c1 for c1, c2 in zip(self, other))
+class Vector(VectorBase):
+    def __new__(cls, *components) -> Self: # the vector factory
+        match components:
+            # vector
+            case (VectorBase(),):
+                return components[0]
+            # generator
+            case (Generator(),):
+                return Vector(tuple(components[0]))
+            # single array
+            case (x,) if type(x) in Array.types:
+                return Vector(*x)
+            # 2D
+            case (x, y):
+                return R2(x, y)
+            # 3D
+            case (x, y, z):
+                return R3(x, y, z)
+            # several numbers
+            case x if all(type(xi) in Number.types for xi in x):
+                return VectorBase(*components)
+            # several arrays
+            case x if all(type(xi) in Array.types for xi in x):
+                return VectorBase(*components)
+            case x:
+                raise TypeError(f"given components:\n{components}\nof type: {type(x)}")
+class Norm(VectorBase):
+    def __init__(self, *components):
+        self.components = components
+        gen = (x/abs(self) for x in self)
+        super().__init__(gen)
+class Quaternion(Norm):
+    def __init__(self, angle, axis):
+        q0 = cos(angle/2)
+        self.axis = Vector(*axis)
+        self.axis *= sin(angle/2)
+        self.axis *= sqrt(1-q0**2)/abs(self.axis)
+        super().__init__(q0, *self.axis.components)
+class R2(VectorBase):
+    def __init__(self, *components):
+        super().__init__(*components)
+        self.x, self.y = self.components
+        self.magnitude = abs(self)
+        # self.direction = Norm(*self.components) if self.magnitude>0 else None
+    def rotate(self, angle) -> Self:
+        """docstring"""
+        r = self.x + 1j*self.y
+        r_rotated = r * exp(1j*angle)
+        self.__init__(r_rotated.real, r_rotated.imag)
+        return self
+class R3(VectorBase):
+    def __init__(self, *components):
+        super().__init__(*components)
+        self.x, self.y, self.z = self.components
+        self.magnitude = abs(self)
+        # self.direction = Norm(*self.components) if self.magnitude>0 else None
+    def from_spherical(radius: Number, azimuth: Number, latitude: Number) -> Self:
+        """docstring"""
+        x = radius * cos(azimuth) * sin(latitude)
+        y = radius * sin(azimuth) * sin(latitude)
+        z = radius * cos(latitude)
+        return R3(x, y, z)
+    def rotate(self, angle, axis):
+        """docstring"""
+        axis = array(axis)
+        qs = array([0, *self.components])
+        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 = R3(*rotated_vector)
+        return self
+    def cross(self, other: Self) -> Self:
+        """Compute self cross other"""
+        x = self.y*other.z - self.z*other.y
+        y = -(self.x*other.z - self.z*other.x)
+        z = self.x*other.y - self.y-other.z
+        return R3(x, y, z)

kbasic-0.1.39/src/kbasic/vectors.py

@@ -1,145 +0,0 @@
-# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
-# >-|===|>                             Imports                             <|===|-<
-# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
-from typing import Self
-from collections.abc import Generator
-from numpy import array, cos, sin, sqrt, exp
-from kbasic.typing import Number, Array
-
-# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
-# >-|===|>                           Definitions                           <|===|-<
-# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
-# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
-# >-|===|>                            Functions                            <|===|-<
-# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
-def hamilton_product(q1, q2):
-    a1, b1, c1, d1 = q1
-    a2, b2, c2, d2 = q2
-    return array([
-        a1*a2 - b1*b2 - c1*c2 - d1*d2,
-        a1*b2 + b1*a2 + c1*d2 - d1*c2,
-        a1*c2 - b1*d2 + c1*a2 + d1*b2,
-        a1*d2 + b1*c2 - c1*b2 + d1*a2
-    ], dtype=float)
-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 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")
-
-# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
-# >-|===|>                             Classes                             <|===|-<
-# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
-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:
-        return str(self.components)
-    def __len__(self) -> int:
-        return self.dimensions
-    def __abs__(self) -> Number:
-        return sqrt(sum(array(self.components)**2))
-    def __iter__(self) -> Self:
-        self._index = 0
-        return self 
-    def __next__(self) -> Number:
-        try:
-            value = self.components[self._index]
-            self._index += 1
-            return value
-        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 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 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:
-            case Vector(): return sum([c1*c2 for c1,c2 in zip(self.components, other.components)])
-            case x if type(x) in Number.types: return type(self)(c*other for c in self.components)            
-    def __truediv__(self, other) -> Self:
-        match other:
-            case x if type(x) in Number.types: return type(self)(c/other for c in self.components)
-    def __floordiv__(self, other) -> Self:
-        match other:
-            case x if type(x) in Number.types: return type(self)(c//other for c in self.components)
-    def __radd__(self, other) -> Self: 
-        match other:
-            case 0: return self
-            case _: return self.__add__(other)
-    def __rsub__(self, other) -> Self: 
-        match other:
-            case 0: return self
-            case _: return self.__sub__(other)
-    def __rmul__(self, other) -> Self|Number: 
-        match other:
-            case 0: return self
-            case _: return self.__mul__(other)
-    def __rtruediv__(self, other) -> Self: 
-        match other:
-            case 0: return self
-            case _: return self.__truediv__(other)
-    def __rfloordiv__(self, other) -> Self: 
-        match other:
-            case 0: return self
-            case _: return self.__floordiv__(other)
-class Norm(Vector):
-    def __init__(self, *components):
-        components: tuple = organize_components(components)
-        Vector.__init__(self, *components)
-        gen = (x/abs(self) for x in self.components)
-        Vector.__init__(self, gen)
-class Quaternion(Norm):
-    def __init__(self, angle, axis):
-        q0 = cos(angle/2)
-        self.axis = sin(angle/2)*Vector(axis)
-        self.axis *= sqrt(1-q0**2)/abs(self.axis)
-        Norm.__init__(self, q0, *self.axis.components)
-class R2(Vector):
-    def __init__(self, *components):
-        self.components: tuple[Number] = organize_components(components)
-        self.x, self.y = self.components
-        Vector.__init__(self, *components)
-        self.magnitude = abs(self)
-        self.direction = Norm(*self.components) if self.magnitude>0 else None 
-    def rotate(self, angle):
-        r = self.x + 1j*self.y 
-        r_rotated = r * exp(1j*angle)    
-        self = R2(r_rotated.real, r_rotated.imag)    
-class R3(Vector):
-    def __init__(self, *components):
-        self.components: tuple[Number] = organize_components(components)
-        self.x, self.y, self.z = self.components
-        Vector.__init__(self, *self.components)
-        self.magnitude = abs(self)
-        self.direction = Norm(*self.components) if self.magnitude>0 else None
-    def from_spherical(radius: Number, azimuth: Number, latitude: Number) -> Self:
-        x = radius * cos(azimuth) * sin(latitude)
-        y = radius * sin(azimuth) * sin(latitude)
-        z = radius * cos(latitude)
-        return R3(x, y, z)
-    def rotate(self, angle, axis):
-        axis = array(axis)
-        qs = array([0, *self.components])
-        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 = R3(*rotated_vector)
-class Matrix:
-    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))]
-                return res