ethraid 3.0__tar.gz → 3.2.0__tar.gz

ethraid-3.2.0/.eggs/numpy-2.2.2-py3.12-macosx-10.15-x86_64.egg/numpy/_core/tests/examples/cython/checks.pyx

@@ -0,0 +1,274 @@
+#cython: language_level=3
+
+"""
+Functions in this module give python-space wrappers for cython functions
+exposed in numpy/__init__.pxd, so they can be tested in test_cython.py
+"""
+cimport numpy as cnp
+cnp.import_array()
+
+
+def is_td64(obj):
+    return cnp.is_timedelta64_object(obj)
+
+
+def is_dt64(obj):
+    return cnp.is_datetime64_object(obj)
+
+
+def get_dt64_value(obj):
+    return cnp.get_datetime64_value(obj)
+
+
+def get_td64_value(obj):
+    return cnp.get_timedelta64_value(obj)
+
+
+def get_dt64_unit(obj):
+    return cnp.get_datetime64_unit(obj)
+
+
+def is_integer(obj):
+    return isinstance(obj, (cnp.integer, int))
+
+
+def get_datetime_iso_8601_strlen():
+    return cnp.get_datetime_iso_8601_strlen(0, cnp.NPY_FR_ns)
+
+
+def convert_datetime64_to_datetimestruct():
+    cdef:
+        cnp.npy_datetimestruct dts
+        cnp.PyArray_DatetimeMetaData meta
+        cnp.int64_t value = 1647374515260292
+        # i.e. (time.time() * 10**6) at 2022-03-15 20:01:55.260292 UTC
+
+    meta.base = cnp.NPY_FR_us
+    meta.num = 1
+    cnp.convert_datetime64_to_datetimestruct(&meta, value, &dts)
+    return dts
+
+
+def make_iso_8601_datetime(dt: "datetime"):
+    cdef:
+        cnp.npy_datetimestruct dts
+        char result[36]  # 36 corresponds to NPY_FR_s passed below
+        int local = 0
+        int utc = 0
+        int tzoffset = 0
+
+    dts.year = dt.year
+    dts.month = dt.month
+    dts.day = dt.day
+    dts.hour = dt.hour
+    dts.min = dt.minute
+    dts.sec = dt.second
+    dts.us = dt.microsecond
+    dts.ps = dts.as = 0
+
+    cnp.make_iso_8601_datetime(
+        &dts,
+        result,
+        sizeof(result),
+        local,
+        utc,
+        cnp.NPY_FR_s,
+        tzoffset,
+        cnp.NPY_NO_CASTING,
+    )
+    return result
+
+
+cdef cnp.broadcast multiiter_from_broadcast_obj(object bcast):
+    cdef dict iter_map = {
+        1: cnp.PyArray_MultiIterNew1,
+        2: cnp.PyArray_MultiIterNew2,
+        3: cnp.PyArray_MultiIterNew3,
+        4: cnp.PyArray_MultiIterNew4,
+        5: cnp.PyArray_MultiIterNew5,
+    }
+    arrays = [x.base for x in bcast.iters]
+    cdef cnp.broadcast result = iter_map[len(arrays)](*arrays)
+    return result
+
+
+def get_multiiter_size(bcast: "broadcast"):
+    cdef cnp.broadcast multi = multiiter_from_broadcast_obj(bcast)
+    return multi.size
+
+
+def get_multiiter_number_of_dims(bcast: "broadcast"):
+    cdef cnp.broadcast multi = multiiter_from_broadcast_obj(bcast)
+    return multi.nd
+
+
+def get_multiiter_current_index(bcast: "broadcast"):
+    cdef cnp.broadcast multi = multiiter_from_broadcast_obj(bcast)
+    return multi.index
+
+
+def get_multiiter_num_of_iterators(bcast: "broadcast"):
+    cdef cnp.broadcast multi = multiiter_from_broadcast_obj(bcast)
+    return multi.numiter
+
+
+def get_multiiter_shape(bcast: "broadcast"):
+    cdef cnp.broadcast multi = multiiter_from_broadcast_obj(bcast)
+    return tuple([multi.dimensions[i] for i in range(bcast.nd)])
+
+
+def get_multiiter_iters(bcast: "broadcast"):
+    cdef cnp.broadcast multi = multiiter_from_broadcast_obj(bcast)
+    return tuple([<cnp.flatiter>multi.iters[i] for i in range(bcast.numiter)])
+
+
+def get_default_integer():
+    if cnp.NPY_DEFAULT_INT == cnp.NPY_LONG:
+        return cnp.dtype("long")
+    if cnp.NPY_DEFAULT_INT == cnp.NPY_INTP:
+        return cnp.dtype("intp")
+    return None
+
+def get_ravel_axis():
+    return cnp.NPY_RAVEL_AXIS
+
+
+def conv_intp(cnp.intp_t val):
+    return val
+
+
+def get_dtype_flags(cnp.dtype dtype):
+    return dtype.flags
+
+
+cdef cnp.NpyIter* npyiter_from_nditer_obj(object it):
+    """A function to create a NpyIter struct from a nditer object.
+
+    This function is only meant for testing purposes and only extracts the
+    necessary info from nditer to test the functionality of NpyIter methods
+    """
+    cdef:
+        cnp.NpyIter* cit
+        cnp.PyArray_Descr* op_dtypes[3]
+        cnp.npy_uint32 op_flags[3]
+        cnp.PyArrayObject* ops[3]
+        cnp.npy_uint32 flags = 0
+
+    if it.has_index:
+        flags |= cnp.NPY_ITER_C_INDEX
+    if it.has_delayed_bufalloc:
+        flags |= cnp.NPY_ITER_BUFFERED | cnp.NPY_ITER_DELAY_BUFALLOC
+    if it.has_multi_index:
+        flags |= cnp.NPY_ITER_MULTI_INDEX
+
+    # one of READWRITE, READONLY and WRTIEONLY at the minimum must be specified for op_flags
+    for i in range(it.nop):
+        op_flags[i] = cnp.NPY_ITER_READONLY
+
+    for i in range(it.nop):
+        op_dtypes[i] = cnp.PyArray_DESCR(it.operands[i])
+        ops[i] = <cnp.PyArrayObject*>it.operands[i]
+
+    cit = cnp.NpyIter_MultiNew(it.nop, &ops[0], flags, cnp.NPY_KEEPORDER,
+                               cnp.NPY_NO_CASTING, &op_flags[0],
+                               <cnp.PyArray_Descr**>NULL)
+    return cit
+
+
+def get_npyiter_size(it: "nditer"):
+    cdef cnp.NpyIter* cit = npyiter_from_nditer_obj(it)
+    result = cnp.NpyIter_GetIterSize(cit)
+    cnp.NpyIter_Deallocate(cit)
+    return result
+
+
+def get_npyiter_ndim(it: "nditer"):
+    cdef cnp.NpyIter* cit = npyiter_from_nditer_obj(it)
+    result = cnp.NpyIter_GetNDim(cit)
+    cnp.NpyIter_Deallocate(cit)
+    return result
+
+
+def get_npyiter_nop(it: "nditer"):
+    cdef cnp.NpyIter* cit = npyiter_from_nditer_obj(it)
+    result = cnp.NpyIter_GetNOp(cit)
+    cnp.NpyIter_Deallocate(cit)
+    return result
+
+
+def get_npyiter_operands(it: "nditer"):
+    cdef cnp.NpyIter* cit = npyiter_from_nditer_obj(it)
+    try:
+        arr = cnp.NpyIter_GetOperandArray(cit)
+        return tuple([<cnp.ndarray>arr[i] for i in range(it.nop)])
+    finally:
+        cnp.NpyIter_Deallocate(cit)
+
+
+def get_npyiter_itviews(it: "nditer"):
+    cdef cnp.NpyIter* cit = npyiter_from_nditer_obj(it)
+    result = tuple([cnp.NpyIter_GetIterView(cit, i) for i in range(it.nop)])
+    cnp.NpyIter_Deallocate(cit)
+    return result
+
+
+def get_npyiter_dtypes(it: "nditer"):
+    cdef cnp.NpyIter* cit = npyiter_from_nditer_obj(it)
+    try:
+        arr = cnp.NpyIter_GetDescrArray(cit)
+        return tuple([<cnp.dtype>arr[i] for i in range(it.nop)])
+    finally:
+        cnp.NpyIter_Deallocate(cit)
+
+
+def npyiter_has_delayed_bufalloc(it: "nditer"):
+    cdef cnp.NpyIter* cit = npyiter_from_nditer_obj(it)
+    result = cnp.NpyIter_HasDelayedBufAlloc(cit)
+    cnp.NpyIter_Deallocate(cit)
+    return result
+
+
+def npyiter_has_index(it: "nditer"):
+    cdef cnp.NpyIter* cit = npyiter_from_nditer_obj(it)
+    result = cnp.NpyIter_HasIndex(cit)
+    cnp.NpyIter_Deallocate(cit)
+    return result
+
+
+def npyiter_has_multi_index(it: "nditer"):
+    cdef cnp.NpyIter* cit = npyiter_from_nditer_obj(it)
+    result = cnp.NpyIter_HasMultiIndex(cit)
+    cnp.NpyIter_Deallocate(cit)
+    return result
+
+
+def npyiter_has_finished(it: "nditer"):
+    cdef cnp.NpyIter* cit
+    try:
+        cit = npyiter_from_nditer_obj(it)
+        cnp.NpyIter_GotoIterIndex(cit, it.index)
+        return not (cnp.NpyIter_GetIterIndex(cit) < cnp.NpyIter_GetIterSize(cit))
+    finally:
+        cnp.NpyIter_Deallocate(cit)
+
+def compile_fillwithbyte():
+    # Regression test for gh-25878, mostly checks it compiles.
+    cdef cnp.npy_intp dims[2]
+    dims = (1, 2)
+    pos = cnp.PyArray_ZEROS(2, dims, cnp.NPY_UINT8, 0)
+    cnp.PyArray_FILLWBYTE(pos, 1)
+    return pos
+
+def inc2_cfloat_struct(cnp.ndarray[cnp.cfloat_t] arr):
+    # This works since we compile in C mode, it will fail in cpp mode
+    arr[1].real += 1
+    arr[1].imag += 1
+    # This works in both modes
+    arr[1].real = arr[1].real + 1
+    arr[1].imag = arr[1].imag + 1
+
+
+def check_npy_uintp_type_enum():
+    # Regression test for gh-27890: cnp.NPY_UINTP was not defined.
+    # Cython would fail to compile this before gh-27890 was fixed.
+    return cnp.NPY_UINTP > 0

