jetpytools 1.2.3__py3-none-any.whl

jetpytools/utils/file.py

@@ -0,0 +1,256 @@
+from __future__ import annotations
+
+import ctypes
+import sys
+from io import BufferedRandom, BufferedReader, BufferedWriter, FileIO, TextIOWrapper
+from os import F_OK, R_OK, W_OK, X_OK, access, getenv, path
+from pathlib import Path
+from typing import IO, Any, BinaryIO, Callable, Literal, overload
+
+from ..exceptions import FileIsADirectoryError, FileNotExistsError, FilePermissionError, FileWasNotFoundError
+from ..types import (
+    FileOpener, FilePathType, FuncExceptT, OpenBinaryMode, OpenBinaryModeReading, OpenBinaryModeUpdating,
+    OpenBinaryModeWriting, OpenTextMode, SPath
+)
+
+__all__ = [
+    'add_script_path_hook',
+    'remove_script_path_hook',
+
+    'get_script_path',
+
+    'get_user_data_dir',
+
+    'check_perms',
+    'open_file'
+]
+
+_script_path_hooks = list[Callable[[], SPath | None]]()
+
+
+def add_script_path_hook(hook: Callable[[], SPath | None]) -> None:
+    _script_path_hooks.append(hook)
+
+
+def remove_script_path_hook(hook: Callable[[], SPath | None]) -> None:
+    _script_path_hooks.remove(hook)
+
+
+def get_script_path() -> SPath:
+    for hook in reversed(_script_path_hooks):
+        if (script_path := hook()) is not None:
+            return script_path
+
+    import __main__
+
+    try:
+        return SPath(__main__.__file__)
+    except AttributeError:
+        return SPath.cwd()
+
+
+def get_user_data_dir() -> Path:
+    """Get user data dir path."""
+
+    if sys.platform == 'win32':
+        buf = ctypes.create_unicode_buffer(1024)
+        ctypes.windll.shell32.SHGetFolderPathW(None, 28, None, 0, buf)
+
+        if any([ord(c) > 255 for c in buf]):
+            buf2 = ctypes.create_unicode_buffer(1024)
+            if ctypes.windll.kernel32.GetShortPathNameW(buf.value, buf2, 1024):
+                buf = buf2
+
+        return Path(path.normpath(buf.value))
+
+    if sys.platform == 'darwin':  # type: ignore[unreachable]
+        return Path(path.expanduser('~/Library/Application Support/'))
+
+    return Path(getenv('XDG_DATA_HOME', path.expanduser("~/.local/share")))
+
+
+def check_perms(
+    file: FilePathType, mode: OpenTextMode | OpenBinaryMode, strict: bool = False,
+    *, func: FuncExceptT | None = None
+) -> bool:
+    """
+    Confirm whether the user has write/read access to a file.
+
+    :param file:                    Path to file.
+    :param mode:                    Read/Write mode.
+    :param func:                    Function that this was called from, only useful to *func writers.
+
+    :param:                         True if the user has write/read access, else False.
+
+    :raises FileNotExistsError:     File could not be found.
+    :raises FilePermissionError:    User does not have access to the file.
+    :raises FileIsADirectoryError:  Given path is a directory, not a file.
+    :raises FileWasNotFoundError:   Parent directories exist, but the given file could not be found.
+    """
+
+    file = Path(str(file))
+    got_perms = False
+
+    mode_i = F_OK
+
+    if func is not None:
+        if not str(file):
+            raise FileNotExistsError(file, func)
+
+    for char in 'rbU':
+        mode_str = mode.replace(char, '')
+
+    if not mode_str:
+        mode_i = R_OK
+    elif 'x' in mode_str:
+        mode_i = X_OK
+    elif '+' in mode_str or 'w' in mode_str:
+        mode_i = W_OK
+
+    check_file = file
+
+    if not strict and mode_i != R_OK:
+        while not check_file.exists():
+            check_file = check_file.parent
+
+    if strict and file.is_dir():
+        raise FileIsADirectoryError(file, func)
+
+    got_perms = access(check_file, mode_i)
+
+    if func is not None:
+        if not got_perms:
+            if strict and not file.exists():
+                if file.parent.exists():
+                    raise FileWasNotFoundError(file, func)
+
+                raise FileNotExistsError(file, func)
+
+            raise FilePermissionError(file, func)
+
+    return got_perms
+
+
+@overload
+def open_file(
+    file: FilePathType, mode: OpenTextMode = 'r', buffering: int = ...,
+    encoding: str | None = None, errors: str | None = ..., newline: str | None = ...,
+    *, func: FuncExceptT | None = None
+) -> TextIOWrapper:
+    ...
+
+
+@overload
+def open_file(
+    file: FilePathType, mode: OpenBinaryMode, buffering: Literal[0],
+    encoding: None = None, *, func: FuncExceptT | None = None
+) -> FileIO:
+    ...
+
+
+@overload
+def open_file(
+    file: FilePathType, mode: OpenBinaryModeUpdating, buffering: Literal[-1, 1] = ...,
+    encoding: None = None, *, func: FuncExceptT | None = None
+) -> BufferedRandom:
+    ...
+
+
+@overload
+def open_file(
+    file: FilePathType, mode: OpenBinaryModeWriting, buffering: Literal[-1, 1] = ...,
+    encoding: None = None, *, func: FuncExceptT | None = None
+) -> BufferedWriter:
+    ...
+
+
+@overload
+def open_file(
+    file: FilePathType, mode: OpenBinaryModeReading, buffering: Literal[-1, 1] = ...,
+    encoding: None = None, *, func: FuncExceptT | None = None
+) -> BufferedReader:
+    ...
+
+
+@overload
+def open_file(
+    file: FilePathType, mode: OpenBinaryMode, buffering: int = ...,
+    encoding: None = None, *, func: FuncExceptT | None = None
+) -> BinaryIO:
+    ...
+
+
+@overload
+def open_file(
+    file: FilePathType, mode: str, buffering: int = ...,
+    encoding: str | None = ..., errors: str | None = ..., newline: str | None = ...,
+    closefd: bool = ..., opener: FileOpener | None = ..., *, func: FuncExceptT | None = None
+) -> IO[Any]:
+    ...
+
+
+def open_file(file: FilePathType, mode: Any = 'r+', *args: Any, func: FuncExceptT | None = None, **kwargs: Any) -> Any:
+    """
+    Open file and return a stream. Raise OSError upon failure.
+
+    :param file:        Is either a text or byte string giving the name of the file to be opened.
+                        It is also possible to use a string or bytearray as a file for both reading and writing.
+                        For strings, StringIO can be used like a file opened in a text mode.
+                        For bytes a BytesIO can be used like a file opened in a binary mode.
+    :param mode:        This is an optional string that specifies the mode in which the file is opened.
+                        It defaults to 'r' which means open for reading in text mode.
+                        Other common values are:
+                            'w' for writing, and truncating the file if it already exists
+                            'x' for creating and writing to a new file
+                            'a' for appending, which on some Unix systems means that all writes append to the end
+                            of the file regardless of the current seek position).
+                        In text mode, if encoding is not specified the encoding used is platform dependent:
+                            locale.getpreferredencoding(False) is called to get the current locale encoding.
+                        For reading and writing raw bytes use binary mode and leave encoding unspecified.
+    :param buffering:   This is an optional integer used to set the buffering policy.
+                        Pass:
+                            0 to switch buffering off (only allowed in binary mode)
+                            1 to select line buffering (only usable in text mode)
+                            Integer > 1 to indicate the size of a fixed-size chunk buffer.
+                        When no buffering argument is given, the default buffering policy works as follows:
+                            Binary files are buffered in fixed-size chunks;
+                            the size of the buffer is chosen using a heuristic trying to determine the
+                            underlying device's "block size" and falling back on io.DEFAULT_BUFFER_SIZE.
+                            On many systems, the buffer will typically be 4096 or 8192 bytes long.
+                        "Interactive" text files (files for which isatty() returns True) use line buffering.
+                        Other text files use the policy described above for binary files.
+    :param: encoding:   This is the name of the encoding used to decode or encode the file.
+                        This should only be used in text mode
+                        The default encoding is platform dependent, but any encoding supported by Python can be passed.
+                        See the codecs module for the list of supported encodings.
+    :param newline:     This parameter controls how universal newlines works (it only applies to text mode).
+                        It can be None, '', '\n', '\r', and '\r\n'.
+                        It works as follows:
+                            On input,
+                                if newline is None, universal newlines mode is enabled.
+                                Lines in the input can end in '\n', '\r', or '\r\n',
+                                and these are translated into '\n' before being returned to the caller.
+                                If it is '', universal newline mode is enabled, but line endings are
+                                returned to the caller untranslated.
+                                If it has any of the other legal values, input lines are only terminated
+                                by the given string, and the line ending is returned to the caller untranslated.
+                            On output,
+                                if newline is None, any '\n' characters written are translated to the system default
+                                line separator, os.linesep. If newline is '' or '\n', no translation takes place.
+                                If newline is any of the other legal values, any '\n' characters written are
+                                translated to the given string.
+
+    :return:            A file object whose type depends on the mode, and through which the standard file operations
+                        such as reading and writing are performed.
+                        When open_file is used to open a file in a text mode ('w', 'r', 'wt', 'rt', etc.),
+                            it returns a TextIOWrapper.
+                        When used to open a file in a binary mode, the returned class varies:
+                            in read binary mode, it returns a BufferedReader
+                            in write binary and append binary modes, it returns a BufferedWriter
+                            in read/write mode, it returns a BufferedRandom
+
+    """
+
+    check_perms(file, mode, func=func)
+
+    return open(file, mode, *args, errors='strict', closefd=True, **kwargs)  # type: ignore

