kbasic 0.1.2__tar.gz → 0.1.4__tar.gz

{kbasic-0.1.2 → kbasic-0.1.4}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.3
 Name: kbasic
-Version: 0.1.2
-Summary: Add your description here
+Version: 0.1.4
+Summary: Keyan's basic utility functions.
 Requires-Dist: numpy>=2.4.2
 Requires-Dist: pylatexenc>=2.10
 Requires-Dist: scipy>=1.17.0
@@ -9,3 +9,8 @@ Requires-Dist: tqdm>=4.67.3
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 
+# KBasic
+The core utility functions that Keyan is sick of rewriting in every project :-) 
+```
+pip install kbasic
+```

kbasic-0.1.4/README.md

@@ -0,0 +1,5 @@
+# KBasic
+The core utility functions that Keyan is sick of rewriting in every project :-) 
+```
+pip install kbasic
+```

{kbasic-0.1.2 → kbasic-0.1.4}/pyproject.toml

@@ -1,7 +1,7 @@
 [project]
 name = "kbasic"
-version = "0.1.2"
-description = "Add your description here"
+version = "0.1.4"
+description = "Keyan's basic utility functions."
 readme = "README.md"
 requires-python = ">=3.11"
 dependencies = [

kbasic-0.1.4/src/kbasic/Tex.py

@@ -0,0 +1,46 @@
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+# >-|===|>                             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!
+warnings.filterwarnings(action='ignore', category=SyntaxWarning)
+from pylatexenc.latex2text import LatexNodes2Text
+
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+# >-|===|>                              Types                              <|===|-<
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+# >-|===|>                           Definitions                           <|===|-<
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+l2t = LatexNodes2Text().latex_to_text
+
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+# >-|===|>                            Functions                            <|===|-<
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+def texfraction(num) -> str: 
+    f = Fraction(str(num))
+    return r"$\frac{" + str(f.numerator) + "}{" + str(f.denominator) + r"}$"
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+# >-|===|>                            Decorators                           <|===|-<
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+# >-|===|>                             Classes                             <|===|-<
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+class Tex(str):
+    def __init__(self, x):
+        x = x.strip(' $')
+        if x[-1]=='\n': x = x[:-1]
+        if x[-2:]=='.0': x = x[:-2]
+        # replace wonky \ letter commands with raw versions
+        # WARNING: DOES NOT WORK WITH \U OR \X BECAUSE THESE ARE UNICODE THINGS AND IDK HOW TO OVERRIDE THAT BEHAVIOR
+        x = x.replace("\a", r"\a").replace("\b", r"\b").replace("\f", r"\f").replace("\n", r"\n").replace("\r", r"\r").replace("\t", r"\t").replace("\v", r"\v")
+        # make compatible with fstring
+        x = x.replace("[", "{").replace("]", "}")
+        # get rid of extraneous .0's 
+        x = x.replace(".0 ", " ").replace(".0}", "}").replace(".0$", "$").replace(".0\n", "\n")
+        self.string = fr"{l2t(x)}"
+        self.wrap = "$"+self.string+"$"
+
+    def __repr__(self): return self.string.strip("$")
+    def __str__(self): return self.string

kbasic-0.1.4/src/kbasic/__init__.py

@@ -0,0 +1,8 @@
+from kbasic.audio import *
+from kbasic.array import *
+from kbasic.bar import *
+from kbasic.shell import *
+from kbasic.user_input import *
+from kbasic.Tex import *
+from kbasic.typing import *
+from kbasic.vectors import *

kbasic-0.1.4/src/kbasic/array.py

@@ -0,0 +1,79 @@
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+# >-|===|>                             Imports                             <|===|-<
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+from typing import Callable
+from numpy import ndarray, argmin, abs, where, nanmean, nanmin, nanmax, linspace, nanstd, array, isnan, arange, mgrid
+from scipy.interpolate import RegularGridInterpolator
+
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+# >-|===|>                              Types                              <|===|-<
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+# >-|===|>                           Definitions                           <|===|-<
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+# >-|===|>                            Functions                            <|===|-<
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+def tile(arr: ndarray) -> ndarray:
+    """take an image and create a 3x3 grid of that image"""
+    return np.r_[np.c_[arr, arr, arr], np.c_[arr, arr, arr], np.c_[arr, arr, arr]]
+def where_closest(arr:ndarray, x): return int(argmin(abs(arr-x)))
+def where_between(arr:ndarray, low, high): return where((arr>=low)&(arr<=high))
+def bin_this(
+        x, y, 
+        n_bins: int = 50, 
+        func: Callable = nanmean
+) -> tuple[ndarray]:
+    """a function to rebin x, y data and calculate errors.
+
+    Args:
+        x: the axis you want to bin
+        y: the data associated with each bin
+        n_bins (int, optional): desired number of bins. Defaults to 50.
+        func (Callable, optional): the function to call on the members of each bin. Defaults to numpy.nanmean.
+
+    Returns:
+        x_binned (ndarray): the bins.
+        y_binned (ndarray): func(members of each bin).
+        bin_errors (ndarray): standard error of the mean for each bin
+    """
+    xbins = linspace(nanmin(x),nanmax(x),n_bins)
+    Y,error = list(),list()
+    for i,low_edge in enumerate(xbins[:-1]):
+        high_edge = xbins[i+1]
+        mask = (low_edge<x)&(x<high_edge)
+        yin = y[mask]
+        Y.append(func(yin))
+        error.append(nanstd(yin)/sqrt(len(yin)))
+    x_binned, y_binned, bin_errors = array(xbins)[:-1],array(Y),array(error)
+    return x_binned, y_binned, bin_errors
+def nan_clip(*args):
+    """
+    take a series of arrays and only return the indicies where ALL members are finite
+    """
+    mask = ~any([isnan(a) for a in args], axis=0)
+    nanless_args = tuple([array(a)[mask] for a in args])
+    return nanless_args
+def interpolate2d(
+        data, factor: int, 
+        method: str = 'linear'
+) -> ndarray:
+    """interpolate 2d data on a regular grid by an even factor
+
+    Args:
+        data (ndarray[ndarray]): 2d data on a regular grid
+        factor (int): how many new grid points per old grid points
+        method (str, optional): the interpolation method. Defaults to 'linear'.
+
+    Returns:
+        ndarray[ndarray]: an interpolated grid of data
+    """
+    Nx, Ny = array(data).shape
+    return RegularGridInterpolator((arange(Nx), arange(Ny)), data, method=method)(mgrid[:Nx-1:1/factor, :Ny-1:1/factor].T).T
+
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+# >-|===|>                            Decorators                           <|===|-<
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+# >-|===|>                             Classes                             <|===|-<
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==

kbasic-0.1.4/src/kbasic/audio/sound.py

@@ -0,0 +1,28 @@
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+# >-|===|>                             Imports                             <|===|-<
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+from os import system
+
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+# >-|===|>                              Types                              <|===|-<
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+# >-|===|>                           Definitions                           <|===|-<
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+audioDir = '/Users/keyan/code/packages/keyutils/audio/lib/'
+rightplace = '"Caroline Rose - year of the slug - 01 everything in its right place.wav"'
+success = 'success.mp3'
+
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+# >-|===|>                            Functions                            <|===|-<
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+def play(file: str):
+    system(f"afplay {audioDir}{file}")
+def success(): system(f"afplay {audioDir}success.mp3")
+
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+# >-|===|>                            Decorators                           <|===|-<
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+# >-|===|>                             Classes                             <|===|-<
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==

kbasic-0.1.4/src/kbasic/bar.py

@@ -0,0 +1,81 @@
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+# >-|===|>                             Imports                             <|===|-<
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+from kbasic.typing import Number
+from contextlib import contextmanager
+import inspect
+from tqdm import tqdm
+
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+# >-|===|>                              Types                              <|===|-<
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+# >-|===|>                           Definitions                           <|===|-<
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+# >-|===|>                            Functions                            <|===|-<
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+def bar(
+        x: Number, total: Number, 
+        width: int = 20, border="|", block="▉"
+) -> str:
+    """create a string representing a progress bar set at 100 * x / total % full.
+
+    Args:
+        x (Number): x out of total
+        total (_type_): x out of total
+        width (int, optional): how many characters wide the bar should be. Defaults to 20.
+        border (str, optional): the character to represent the border of the bar. Defaults to "|".
+        block (str, optional): the character representing a full part of the bar. Defaults to "▉".
+
+    Returns:
+        str: a progress bar
+    """
+    full = int((x/total) * width // 1)
+    empty = width - full
+    bar = border + full*block + empty*" " + border 
+    return bar
+@contextmanager
+def redirect_to_tqdm():
+    """maybe make print statements show up below the bar without fucking everything up?
+    idk tbh im not sure how this works exactly I got it from stack exchange.
+    """
+    # Store builtin print
+    old_print = print
+    def new_print(*args, **kwargs):
+        # If tqdm.tqdm.write raises error, use builtin print
+        try:
+            tqdm.write(*args, **kwargs)
+        except:
+            old_print(*args, ** kwargs)
+
+    try:
+        # Globaly replace print with new_print
+        inspect.builtins.print = new_print
+        yield
+    finally:
+        inspect.builtins.print = old_print
+def progress_bar(iterator, **kwargs):
+    """tqdm with print redirected to tqdm.write
+    """
+    with redirect_to_tqdm():
+        for x in tqdm(iterator, **kwargs):
+            yield x
+def verbose_bar(iterator, verbose, **kwargs):
+    """just a progress bar if verbose is true.
+    """
+    return progress_bar(iterator, **kwargs) if verbose else iterator
+
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+# >-|===|>                            Decorators                           <|===|-<
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+# >-|===|>                             Classes                             <|===|-<
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+class ProgressBar(tqdm):
+    def __init__(self, *args, **kwargs):
+        super().__init__(self, *args, **kwargs)
+        self.iter = self.initial
+    def update(self, iter: int): 
+        super().update(n=iter-self.iter)
+        self.iter = iter

kbasic-0.1.4/src/kbasic/parsing.py

@@ -0,0 +1,159 @@
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+# >-|===|>                             Imports                             <|===|-<
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+#pysim imports
+from kbasic.user_input import yesno
+#nonpysim imports
+import numpy as np
+from glob import glob 
+from shutil import copy, move, copytree, rmtree
+from os.path import isdir, isfile, exists, abspath
+from os import mkdir, remove
+from functools import cached_property
+
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+# >-|===|>                           Definitions                           <|===|-<
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+unreadable_file_types = ['gz', 'tar', 'zip']
+
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+# >-|===|>                            Functions                            <|===|-<
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+def ensure_path(path: str) -> None:
+    """make sure that a path exists
+
+    Args:
+        path (str): the path you want to exist
+    """
+    parts = path.strip().split('/')
+    for i in range(len(parts)):
+        if "/".join(parts[:i]) in "/home/x-kgootkin/": continue
+        if not exists("/".join(parts[:i])):
+            mkdir("/".join(parts[:i]))
+
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+# >-|===|>                             Classes                             <|===|-<
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+class File:
+    def __init__(self, path:str, master=None, executable:bool=False, 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.
+            executable (bool, optional): is this file an executable. Defaults to False.
+            verbose (bool, optional): should this file be annoying. Defaults to False.
+        """
+        self.path: str = abspath(path.replace("\\", "/").replace('//', '/'))
+        pathlist: list[str] = self.path.split("/")
+        self.parent = Folder("/".join(pathlist[:-1]))
+        self.grandparent = Folder("/".join(pathlist[:-2])) if len(pathlist)>3 else None
+        self.greatgrandparent = Folder("/".join(pathlist[:-3])) if len(pathlist)>4 else None
+        self.name = self.path.split("/")[-1]
+        self.extension = self.name.split(".")[-1] if "." in self.name else None
+        self.master = master if not isinstance(master, str) else File(master)
+        self.executable = executable
+        self.verbose = verbose
+    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, executable=self.executable)
+    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 Folder:
+    def __init__(self, path:str, master=None) -> None:
+        self.path = '/' if path=='' else abspath(path.replace("\\", "/").replace('//', '/'))
+        self.name = self.path.split("/")[-1] if len(self.path.split('/')[-1])>0 else self.path.split("/")[-2]
+        self.master = master if not isinstance(master, str) else Folder(master)
+    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 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, "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)
+
+def parse(path: str | list[str]) -> 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: path as a Folder/File.
+    """
+    match path:
+        case str():
+            if isdir(path): return Folder(path)
+            if isfile(path): return File(path)
+        case list()|np.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}")

{kbasic-0.1.2 → kbasic-0.1.4}/src/kbasic/shell.py

@@ -1,17 +1,27 @@
-from subprocess import check_output, DEVNULL
-import numpy as np
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+# >-|===|>                             Imports                             <|===|-<
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
 from kbasic.bar import ProgressBar, redirect_to_tqdm
 from kbasic.audio import success
-from pysim.dhybridr.io import dHybridRinput
+# from kgsim.dhybridr.io import dHybridRinput
+from subprocess import check_output, DEVNULL
 from tqdm import tqdm
 from time import sleep
-
 import asyncio
+import numpy as np
 
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+# >-|===|>                              Types                              <|===|-<
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+# >-|===|>                           Definitions                           <|===|-<
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
 _USERNAME_ = 'x-kgootkin'
-
 bad = ['\x1b[31m', '\x1b[34m', '\x1b[m']
 
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+# >-|===|>                            Functions                            <|===|-<
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
 def parse_shell_output(output):
         match output:
             case str(): return output 
@@ -22,7 +32,6 @@ def parse_shell_output(output):
                         if b in output[i]:
                             output[i] = output[i].strip(b)
                 return output
-
 def system(cmd: str):
     print(cmd)
     command = cmd.split(' ') if type(cmd)==str else cmd
@@ -37,17 +46,19 @@ def system(cmd: str):
             for j in range(start_quote+1, end_quote+1): del command[j]
     output = parse_shell_output(check_output(command, stderr=DEVNULL).decode().splitlines())
     return output
-
 def anvil(cmd: str):
     output = parse_shell_output(check_output(['ssh', 'x-kgootkin@anvil.rcac.purdue.edu', *cmd.split(' ')], stderr=DEVNULL).decode().splitlines())
     return output
-
 async def anvil_async(cmd: str): asyncio.to_thread(anvil, cmd)
-
-
 def anvil_queue(username=_USERNAME_): return anvil(f"squeue -u {username}")
-qs = anvil_queue 
-
+qs = anvil_queue
+
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+# >-|===|>                            Decorators                           <|===|-<
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+# >-|===|>                             Classes                             <|===|-<
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!== 
 class AnvilJob:
     def __init__(self, queue_row: str, sep="DISTINCTSEPERATOR"):
         self.sep = sep
@@ -66,32 +77,28 @@ class AnvilJob:
 
     def __repr__(self): return "-"*30 + f"\n{self.name}: {self.status}\n\t{self.time}/{self.time_limit}"
 
-    def update(self, input=True, iter=True):
-        match input, iter:
-            case True, True:
-                x = anvil(f"cat /anvil/scratch/{self.username}/sims/{self.name}/input/input; echo {self.sep}; ls /anvil/scratch/{self.username}/sims/{self.name}/Output/Fields/Magnetic/Total/x/")
-                input_lines = "\n".join(x).split(self.sep)[0].split('\n')
-                self.input = dHybridRinput(input_lines)
-                self.iter = int(x[-1][5:-3])
-            case True, False:
-                self.input = dHybridRinput(anvil(f"cat /anvil/scratch/{self.username}/sims/{self.name}/input/input"))
-            case False, True:
-                self.iter = int(anvil(f"ls /anvil/scratch/{self.username}/sims/{self.name}/Output/Fields/Magnetic/Total/x/")[-1][5:-3])
-
+    # def update(self, input=True, iter=True):
+    #     match input, iter:
+    #         case True, True:
+    #             x = anvil(f"cat /anvil/scratch/{self.username}/sims/{self.name}/input/input; echo {self.sep}; ls /anvil/scratch/{self.username}/sims/{self.name}/Output/Fields/Magnetic/Total/x/")
+    #             input_lines = "\n".join(x).split(self.sep)[0].split('\n')
+    #             self.input = dHybridRinput(input_lines)
+    #             self.iter = int(x[-1][5:-3])
+    #         case True, False:
+    #             self.input = dHybridRinput(anvil(f"cat /anvil/scratch/{self.username}/sims/{self.name}/input/input"))
+    #         case False, True:
+    #             self.iter = int(anvil(f"ls /anvil/scratch/{self.username}/sims/{self.name}/Output/Fields/Magnetic/Total/x/")[-1][5:-3])
 def get_anvil_jobs(username=_USERNAME_):
     q = anvil(f"squeue -u {username}")
     if type(q)==str: return []
     return [AnvilJob(x) for x in q[1:]]
-
 async def get_anvil_jobs_async(username=_USERNAME_):
     q = await asyncio.to_thread(anvil, f"squeue -u {username}")
     if type(q)==str: return []
     return [AnvilJob(x) for x in q[1:]]
-
 async def get_anvil_sim_iter(name: str):
     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_):
         self.username = username

kbasic-0.1.4/src/kbasic/typing.py

@@ -0,0 +1,38 @@
+"""
+    I don't like type checking in python, so the way i decided to do it is if i want
+    to see if something looks like a number (int, float, complex or numpy variants)
+    i would say ->
+    if type(x) in Number.types: do_something()
+    elif type(x) in Iterable.types: do_something_else()
+"""
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+# >-|===|>                             Imports                             <|===|-<
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+from numpy import ndarray, int8, uint8, int16, uint16, int32, uint32, int64, uint64, float16, float32, float64, longdouble, complex64, complex128, clongdouble
+
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+# >-|===|>                              Types                              <|===|-<
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+class Number:
+    types: list = [
+        int, int8, uint8, int16, uint16, int32, uint32, int64, uint64, 
+        float, float16, float32, float64, longdouble, 
+        complex, complex64, complex128, clongdouble
+    ]
+class Iterable:
+    types: list = [
+        list, set, dict, tuple, ndarray
+    ]
+
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+# >-|===|>                           Definitions                           <|===|-<
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+# >-|===|>                            Functions                            <|===|-<
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+# >-|===|>                            Decorators                           <|===|-<
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+# >-|===|>                             Classes                             <|===|-<
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==

kbasic-0.1.4/src/kbasic/user_input.py

@@ -0,0 +1,42 @@
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+# >-|===|>                             Imports                             <|===|-<
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+# >-|===|>                              Types                              <|===|-<
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+# >-|===|>                           Definitions                           <|===|-<
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+# >-|===|>                            Functions                            <|===|-<
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+def yesno(prompt: str):
+    """
+    prompt the user to either reply yes or no
+    :param prompt: the yes/no question to be answered
+    :return: True if yes False if no
+    """
+    response = input(prompt).lower()
+    if 'y' in response and not 'n' in response:
+        return True
+    elif 'n' in response and not 'y' in response:
+        return False
+    else:
+        def retry_yesno():
+            retry_prompt = "Sorry I couldn't read that please respond with yes or no\n" + prompt
+            retry_response = input(retry_prompt).lower()
+            if 'y' in retry_response and not 'n' in retry_response:
+                return True
+            elif 'n' in retry_response and not 'y' in retry_response:
+                return False
+            else:
+                raise ValueError("need a response with either y or n in it.")
+
+        return retry_yesno()
+
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+# >-|===|>                            Decorators                           <|===|-<
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+# >-|===|>                             Classes                             <|===|-<
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==

{kbasic-0.1.2 → kbasic-0.1.4}/src/kbasic/vectors.py

@@ -1,16 +1,14 @@
 # !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
 # >-|===|>                             Imports                             <|===|-<
 # !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
-from numpy import array, ndarray, cos, arccos, sin, arcsin, sqrt, float64, float32, exp, pi, complex128
+from numpy import array, cos, sin, sqrt, exp
 from typing import Self
 from collections.abc import Generator
+from kbasic.typing import Number, Iterable
+
 # !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
 # >-|===|>                           Definitions                           <|===|-<
 # !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
-class Number:
-    types: list = [float, float64, float32, int, complex, complex128]
-class Iterable:
-    types: list = [list, ndarray, tuple, Generator]
 # !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
 # >-|===|>                            Functions                            <|===|-<
 # !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
@@ -30,6 +28,7 @@ def organize_components(components) -> tuple[float|int]:
         case (Generator(),): return tuple(components[0])
         case (Vector(),): return components[0].components
         case _: raise TypeError(f"{components} cannot be matched")
+
 # !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
 # >-|===|>                             Classes                             <|===|-<
 # !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
@@ -92,7 +91,6 @@ class Vector:
         match other:
             case 0: return self
             case _: return self.__floordiv__(other)
-
 class Norm(Vector):
     def __init__(self, *components):
         components: tuple = organize_components(components)
@@ -105,7 +103,6 @@ class Quaternion(Norm):
         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)