ethraid-3.2.0/.eggs/numpy-2.2.2-py3.12-macosx-10.15-x86_64.egg/numpy/_core/tests/examples/limited_api/limited_api2.pyx

@@ -0,0 +1,11 @@
+#cython: language_level=3
+
+"""
+Make sure cython can compile in limited API mode (see meson.build)
+"""
+
+cdef extern from "numpy/arrayobject.h":
+    pass
+cdef extern from "numpy/arrayscalars.h":
+    pass
+

ethraid-3.2.0/.eggs/numpy-2.2.2-py3.12-macosx-10.15-x86_64.egg/numpy/random/_examples/cython/extending.pyx

@@ -0,0 +1,77 @@
+#cython: language_level=3
+
+from libc.stdint cimport uint32_t
+from cpython.pycapsule cimport PyCapsule_IsValid, PyCapsule_GetPointer
+
+import numpy as np
+cimport numpy as np
+cimport cython
+
+from numpy.random cimport bitgen_t
+from numpy.random import PCG64
+
+np.import_array()
+
+
+@cython.boundscheck(False)
+@cython.wraparound(False)
+def uniform_mean(Py_ssize_t n):
+    cdef Py_ssize_t i
+    cdef bitgen_t *rng
+    cdef const char *capsule_name = "BitGenerator"
+    cdef double[::1] random_values
+    cdef np.ndarray randoms
+
+    x = PCG64()
+    capsule = x.capsule
+    if not PyCapsule_IsValid(capsule, capsule_name):
+        raise ValueError("Invalid pointer to anon_func_state")
+    rng = <bitgen_t *> PyCapsule_GetPointer(capsule, capsule_name)
+    random_values = np.empty(n)
+    # Best practice is to acquire the lock whenever generating random values.
+    # This prevents other threads from modifying the state. Acquiring the lock
+    # is only necessary if the GIL is also released, as in this example.
+    with x.lock, nogil:
+        for i in range(n):
+            random_values[i] = rng.next_double(rng.state)
+    randoms = np.asarray(random_values)
+    return randoms.mean()
+
+
+# This function is declared nogil so it can be used without the GIL below
+cdef uint32_t bounded_uint(uint32_t lb, uint32_t ub, bitgen_t *rng) nogil:
+    cdef uint32_t mask, delta, val
+    mask = delta = ub - lb
+    mask |= mask >> 1
+    mask |= mask >> 2
+    mask |= mask >> 4
+    mask |= mask >> 8
+    mask |= mask >> 16
+
+    val = rng.next_uint32(rng.state) & mask
+    while val > delta:
+        val = rng.next_uint32(rng.state) & mask
+
+    return lb + val
+
+
+@cython.boundscheck(False)
+@cython.wraparound(False)
+def bounded_uints(uint32_t lb, uint32_t ub, Py_ssize_t n):
+    cdef Py_ssize_t i
+    cdef bitgen_t *rng
+    cdef uint32_t[::1] out
+    cdef const char *capsule_name = "BitGenerator"
+
+    x = PCG64()
+    out = np.empty(n, dtype=np.uint32)
+    capsule = x.capsule
+
+    if not PyCapsule_IsValid(capsule, capsule_name):
+        raise ValueError("Invalid pointer to anon_func_state")
+    rng = <bitgen_t *>PyCapsule_GetPointer(capsule, capsule_name)
+
+    with x.lock, nogil:
+        for i in range(n):
+            out[i] = bounded_uint(lb, ub, rng)
+    return np.asarray(out)