jetpytools/utils/funcs.py

@@ -0,0 +1,35 @@
+from __future__ import annotations
+
+from functools import update_wrapper
+from types import FunctionType
+from typing import Sequence
+
+from ..types import F
+
+__all__ = [
+    'copy_func',
+    'erase_module'
+]
+
+
+def copy_func(f: F) -> FunctionType:
+    """Try copying a function."""
+
+    try:
+        g = FunctionType(
+            f.__code__, f.__globals__, name=f.__name__, argdefs=f.__defaults__, closure=f.__closure__
+        )
+        g = update_wrapper(g, f)  # type: ignore
+        g.__kwdefaults__ = f.__kwdefaults__
+        return g
+    except BaseException:  # for builtins
+        return f  # type: ignore
+
+
+def erase_module(func: F, modules: Sequence[str] | None = None) -> F:
+    """Delete the __module__ of the function."""
+
+    if hasattr(func, '__module__') and (True if modules is None else (func.__module__ in modules)):
+        func.__module__ = None  # type: ignore
+
+    return func

jetpytools/utils/math.py

@@ -0,0 +1,158 @@
+from __future__ import annotations
+
+from math import ceil, log, log10
+from typing import Sequence
+
+from ..types import Nb
+
+__all__ = [
+    'clamp', 'clamp_arr',
+
+    'cround',
+
+    'mod_x', 'mod2', 'mod4', 'mod8',
+
+    'next_power_of_y', 'next_power_of_2',
+
+    'spline_coeff',
+
+    'ndigits'
+]
+
+
+def clamp(val: Nb, min_val: Nb, max_val: Nb) -> Nb:
+    """Faster max(min(value, max_val), min_val) "wrapper" """
+
+    return min_val if val < min_val else max_val if val > max_val else val
+
+
+def clamp_arr(vals: Sequence[Nb], min_val: Nb, max_val: Nb) -> list[Nb]:
+    """Map an array to clamp."""
+
+    return [clamp(x, min_val, max_val) for x in vals]
+
+
+def cround(x: float, *, eps: float = 1e-6) -> int:
+    """Rounding function that accounts for float's imprecision."""
+
+    return round(x + (eps if x > 0. else - eps))
+
+
+def mod_x(val: int | float, x: int) -> int:
+    """Force a value to be divisible by x (val % x == 0)."""
+
+    if x == 0:
+        return cround(val)
+
+    return cround(val / x) * x
+
+
+def mod2(val: int | float) -> int:
+    """Force a value to be mod 2"""
+
+    return mod_x(val, x=2)
+
+
+def mod4(val: int | float) -> int:
+    """Force a value to be mod 4"""
+
+    return mod_x(val, x=4)
+
+
+def mod8(val: int | float) -> int:
+    """Force a value to be mod 8"""
+
+    return mod_x(val, x=8)
+
+
+def next_power_of_2(x: float) -> int:
+    """Get the next power of 2 of x."""
+
+    x = cround(x)
+
+    if x == 0:
+        return 1
+
+    if x & (x - 1) == 0:
+        return x
+
+    while x & (x - 1) > 0:
+        x &= (x - 1)
+
+    return x << 1
+
+
+def next_power_of_y(x: float, y: int) -> int:
+    """Get the next power of y of x."""
+
+    if x == 0:
+        return 1
+
+    return int(y ** ceil(log(x, y)))
+
+
+def spline_coeff(
+    x: int, coordinates: list[tuple[float, float]] = [
+        (0, 0), (0.5, 0.1), (1, 0.6), (2, 0.9), (2.5, 1), (3, 1.1), (3.5, 1.15), (4, 1.2), (8, 1.25), (255, 1.5)
+    ]
+) -> float:
+    """Get spline coefficient of an index and coordinates."""
+
+    length = len(coordinates)
+
+    if length < 3:
+        raise ValueError("coordinates require at least three pairs")
+
+    px, py = zip(*coordinates)
+
+    matrix = [[1.0] + [0.0] * length]
+
+    for i in range(1, length - 1):
+        p = [0.0] * (length + 1)
+
+        p[i - 1] = px[i] - px[i - 1]
+        p[i] = 2 * (px[i + 1] - px[i - 1])
+        p[i + 1] = px[i + 1] - px[i]
+        p[length] = 6 * (((py[i + 1] - py[i]) / p[i + 1]) - (py[i] - py[i - 1]) / p[i - 1])
+
+        matrix.append(p)
+
+    matrix += [([0.0] * (length - 1) + [1.0, 0.0])]
+
+    for i in range(length):
+        num = matrix[i][i]
+
+        for j in range(length + 1):
+            matrix[i][j] /= num
+
+        for j in range(length):
+            if i != j:
+                a = matrix[j][i]
+
+                for k in range(i, length + 1):
+                    matrix[j][k] -= a * matrix[i][k]
+
+    for i in range(length + 1):
+        if x >= px[i] and x <= px[i + 1]:
+            break
+
+    j = i + 1
+
+    h = px[j] - px[i]
+
+    s = matrix[j][length] * float((x - px[i]) ** 3)
+    s -= matrix[i][length] * float((x - px[j]) ** 3)
+
+    s /= 6 * h
+
+    s += (py[j] / h - h * matrix[j][length] / 6) * (x - px[i])
+    s -= (py[i] / h - h * matrix[i][length] / 6) * (x - px[j])
+
+    return s
+
+
+def ndigits(num: Nb) -> int:
+    if num == 0:
+        return 1
+
+    return int(log10(abs(num))) + 1