@@ -136,7 +133,6 @@ class R3(Vector):
         rotation_inverse = array([rotation[0], *-rotation[1:]])
         rotated_vector = hamilton_product(hamilton_product(rotation, qs), rotation_inverse)[1:]
         self.__init__(*rotated_vector)
-
 class Matrix:
     def __init__(self, array):
         self.array = array 

kbasic-0.1.2/src/kbasic/Tex.py

@@ -1,23 +0,0 @@
-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
-l2t = LatexNodes2Text().latex_to_text
-
-class Tex(str):
-    def __init__(self, x):
-        x = x.strip(' $')
-        if x[-1]=='\n': x = x[:-1]
-        if x[-2:]=='.0': x = x[:-2]
-        # replace wonky \ letter commands with raw versions
-        # WARNING: DOES NOT WORK WITH \U OR \X BECAUSE THESE ARE UNICODE THINGS AND IDK HOW TO OVERRIDE THAT BEHAVIOR
-        x = x.replace("\a", r"\a").replace("\b", r"\b").replace("\f", r"\f").replace("\n", r"\n").replace("\r", r"\r").replace("\t", r"\t").replace("\v", r"\v")
-        # make compatible with fstring
-        x = x.replace("[", "{").replace("]", "}")
-        # get rid of extraneous .0's 
-        x = x.replace(".0 ", " ").replace(".0}", "}").replace(".0$", "$").replace(".0\n", "\n")
-        self.string = fr"{l2t(x)}"
-        self.wrap = "$"+self.string+"$"
-
-    def __repr__(self): return self.string.strip("$")
-    def __str__(self): return self.string