ethraid-3.2.0/.eggs/numpy-2.2.2-py3.12-macosx-10.15-x86_64.egg/numpy/random/_examples/cython/extending_distributions.pyx

@@ -0,0 +1,116 @@
+#cython: language_level=3
+"""
+This file shows how the to use a BitGenerator to create a distribution.
+"""
+import numpy as np
+cimport numpy as np
+cimport cython
+from cpython.pycapsule cimport PyCapsule_IsValid, PyCapsule_GetPointer
+from libc.stdint cimport uint16_t, uint64_t
+from numpy.random cimport bitgen_t
+from numpy.random import PCG64
+from numpy.random.c_distributions cimport (
+      random_standard_uniform_fill, random_standard_uniform_fill_f)
+
+
+@cython.boundscheck(False)
+@cython.wraparound(False)
+def uniforms(Py_ssize_t n):
+    """
+    Create an array of `n` uniformly distributed doubles.
+    A 'real' distribution would want to process the values into
+    some non-uniform distribution
+    """
+    cdef Py_ssize_t i
+    cdef bitgen_t *rng
+    cdef const char *capsule_name = "BitGenerator"
+    cdef double[::1] random_values
+
+    x = PCG64()
+    capsule = x.capsule
+    # Optional check that the capsule if from a BitGenerator
+    if not PyCapsule_IsValid(capsule, capsule_name):
+        raise ValueError("Invalid pointer to anon_func_state")
+    # Cast the pointer
+    rng = <bitgen_t *> PyCapsule_GetPointer(capsule, capsule_name)
+    random_values = np.empty(n, dtype='float64')
+    with x.lock, nogil:
+        for i in range(n):
+            # Call the function
+            random_values[i] = rng.next_double(rng.state)
+    randoms = np.asarray(random_values)
+
+    return randoms
+
+# cython example 2
+@cython.boundscheck(False)
+@cython.wraparound(False)
+def uint10_uniforms(Py_ssize_t n):
+    """Uniform 10 bit integers stored as 16-bit unsigned integers"""
+    cdef Py_ssize_t i
+    cdef bitgen_t *rng
+    cdef const char *capsule_name = "BitGenerator"
+    cdef uint16_t[::1] random_values
+    cdef int bits_remaining
+    cdef int width = 10
+    cdef uint64_t buff, mask = 0x3FF
+
+    x = PCG64()
+    capsule = x.capsule
+    if not PyCapsule_IsValid(capsule, capsule_name):
+        raise ValueError("Invalid pointer to anon_func_state")
+    rng = <bitgen_t *> PyCapsule_GetPointer(capsule, capsule_name)
+    random_values = np.empty(n, dtype='uint16')
+    # Best practice is to release GIL and acquire the lock
+    bits_remaining = 0
+    with x.lock, nogil:
+        for i in range(n):
+            if bits_remaining < width:
+                buff = rng.next_uint64(rng.state)
+            random_values[i] = buff & mask
+            buff >>= width
+
+    randoms = np.asarray(random_values)
+    return randoms
+
+# cython example 3
+def uniforms_ex(bit_generator, Py_ssize_t n, dtype=np.float64):
+    """
+    Create an array of `n` uniformly distributed doubles via a "fill" function.
+
+    A 'real' distribution would want to process the values into
+    some non-uniform distribution
+
+    Parameters
+    ----------
+    bit_generator: BitGenerator instance
+    n: int
+        Output vector length
+    dtype: {str, dtype}, optional
+        Desired dtype, either 'd' (or 'float64') or 'f' (or 'float32'). The
+        default dtype value is 'd'
+    """
+    cdef Py_ssize_t i
+    cdef bitgen_t *rng
+    cdef const char *capsule_name = "BitGenerator"
+    cdef np.ndarray randoms
+
+    capsule = bit_generator.capsule
+    # Optional check that the capsule if from a BitGenerator
+    if not PyCapsule_IsValid(capsule, capsule_name):
+        raise ValueError("Invalid pointer to anon_func_state")
+    # Cast the pointer
+    rng = <bitgen_t *> PyCapsule_GetPointer(capsule, capsule_name)
+
+    _dtype = np.dtype(dtype)
+    randoms = np.empty(n, dtype=_dtype)
+    if _dtype == np.float32:
+        with bit_generator.lock:
+            random_standard_uniform_fill_f(rng, n, <float*>np.PyArray_DATA(randoms))
+    elif _dtype == np.float64:
+        with bit_generator.lock:
+            random_standard_uniform_fill(rng, n, <double*>np.PyArray_DATA(randoms))
+    else:
+        raise TypeError('Unsupported dtype %r for random' % _dtype)
+    return randoms
+