jetpytools/utils/ranges.py

@@ -0,0 +1,89 @@
+from __future__ import annotations
+
+from itertools import chain, zip_longest
+from typing import Iterable, overload
+
+from ..exceptions import CustomIndexError
+from ..types import T0, T
+
+__all__ = [
+    'ranges_product',
+
+    'interleave_arr'
+]
+
+
+@overload
+def ranges_product(range0: range | int, range1: range | int, /) -> Iterable[tuple[int, int]]:
+    ...
+
+
+@overload
+def ranges_product(range0: range | int, range1: range | int, range2: range | int, /) -> Iterable[tuple[int, int, int]]:
+    ...
+
+
+def ranges_product(*_iterables: range | int) -> Iterable[tuple[int, ...]]:
+    """
+    Take two or three lengths/ranges and make a cartesian product of them.
+
+    Useful for getting all coordinates of an image.
+    For example ranges_product(1920, 1080) will give you [(0, 0), (0, 1), (0, 2), ..., (1919, 1078), (1919, 1079)].
+    """
+
+    n_iterables = len(_iterables)
+
+    if n_iterables <= 1:
+        raise CustomIndexError(f'Not enough ranges passed! ({n_iterables})', ranges_product)
+
+    iterables = [range(x) if isinstance(x, int) else x for x in _iterables]
+
+    if n_iterables == 2:
+        first_it, second_it = iterables
+
+        for xx in first_it:
+            for yy in second_it:
+                yield xx, yy
+    elif n_iterables == 3:
+        first_it, second_it, third_it = iterables
+
+        for xx in first_it:
+            for yy in second_it:
+                for zz in third_it:
+                    yield xx, yy, zz
+    else:
+        raise CustomIndexError(f'Too many ranges passed! ({n_iterables})', ranges_product)
+
+
+def interleave_arr(arr0: Iterable[T], arr1: Iterable[T0], n: int = 2) -> Iterable[T | T0]:
+    """
+    Interleave two arrays of variable length.
+
+    :param arr0:    First array to be interleaved.
+    :param arr1:    Second array to be interleaved.
+    :param n:       The number of elements from arr0 to include in the interleaved sequence
+                    before including an element from arr1.
+
+    :yield:         Elements from either arr0 or arr01.
+    """
+    if n == 1:
+        yield from (x for x in chain.from_iterable(zip_longest(arr0, arr1)) if x is not None)
+
+        return
+
+    arr0_i, arr1_i = iter(arr0), iter(arr1)
+    arr1_vals = arr0_vals = True
+
+    while arr1_vals or arr0_vals:
+        if arr0_vals:
+            for _ in range(n):
+                try:
+                    yield next(arr0_i)
+                except StopIteration:
+                    arr0_vals = False
+
+        if arr1_vals:
+            try:
+                yield next(arr1_i)
+            except StopIteration:
+                arr1_vals = False