kbasic-0.1.2/src/kbasic/__init__.py

@@ -1,6 +0,0 @@
-from kbasic.Tex import Tex
-from kbasic.array import bin_this, nan_clip, where_between, where_closest
-from kbasic.bar import progress_bar, verbose_bar
-from kbasic.user_input import yesno
-from kbasic.vectors import *
-from kbasic.audio import *

kbasic-0.1.2/src/kbasic/array.py

@@ -1,25 +0,0 @@
-import numpy as np
-from scipy.interpolate import RegularGridInterpolator
-
-def where_closest(arr:np.ndarray, x): return np.argmin(np.abs(arr-x))
-def where_between(arr:np.ndarray, low, high): return np.where((arr>=low)&(arr<=high))
-
-def bin_this(x, y, n_bins=50, func=np.nanmean):
-    xbins = np.linspace(np.nanmin(x),np.nanmax(x),n_bins)
-    Y,error = list(),list()
-    for i,low_edge in enumerate(xbins[:-1]):
-        high_edge = xbins[i+1]
-        mask = (low_edge<x)&(x<high_edge)
-        yin = y[mask]
-        Y.append(func(yin))
-        error.append(np.nanstd(yin)/np.sqrt(len(yin)))
-    return np.array(xbins)[:-1],np.array(Y),np.array(error)
-
-def nan_clip(*args):
-    mask = ~np.any([np.isnan(a) for a in args], axis=0)
-    nanless_args = tuple([np.array(a)[mask] for a in args])
-    return nanless_args
-
-def interpolate2d(data, factor, method='cubic'):
-    Nx, Ny = np.array(data).shape
-    return RegularGridInterpolator((np.arange(Nx), np.arange(Ny)), data, method=method)(np.mgrid[:Nx-1:1/factor, :Ny-1:1/factor].T).T