{ethraid-3.0/ethraid.egg-info → ethraid-3.2.0}/PKG-INFO

@@ -1,23 +1,44 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: ethraid
-Version: 3.0
+Version: 3.2.0
 Summary: Characterize long-period companions using RV trends, astrometric accelerations, and direct imaging
 Home-page: 
 Author: Judah Van Zandt
 Author-email: judahvz@astro.ucla.edu
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Requires-Dist: astropy>=6.0
+Requires-Dist: Cython>=3.0
+Requires-Dist: h5py>=3.10
+Requires-Dist: matplotlib>=3.8
+Requires-Dist: numpy>=1.26
+Requires-Dist: pandas>=2.0
+Requires-Dist: scipy>=1.11
+Requires-Dist: tqdm>=4.64.0
+Requires-Dist: astroquery>=0.4.7
+Requires-Dist: setuptools>=65.6.3
+Dynamic: author
+Dynamic: author-email
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: summary
+
+<div align="center">
+    <img src="ethraid/example/ethraid.jpg" width="168" height="150">
+</div>
 
 # Ethraid
 
 Characterize long-period companions with partial orbits.
 
-Please cite Van Zandt \& Petigura (2024, Accepted) and the following DOI if you make use of this software in your research.
+Please cite Van Zandt \& Petigura (2024) and the following DOI if you make use of this software in your research.
 [![DOI](https://zenodo.org/badge/355760029.svg)](https://zenodo.org/doi/10.5281/zenodo.10841606)
 
 ## Environment
-### Create new environment with python 3.7
-- *\$ conda create --name ethraid_env python=3.7*
+### Create new environment with python 3.14
+- *\$ conda create --name ethraid_env python=3.14*
 - *\$ conda activate ethraid_env*
 
 ## Download using pip

{ethraid-3.0 → ethraid-3.2.0}/README.md

@@ -1,13 +1,17 @@
+<div align="center">
+    <img src="ethraid/example/ethraid.jpg" width="168" height="150">
+</div>
+
 # Ethraid
 
 Characterize long-period companions with partial orbits.
 
-Please cite Van Zandt \& Petigura (2024, Accepted) and the following DOI if you make use of this software in your research.
+Please cite Van Zandt \& Petigura (2024) and the following DOI if you make use of this software in your research.
 [![DOI](https://zenodo.org/badge/355760029.svg)](https://zenodo.org/doi/10.5281/zenodo.10841606)
 
 ## Environment
-### Create new environment with python 3.7
-- *\$ conda create --name ethraid_env python=3.7*
+### Create new environment with python 3.14
+- *\$ conda create --name ethraid_env python=3.14*
 - *\$ conda activate ethraid_env*
 
 ## Download using pip

{ethraid-3.0 → ethraid-3.2.0}/ethraid/__init__.py

@@ -1,7 +1,7 @@
 import os
 from astropy.time import Time
 
-__version__='3.0' # Remember to remove random seed
+__version__='3.2.0' # Remember to remove random seed
 
 _ROOT = os.path.abspath(os.path.dirname(__file__))
 

{ethraid-3.0 → ethraid-3.2.0}/ethraid/cli.py

@@ -2,6 +2,7 @@
 Command Line Interface
 """
 
+import sys
 from argparse import ArgumentParser
 import ethraid.driver
 
@@ -137,6 +138,11 @@ def main():
     #                       help='Dimension of binned probability arrays. Required for raw input arrays.'
     #                       )
     psr_all.set_defaults(func=ethraid.driver.all)
+    
+    # If no arguments are provided, print help message and exit
+    if len(sys.argv)==1:
+        psr.print_help(sys.stderr)
+        sys.exit(1)
 
     
     args = psr.parse_args()