jetpytools-1.2.3.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 LightArrowsEXE
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

jetpytools-1.2.3.dist-info/METADATA

@@ -0,0 +1,48 @@
+Metadata-Version: 2.2
+Name: jetpytools
+Version: 1.2.3
+Summary: Collection of stuff that's useful in general python programming
+Author: Jaded Encoding Thaumaturgy
+Author-email: jaded.encoding.thaumaturgy@gmail.com
+Maintainer: Jaded Encoding Thaumaturgy
+Maintainer-email: jaded.encoding.thaumaturgy@gmail.com
+Project-URL: Source Code, https://github.com/Jaded-Encoding-Thaumaturgy/jetpytools
+Project-URL: Contact, https://discord.gg/XTpc6Fa9eB
+Classifier: Natural Language :: English
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Other Audience
+Classifier: Programming Language :: Python :: 3.10
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: maintainer
+Dynamic: maintainer-email
+Dynamic: project-url
+Dynamic: requires-python
+Dynamic: summary
+
+# jetpytools
+
+Collection of stuff that's useful in general python programming
+
+## How to install
+
+Install `jetpytools` with the following command:
+
+```sh
+pip install jetpytools
+```
+
+Or if you want the latest git version, install it with this command:
+
+```sh
+pip install git+https://github.com/Jaded-Encoding-Thaumaturgy/jetpytools.git
+```

