kbasic 0.1.0__tar.gz → 0.1.2__tar.gz

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

@@ -1,7 +1,11 @@
 Metadata-Version: 2.3
 Name: kbasic
-Version: 0.1.0
+Version: 0.1.2
 Summary: Add your description here
+Requires-Dist: numpy>=2.4.2
+Requires-Dist: pylatexenc>=2.10
+Requires-Dist: scipy>=1.17.0
+Requires-Dist: tqdm>=4.67.3
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 

kbasic-0.1.2/pyproject.toml

@@ -0,0 +1,25 @@
+[project]
+name = "kbasic"
+version = "0.1.2"
+description = "Add your description here"
+readme = "README.md"
+requires-python = ">=3.11"
+dependencies = [
+    "numpy>=2.4.2",
+    "pylatexenc>=2.10",
+    "scipy>=1.17.0",
+    "tqdm>=4.67.3",
+]
+
+[build-system]
+requires = ["uv_build>=0.10.2,<0.11.0"]
+build-backend = "uv_build"
+
+[dependency-groups]
+dev = [
+    "pytest>=9.0.2",
+    "pytest-cov>=7.0.0",
+]
+
+[tool.pytest.ini_options]
+addopts = "-v --maxfail=1 --cov=kbasic"

kbasic-0.1.2/src/kbasic/Tex.py

@@ -0,0 +1,23 @@
+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

@@ -0,0 +1,6 @@
+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

@@ -0,0 +1,25 @@
+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/__init__.py

@@ -0,0 +1 @@
+from kbasic.audio.sound import *

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

@@ -0,0 +1,8 @@
+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

@@ -0,0 +1,43 @@
+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/shell.py

@@ -0,0 +1,133 @@
+from subprocess import check_output, DEVNULL
+import numpy as np
+from kbasic.bar import ProgressBar, redirect_to_tqdm
+from kbasic.audio import success
+from pysim.dhybridr.io import dHybridRinput
+from tqdm import tqdm
+from time import sleep
+
+import asyncio
+
+_USERNAME_ = 'x-kgootkin'
+
+bad = ['\x1b[31m', '\x1b[34m', '\x1b[m']
+
+def parse_shell_output(output):
+        match output:
+            case str(): return output 
+            case [x]: return x
+            case [x, *_]: 
+                for i in range(len(output)):
+                    for b in bad:
+                        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
+    print(command)
+    for i in range(len(command)-1):
+        if command[i].startswith('"'): 
+            print(command[i])
+            start_quote = i 
+            end_quote = i+1
+            while not command[end_quote].endswith('"'): end_quote+=1
+            command[i] = " ".join(command[start_quote:end_quote+1])
+            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 
+
+class AnvilJob:
+    def __init__(self, queue_row: str, sep="DISTINCTSEPERATOR"):
+        self.sep = sep
+        [
+            jobid, username, account, name, nodes, cpus, time_limit, status, time
+        ] = queue_row.split()
+        self.jobid = int(jobid)
+        self.username = str(username)
+        self.account = str(account)
+        self.name = str(name)
+        self.nodes = int(nodes)
+        self.cpus = int(cpus)
+        self.time_limit = str(time_limit)
+        self.status = str(status)
+        self.time = str(time)
+
+    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 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
+    @property
+    def jobs(self): return get_anvil_jobs()
+    def monitor(self, sep="DISTINCTSEPERATOR"):
+        with redirect_to_tqdm():
+            js = self.jobs
+            print(js, self.jobs)
+            pbars=[tqdm(position=i, leave=True, desc=js[i].name, postfix=f"{js[i].time}/{js[i].time_limit}") for i in range(len(js))]
+            for i in range(len(js)):
+                j = js[i]
+                j.update()
+                pbars[i].total = j.input.niter
+                pbars[i].n = j.iter
+                pbars[i].refresh()
+            while len(js:=self.jobs) > 0:
+                x = anvil(f";echo {sep};".join([f"ls /anvil/scratch/{self.username}/sims/{js[i].name}/Output/Fields/Magnetic/Total/x/" for i in range(len(js))]))
+                sep_ind = 0
+                for i in range(len(js)):
+                    if i==range(len(js))[-1]: 
+                        sep_ind=0
+                    else: 
+                        while x[sep_ind]!=sep: sep_ind+=1
+                    it = int(x[sep_ind-1][5:-3])
+                    pbars[i].n = it 
+                    pbars[i].postfix = f"{js[i].time}/{js[i].time_limit}"
+                    pbars[i].refresh()
+                    sep_ind+=1
+    def sound_when_running(self, i=0):
+        while len(js:=self.jobs) > 0:
+            j = js[i]
+            if j.status=='R': return success()
+    def sound_when_queue_clear(self):
+        while len(js:=self.jobs)>0: sleep(20)
+        return success()
+    def sound_monitor(self):
+        self.sound_when_running()
+        self.sound_when_queue_clear()

kbasic-0.1.2/src/kbasic/typing.py

@@ -0,0 +1,13 @@
+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

@@ -0,0 +1,23 @@
+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()

kbasic-0.1.2/src/kbasic/vectors.py

@@ -0,0 +1,146 @@
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+# >-|===|>                             Imports                             <|===|-<
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+from numpy import array, ndarray, cos, arccos, sin, arcsin, sqrt, float64, float32, exp, pi, complex128
+from typing import Self
+from collections.abc import Generator
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+# >-|===|>                           Definitions                           <|===|-<
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+class Number:
+    types: list = [float, float64, float32, int, complex, complex128]
+class Iterable:
+    types: list = [list, ndarray, tuple, Generator]
+# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+# >-|===|>                            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 Iterable.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: raise StopIteration
+    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 Iterable.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 Iterable.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.__init__(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.__init__(*rotated_vector)
+
+class Matrix:
+    def __init__(self, array):
+        self.array = array 
+    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))]

kbasic-0.1.0/pyproject.toml

@@ -1,11 +0,0 @@
-[project]
-name = "kbasic"
-version = "0.1.0"
-description = "Add your description here"
-readme = "README.md"
-requires-python = ">=3.11"
-dependencies = []
-
-[build-system]
-requires = ["uv_build>=0.10.2,<0.11.0"]
-build-backend = "uv_build"

kbasic-0.1.0/src/kbasic/__init__.py

@@ -1,2 +0,0 @@
-def hello() -> str:
-    return "Hello from kbasic!"