kbasic-0.1.2/src/kbasic/audio/sound.py

@@ -1,8 +0,0 @@
-from os import system
-audioDir = '/Users/keyan/code/packages/keyutils/audio/lib/'
-rightplace = '"Caroline Rose - year of the slug - 01 everything in its right place.wav"'
-success = 'success.mp3'
-
-def play(file: str):
-    system(f"afplay {audioDir}{file}")
-def success(): system(f"afplay {audioDir}success.mp3")

kbasic-0.1.2/src/kbasic/bar.py

@@ -1,43 +0,0 @@
-from contextlib import contextmanager
-import inspect
-from tqdm import tqdm
-
-def bar(x, total, width: int = 20, border="|", block="▉"):
-    full = int((x/total) * width // 1)
-    empty = width - full
-    bar = border + full*block + empty*" " + border 
-    return bar
-
-@contextmanager
-def redirect_to_tqdm():
-    # Store builtin print
-    old_print = print
-    def new_print(*args, **kwargs):
-        # If tqdm.tqdm.write raises error, use builtin print
-        try:
-            tqdm.write(*args, **kwargs)
-        except:
-            old_print(*args, ** kwargs)
-
-    try:
-        # Globaly replace print with new_print
-        inspect.builtins.print = new_print
-        yield
-    finally:
-        inspect.builtins.print = old_print
-
-def progress_bar(iterator, **kwargs):
-    with redirect_to_tqdm():
-        for x in tqdm(iterator, **kwargs):
-            yield x
-
-def verbose_bar(iterator, verbose, **kwargs):
-    return progress_bar(iterator, **kwargs) if verbose else iterator
-
-class ProgressBar(tqdm):
-    def __init__(self, *args, **kwargs):
-        super().__init__(self, *args, **kwargs)
-        self.iter = self.initial
-    def update(self, iter: int): 
-        super().update(n=iter-self.iter)
-        self.iter = iter

kbasic-0.1.2/src/kbasic/typing.py

@@ -1,13 +0,0 @@
-from numpy import ndarray, int8, uint8, int16, uint16, int32, uint32, int64, uint64, float16, float32, float64, longdouble, complex64, complex128, clongdouble
-
-class Number:
-    types: list = [
-        int, int8, uint8, int16, uint16, int32, uint32, int64, uint64, 
-        float, float16, float32, float64, longdouble, 
-        complex, complex64, complex128, clongdouble
-    ]
-
-class Iterable:
-    types: list = [
-        list, set, dict, tuple, ndarray
-    ]

kbasic-0.1.2/src/kbasic/user_input.py

@@ -1,23 +0,0 @@
-def yesno(prompt: str):
-    """
-    prompt the user to either reply yes or no
-    :param prompt: the yes/no question to be answered
-    :return: True if yes False if no
-    """
-    response = input(prompt).lower()
-    if 'y' in response and not 'n' in response:
-        return True
-    elif 'n' in response and not 'y' in response:
-        return False
-    else:
-        def retry_yesno():
-            retry_prompt = "Sorry I couldn't read that please respond with yes or no\n" + prompt
-            retry_response = input(retry_prompt).lower()
-            if 'y' in retry_response and not 'n' in retry_response:
-                return True
-            elif 'n' in retry_response and not 'y' in retry_response:
-                return False
-            else:
-                raise ValueError("need a response with either y or n in it.")
-
-        return retry_yesno()