jetpytools-1.2.3.dist-info/RECORD

@@ -0,0 +1,33 @@
+jetpytools/__init__.py,sha256=FSVZdj69oy4mBXd6OXiRHrUhaSc4Exo1pQHBlXycV98,214
+jetpytools/_metadata.py,sha256=h_0Q6daDjew31Bh1Mlh32FVTx8Srl8nedCU6pABa66g,414
+jetpytools/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+jetpytools/enums/__init__.py,sha256=5n6Cu8Yb9N6hIa_YTsyy_s0cCgCnh0vDb-NyXK2RwV0,81
+jetpytools/enums/base.py,sha256=q0HUCl8NN66b4VXYNjP_AMrYqjlcLVlRs0GQHXt17zU,2083
+jetpytools/enums/other.py,sha256=vQIouUJWRa039t8E1RQYc61MYS3uhe-o-5SBRlXs9x4,1416
+jetpytools/exceptions/__init__.py,sha256=g8GT0XqcNuHFHgQGSRj6a_X1kBiBQGP05soYNbEIN_Q,205
+jetpytools/exceptions/base.py,sha256=S3sqhT6yQSbPshmcy3XyVgfjDXic_xbpb8799TfD-cI,6342
+jetpytools/exceptions/enum.py,sha256=9YoWwEfyd9k7NwanAqtXbhJaJQAnjRKqsAO73cDvcpA,223
+jetpytools/exceptions/file.py,sha256=QwhUFAoG3NsFFYuPe5O_I6K969CzlrTCv3RTrfzx8B0,1107
+jetpytools/exceptions/generic.py,sha256=jWCJ6ato12rJBXLmZx4ReMVWG0iMuStR5Tz9CJlVevI,1492
+jetpytools/exceptions/module.py,sha256=drkcpa8hcE7Ee20N15j3qsX_grl8a3Jjv10XJ3xtDmE,1207
+jetpytools/functions/__init__.py,sha256=CeDfQrPCYqjiXyCoZ6jcbfM2d7KmRM11lBSxUK2wl4g,127
+jetpytools/functions/funcs.py,sha256=EMoJ_h2tl8Cgr1PXAsmRvgaOY5YL7AiEnGGo3-H76tk,3797
+jetpytools/functions/normalize.py,sha256=dyEuLVOZ2WSR_qDgyVGILn-0MURizCn5Nk1KuppgbG8,6381
+jetpytools/functions/other.py,sha256=TRz91spvdYJUh9vKe3Kuw6xZfSEJvrQs1mZVg7SyYmY,413
+jetpytools/types/__init__.py,sha256=0veUJC8ioXsx1g3Nx-YQSKTnkenfyaD5y91qBDkyM8Q,253
+jetpytools/types/builtins.py,sha256=moET0CgjQnUkis2V1RViL53OMCVAIV4zBDcClsaKn5g,1807
+jetpytools/types/file.py,sha256=lUXszSZZbZHftCsDXbqoQumqUdZwGi3ocgW3p8tMJyE,6082
+jetpytools/types/funcs.py,sha256=MOA-BdxDbvCPvAReKvUM2P87KnmGnIDjkqSmYycJXUo,3114
+jetpytools/types/generic.py,sha256=sAyBwGVG5FZ-6HVpfRuczov_6zQ_Uyoi0QWnR2iMm9Q,1128
+jetpytools/types/supports.py,sha256=--VZ-iCUiv-a6K8n-H8-6hSxHjrvdYg9mCLhr_lRplo,3051
+jetpytools/types/utils.py,sha256=tBHAlMADYB5CiGb1zeh1m_C4RK8_Zi8Pbd_dStsZjYM,22243
+jetpytools/utils/__init__.py,sha256=v5Bkl43-OBWlXx9OWpZoGH-QMaYNsPIi4vfuhC13ZLI,163
+jetpytools/utils/file.py,sha256=9GhMGJ5D7CpvUFnvnwPFMloYTeIX-AJ7aKYKdoJQ374,10455
+jetpytools/utils/funcs.py,sha256=ZuLz63kveBY1CLlBexEqmrQiGC67dY4gaXdNU3CeBMw,898
+jetpytools/utils/math.py,sha256=lNTriLtTXgqN82DVSXJ5KUbhsWgxXoJ5eNGIZ0-_r_c,3335
+jetpytools/utils/ranges.py,sha256=dL3WG235Pz9sk5su8A0VdwVf_oSt6obR7R_JNwLyCjQ,2572
+jetpytools-1.2.3.dist-info/LICENSE,sha256=l0PN-qDtXcgOB5aXP_nSUsvCK5V3o9pQCGsTzyZhKL0,1071
+jetpytools-1.2.3.dist-info/METADATA,sha256=ipieUMdlycXQ9NkzOWzLDB8QtnL5AExriLKaY0QP258,1399
+jetpytools-1.2.3.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+jetpytools-1.2.3.dist-info/top_level.txt,sha256=Iy4HjIta33ADJxN9Nyt5t5jRIfotEkZkQcOSw4eG8Cs,11
+jetpytools-1.2.3.dist-info/RECORD,,

jetpytools-1.2.3.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (75.8.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

jetpytools-1.2.3.dist-info/top_level.txt

@@ -0,0 +1 @@
+jetpytools