[](https://github.com/SETI/rms-cspyce/releases)
[](https://github.com/SETI/rms-cspyce/releases)
[](https://github.com/SETI/rms-cspyce/actions)
[](https://codecov.io/gh/SETI/rms-cspyce)
<br />
[](https://pypi.org/project/cspyce)
[](https://pypi.org/project/cspyce)
[](https://pypi.org/project/cspyce)
[](https://pypi.org/project/cspyce)
<br />
[](https://github.com/SETI/rms-cspyce/commits/main/)
[](https://github.com/SETI/rms-cspyce/commits/main/)
[](https://github.com/SETI/rms-cspyce/commits/main/)
<br />
[](https://github.com/SETI/rms-cspyce/issues)
[](https://github.com/SETI/rms-cspyce/issues)
[](https://github.com/SETI/rms-cspyce/pulls)
[](https://github.com/SETI/rms-cspyce/pulls)
<br />
[](https://github.com/SETI/rms-cspyce/stargazers)
# `cspyce` MODULE OVERVIEW
Version 2.x, originally released March, 2022 (see above for current installable
version)
PDS Ring-Moon Systems Node, SETI Institute
`cspyce` is a Python module that provides an interface to the C-language CSPICE
library produced by the Navigation and Ancillary Information Facility
([NAIF](https://naif.jpl.nasa.gov/naif/)) of NASA's Planetary Data System (PDS).
It implements most functions of CSPICE in a Python-like way, while also
supporting numerous enhancements, including support for Python exceptions,
array inputs, and aliases.
`cspyce` may be installed by running `pip install cspyce`.
Python versions 3.9 thru 3.12 are currently supported, with pre-built wheels
available for Linux, MacOS, and Windows. NumPy 1.x and 2.x are supported.
If you are looking for information on running or distributing this code from
the GitHub sources, look at the file `README-developers.md` in this directory.
## PYTHONIZATION
`cspyce` has been designed to replicate the core features of CSPICE for
users who wish to translate a program that already exists. Function names in
`cspyce` match their CSPICE names.
However, it is also designed to behave as much as possible like a normal
Python module. To that end, it has the following features.
- The C language requires buffers to be allocated for output and it requires
array sizes to be included for both input and output. The `cspyce` module,
instead, eliminates all extraneous inputs, and all output arguments are
returned as a list (or as a single object if the function only returns one
item).
- `cspyce` has been fully integrated with Python's exception handling;
programmers can still opt to use CSPICE's error handling mechanism if they
wish to.
- All `cspyce` functions can handle positional arguments as well as arguments
passed by name.
- All `cspyce` functions have informative docstrings, so typing
`help(function)` provides useful information.
- Many `cspyce` functions take sensible default values if input arguments are
omitted.
- All `cspyce` functions that take filename arguments now support
[path-like-argument](https://docs.python.org/3/glossary.html#term-path-like-object)s.
A path-like argument could be a strings, a byte string, or a `pathlib.Path`.
The [`pathlib.Path`](https://docs.python.org/3/library/pathlib.html) class provides an
object-oriented class for manipulating file-system paths and performing common operations
on files.
## ENHANCEMENTS
In addition, the `cspyce` module takes advantage of features of the Python
language to provide numerous options about how the functions perform their work.
These options include:
- Whether to return a CSPICE-style error condition or to raise a Python
exception.
- How to handle CSPICE functions that return a status flag, e.g., "found" or
"ok", instead of using the CSPICE toolkit's error handling mechanism.
- Whether to allow `cspyce` functions to accept arrays of inputs all at once,
rather than looping through inputs in Python.
- Whether to automate the translation between SPICE body and frame IDs and their
associated names.
- Whether to allow `cspyce` to support aliases, in which the same body or frame
is associated with alternative names or IDs.
---
## EXCEPTION HANDLING
In CSPICE, the user can designate what to do in the event of an error condition
using the function `erract()`. In CSPICE, the available options are "RETURN",
"REPORT", "IGNORE", "ABORT", and "DEFAULT". The `cspyce` version of this
function adds new options "EXCEPTION" and "RUNTIME" to the suite of error
handling options supported by CSPICE.
- As usual, the user can select the exception handling mechanism to use by
calling the function erract(). In `cspyce`, the default is "EXCEPTION".
- When using the "EXCEPTION" option, each CSPICE error condition raises a
Python exception rather than setting the `failed()` flag. The exception
contains the text of the CSPICE error, in the form (short message + " -- " +
long message). The CSPICE error conditions are mapped to standard Python
exception types in a sensible way:
- `KeyError` indicates that a SPICE ID or name is unrecognized.
- `ValueError` indicates that one of the inputs to a function had an invalid
value.
- `TypeError` indicates that one of the inputs to a function had an invalid
type.
- `IndexError` indicates that an integer index is out of range.
- `IOError` indicates errors with reading and writing files, including SPICE
kernels. IOError can also indicate that needed information was not in one
of the furnished kernels.
- `MemoryError` indicates that adequate memory could not be allocated, or
that the defined size of a memory buffer in C is too small.
- `ZeroDivisionError` indicates that a divide-by-zero has occurred.
- `RuntimeError` indicates that an action is incompatible with some aspect
of the CSPICE module's internal configuration.
- When using one of CSPICE's intrinsic error handling methods, no exception
will be raised, but a call to `failed()` will reveal whether an error has
occurred. A call to `reset()` is needed to clear the error.
- Care has been taken to reduce the chances that the "dangerous" options
"IGNORE" and "REPORT" will cause a segmentation fault. However, this
possibility cannot be entirely ruled out, so caution is advised.
- Because it would be a highly questionable thing to do, the "ABORT" and
"DEFAULT" options are overridden by "EXCEPTION" when the user is running
`cspyce` from an interactive shell. However, they resume their standard
effects during non-interactive runs.
- When using the "RUNTIME" option, each CSPICE error condition raises a
Python `RuntimeError` exception rather than setting the `failed()` flag. This
is similar to the "EXCEPTION" option except the type of exception is always
the same.
- Certain out-of-memory conditions are beyond the control of the CSPICE
library. These will always raise a MemoryError exception, regardless of the
exception handling method chosen.
### HANDLING OF ERROR FLAGS
Many CSPICE functions bypass the library's own error handling mechanism; instead
they return a status flag, sometimes called "found" or "ok", or perhaps an empty
response to indicate failure. The `cspyce` module provides alternative options
for these functions.
Within `cspyce`, functions that return error flags have an alternative
implementation with a suffix of "_error", which uses the CSPICE/`cspyce` error
handling mechanism detailed above instead.
Note that most `_error` versions of functions have fewer return values than the
associated non-error versions. The user should be certain which version is being
used before interpreting the returned value(s).
The `cspyce` module provides several ways to control which version of the
function to use:
- The function `use_flags()` takes a function name or list of names and
designates the original version of each function as the default. If the input
argument is missing, original versions are selected universally.
- The function `use_errors()` takes a function name or list of names and
designates the `_error` version of each function as the default. If the input
argument is missing, `_error` versions are selected universally.
To provide a more consistent Python interface, the `_error` versions of all
`cspyce` functions are selected by default. You can also choose between the
"flag" and "error" versions of a function using `cspyce` function attributes,
as discussed below.
---
## VECTORS AND ARRAYS
### VECTORIZATION
Nearly every function that takes floating-point input (be it a
scalar, 1-D array, or 2-D array) has a vectorized version that allows you to
pass a vector of these items in place of a single value. The CSPICE function is
called for each of the provided inputs, the results are collected, and the
`cspyce` function returns a vector of results.
- Vectorized versions have the same name but with `_vector` appended.
- In a vectorized function, you can replace any or all floating-point input
parameters with an array having one extra leading dimension. Integer, boolean,
and string inputs cannot be replaced by arrays.
- If no inputs have an extra dimension, then the result is the same as
calling the original, un-vectorized function.
- Otherwise, all returned quantities are replaced by arrays having the size of
the largest leading axis.
- Note that it is permissible to pass arrays with different leading axis sizes
to the function. The vectorized function cycles through the elements of each
array repeatedly if necessary. It may make sense to do this if each leading
axis is an integer fraction of the largest axis size. For example, if the
first input array has size 100 and the second has size 25, then the returned
arrays(s) will have 100 elements and the values of the second will each be
used four times. However, caution is advised when using this capability.
- Some functions are not vectorized. These include:
- Functions that have no floating-point inputs.
- Functions that include strings among the returned quantities.
- Functions that already return arrays where the leading axis could be
variable in size.
- In the two cases (`ckgp` and `ckgpav`) where a function can be both vectorized
and either raise an error or return a flag, the `_vector` suffix comes
before `_error`.
### ARRAYS
An optional import allows the `cspyce` module to support multidimensional
arrays:
```python
import cspyce
import cspyce.arrays
```
The latter import creates a new function in which the suffix `_array` replaces
`_vector` for every vectorized function. Whereas `_vector` functions support
only a single extra dimension, `_array` functions follow all the standard rules
of shape broadcasting as defined in NumPy. For example, if one input has leading
dimension (10,4) and another has dimension (4,), then the two shapes will be
broadcasted together and returned quantities will be arrays with shape (10,4).
You can choose between the scalar, vector, and array versions of a function by
using their explicit names, or by using `cspyce` function attributes, as discussed
below.
---
## ALIASES
Aliases allow the user to associate multiple names or SPICE codes with the same
CSPICE body or frame. Aliases can be used for a variety of purposes.
- You can use names and codes interchangeably as input arguments to any `cspyce`
function.
- You can use a body name or code in place of a frame name or code, and the
primary frame associated with that identified body will be used.
- Strings that represent integers are equivalent to the integers themselves.
Most importantly, you can allow multiple names or codes to refer to the same
CSPICE body or frame. For bodies and frames that have multiple names or codes,
calls to a `cspyce` function will try each option in sequence until it finds one
that works. Options are always tried in the order in which they were defined, so
higher-priority names and codes are tried first.
Example 1: Jupiter's moon Dia uses code 553, but it previously used code
55076. With 55076 defined as an alias for 553, a `cspyce` call will return
information about Dia under either of its codes.
Example 2: The Earth's rotation is, by default, modeled by frame "IAU_EARTH".
However, "ITRF93" is the name of a much more precise description of Earth's
rotation. If you define "IAU_EARTH" as an alias for "ITRF93", then the `cspyce`
toolkit will use ITRF93 if it is available, and otherwise IAU_EARTH.
Immediately after a `cspyce` call involving aliases, you can find out what value
or values were actually used by looking at attributes of the function. For
example, the first input to the `cspyce` function `spkez` is called `targ` and
it identifies the code of a target being observed. After a call to
```python
cspyce.spkez(553, ...)
```
the value of `cspyce.spkez.targ` will be the code actually used, in this case
either 553 or 55076.
To enable aliases, you must import an additional module
```python
import cspyce
import cspyce.aliases
```
(Note that `cspyce.aliases` and `cspyce.arrays` can both be imported, and in
either order. Note also that these are unconventional modules, in that they
introduce new functionality into the `cspyce` namespace rather than creating
new namespaces called `cspyce.aliases` and `cspyce.arrays`.)
With this import, a new function is defined for every `cspyce` function that takes
a frame or body as input. The new function has the same name as the pre-existing
`cspyce` function, but with `_alias` inserted immediately after the original
`cspyce` name (and before any other suffix such as `_vector` or `_error`).
You can make alias support the default for individual `cspyce` functions or for
the entire `cspyce` module by calling `cspyce.use_aliases()`. These versions
can subsequently be disabled as the default by calling `cspyce.use_noaliases()`
(see more detailed discussion below).
To define a body alias or frame alias, call
cspyce.define_body_aliases(name_or_code, name_or_code, ...)
cspyce.define_frame_aliases(name_or_code, name_or_code, ...)
where the arguments are an arbitrary list of codes and names.
To determine the aliases associated with a name or code, call
cspyce.get_body_aliases(name_or_code)
cspyce.get_frame_aliases(name_or_code)
where the argument is either a name or a code.
You can also select between the alias-supporting and alias-nonsupporting
versions of a function using function attributes as discussed below.
---
## FUNCTION NAMES, VERSIONS AND SELECTION METHODS
A `cspyce` function can accumulate several suffixes, based on the particular
behavior, as so:
```python
basename[_alias][_vector|_array][_error]
```
Only functions that are truly distinct are defined. For example, if a function
does not have a vector option, then no function will exist containing the
`_vector` suffix.
You can use these functions to set defaults:
cspyce.use_flags()
cspyce.use_errors()
cspyce.use_scalars()
cspyce.use_vectors()
cspyce.use_arrays()
cspyce.use_aliases()
cspyce.use_noaliases()
Each function can take one or more arguments referencing specific `cspyce`
functions, in which case the defaults only apply to those functions. If no
arguments are specified, the default applies to all functions. For example,
to use "flags" as the default for all functions except `ckgp`, you could use:
cspyce.use_flags()
cspyce.use_errors(cspyce.ckgp)
### FUNCTION ATTRIBUTES
Function attributes provide a simpler mechanism for choosing the needed
version of a function, without needing to remember the suffix rules. Every
`cspyce` function has these attributes, each of which identifies another
(or possibly the same) `cspyce` function:
| Attribute | Meaning |
|----------------|------------------------------------------------------------|
| `func.flag` | the equivalent function without the _error suffix, if any. |
| `func.error` | the equivalent function with the _error suffix, if any. |
| `func.scalar` | the equivalent function without _array or _vector suffixes.|
| `func.vector` | the equivalent function with the _vector suffix, if any. |
| `func.array` | the equivalent function with the _array suffix, if any. |
| `func.alias` | the equivalent function with the _alias suffix, if any. |
| `func.noalias` | the equivalent function without the _alias suffix, if any. |
These attributes are always defined, even if the particular option is not
supported by that function. This saves the programmer the effort of remembering,
for example, which functions support aliases or which functions support flags.
Thus, if the programmer wishes to be sure they are using the error version of
function `bodn2c`, and wants the vector version if it exists (but it doesn't!),
they can call
```python
cspyce.bodn2c.error.vector(args, ...)
```
---
## RECORD ENHANCEMENTS
### SpiceCell
`cspyce` provides an enhanced version of `SpiceCell` to make it simpler to use for
both CSPICE and in Python.
In the documentation that follows, _active elements_ refer to those elements in the
`SpiceCell` whose `index` is such that `0 ≤ index < spice_cell.card`.
#### Constructors
To create a `SpiceCell`:
```python
from cspyce import SpiceCell, SPICE_CELL_INT, SPICE_CELL_DOUBLE
spice_cell = SpiceCell(typeno=SPICE_CELL_INT, size=20)
spice_cell = SpiceCell(typeno=SPICE_CELL_DOUBLE, size=10)
```
With these constructors, `spice_cell.card` will be set to 0 and there will initially be
no active elements.
If you already have data that you want to convert to a spice cell, you can use a simpler
interface:
```python
spice_cell = SpiceCell([1, 2, 3, 4, 5])
spice_cell = SpiceCell(np.arange(1.0, 10.0))
spice_cell = SpiceCell(np.arange(1.0, 10.0), size=40) # set size explicitly
```
If you use these constructions, Python will create a `SpiceCell` whose size is a little
bigger than the length of the given data. The passed first argument will be the active
elements.
Any CSPICE function that expects a `SpiceCell` as an input can also be passed an array,
a tuple, or anything that can reasonably be converted into an appropriately typed
`SpiceCell`:
Any CSPICE function that returns a `SpiceCell` as a result takes an optional final
argument.
* If this argument is omitted, a `SpiceCell` with a function-specific default capacity
will be created, and the output will be placed into it.
* If this argument is a `SpiceCell`, it will be used as the output argument.
* If this argument is an integer, a `SpiceCell` with that capacity will be created and
used as the output.
In all cases, the `SpiceCell` output will also be a return value.
```shell
>>> import cspyce
>>> cspyce.wninsd(2.0, 4.9, (1.0, 3.0, 5.0, 7.0, 9.0, 11.0))
<SpiceCell double 6/12 [ 1. 4.9 5. 7. 9. 11. ]>
```
#### Sequence-like operations
`SpiceCell` offers the following methods so that they behave like Python sequences.
`spice_cell[index]`, `spice_cell[index] = value`
: Gets or sets the `index`-th element of the `SpiceCell`.
Must have `-len(spice_cell) ≤ index < spice_cell.size`. As in Python, we allow
negative indices, but -1, -2, etc count backwards from the last active elements.
`len(spice_cell)`
: Returns the number of active elements of `spice_cell`.
`spice_cell.append(value)`
: If `value` is a float or integer, it is added to the `SpiceCell`'s active cells.
If `value` is an array, all of its elements are added to the `SpiceCell`'s active cells.
The cell's maximum size is grown if necessary.
`spice_cell.extend(values)`
: Appends each value in `values` to the end of the `SpiceCell`'s active cells.
Each element of `values` can be a float, an integer, or an array.
The `SpiceCell`'s maximum size is grown if necessary.
`spice_cell += values`
: Synonym for `spice_cell.extend(values)`
`spice_cell.clear()`
: Make all elements inactive. Same as `spice_cell.card = 0`.
`iter(spice_cell)`
: Iterates through the active elements of `spice_cell`.
Because of this iterator, `list(spice_cell)`, `set(spice_cell)`, and `tuple(spice_cell)`
work as expected.
You can also write a for loop `for item in spice_cell: ...` to iterate through
the active elements.
`bool(spice_cell)`
: If a `spice_cell` is used in a boolean context, its value is `False` if all elements
are inactive (`spice.cell.card == 0`), and `True` otherwise.
#### SpiceCell-specific operations
`SpiceCell` also has the following methods and properties specific to a `SpiceCell`.
`spice_cell.size`
: Gets the current maximum size of the `SpiceCell`.
`spice_cell.size = value`
: Grows or shrinks the maximum size of the `SpiceCell`.
If the number of active elements is greater than `value`, it is reduced to `value`.
This operation is a `cspyce` enhancement that does not exist in CSPICE.
`spice_cell.card`
: Same as `len(spice_cell)`. (Also known as the "cardinality", hence the name).
`spice_cell.card = value`
: Changes the number of active elements in the `SpiceCell`.
Must have `0 ≤ value < spice_cell.size`.
`spice_cell.as_array()`
: Returns a view of the active contents of the array as a numpy array
`spice_cell.as_intervals()`
: Returns a view of the active contents of the array as a 2-dimensional `card/2`x 2 array.
Many `SpiceCell`s are used to represent intervals in which each
pair of numbers represents the lower and upper bounds.
Although `cspyce`'s `SpiceCell`s can grow and shrink, CSPICE is not aware of this
capability. Its functions will still raise a WINDOWOVERFLOW if `SpiceCell.size` is
not large enough to hold the results. The user must increase `SpiceCell.size` and try
again.
#### Handling intervals and other structures
Although internally, a `SpiceCell` is a flat array of integers or floats,
some CSPICE routines treat the contents of a `SpiceCell`
as if it were a 2-dimensional array.
For example, some CSPICE routines expect the `SpiceCell` to contain pairs of values
where each pair represents the limits of an interval.
To simplify dealing with this use case, the methods `append` and `extend` have been enhanced.
You can pass an array or an array-like object to `append`, and all elements of the
array will be added to the `SpiceCell`.
Likewise you can pass `extend` a sequence of array-like objects, and all of them will
be added to the `SpiceCell`.
So, for example, you could write:
```python
spice_cell.append([10, 20])
spice_cell.extend([[35, 50], [90, 100], [120, 140]])
```
to add intervals to your SpiceCell.
To view a `SpiceCell` containing intervals, you can use `spice_cell.as_intervals()`
as described above.
This is just a shortcut for `spice_cell.as_array().reshape(-1, 2)`, where
-1 is a special marker to `reshape` saying "figure out this value from the size of the
array and the other dimensions".
The expression `spice_cell.as_array().reshape(-1, 3)` would give an array of triples.
`self.as_array().reshape(-1, 4, 4)` gives an array of 4x4 matrices.
Raw data
{
"_id": null,
"home_page": "https://github.com/SETI/rms-cspyce",
"name": "cspyce",
"maintainer": "Robert S. French",
"docs_url": null,
"requires_python": ">=3.9",
"maintainer_email": "\"Robert S. French\" <rfrench@seti.org>",
"keywords": "cspyce, spice, cspice, naif, jpl, space, geometry, ephemeris",
"author": null,
"author_email": null,
"download_url": "https://files.pythonhosted.org/packages/1e/e8/98bd184ceed07f4d403b676dfe03874d12f2fdf423632bfac5abd9e196c3/cspyce-2.3.0.tar.gz",
"platform": null,
"description": "[](https://github.com/SETI/rms-cspyce/releases)\n[](https://github.com/SETI/rms-cspyce/releases)\n[](https://github.com/SETI/rms-cspyce/actions)\n[](https://codecov.io/gh/SETI/rms-cspyce)\n<br />\n[](https://pypi.org/project/cspyce)\n[](https://pypi.org/project/cspyce)\n[](https://pypi.org/project/cspyce)\n[](https://pypi.org/project/cspyce)\n<br />\n[](https://github.com/SETI/rms-cspyce/commits/main/)\n[](https://github.com/SETI/rms-cspyce/commits/main/)\n[](https://github.com/SETI/rms-cspyce/commits/main/)\n<br />\n[](https://github.com/SETI/rms-cspyce/issues)\n[](https://github.com/SETI/rms-cspyce/issues)\n[](https://github.com/SETI/rms-cspyce/pulls)\n[](https://github.com/SETI/rms-cspyce/pulls)\n<br />\n\n[](https://github.com/SETI/rms-cspyce/stargazers)\n\n\n\n# `cspyce` MODULE OVERVIEW\nVersion 2.x, originally released March, 2022 (see above for current installable\nversion)\n\nPDS Ring-Moon Systems Node, SETI Institute\n\n`cspyce` is a Python module that provides an interface to the C-language CSPICE\nlibrary produced by the Navigation and Ancillary Information Facility\n([NAIF](https://naif.jpl.nasa.gov/naif/)) of NASA's Planetary Data System (PDS).\nIt implements most functions of CSPICE in a Python-like way, while also\nsupporting numerous enhancements, including support for Python exceptions,\narray inputs, and aliases.\n\n`cspyce` may be installed by running `pip install cspyce`.\n\nPython versions 3.9 thru 3.12 are currently supported, with pre-built wheels\navailable for Linux, MacOS, and Windows. NumPy 1.x and 2.x are supported.\n\nIf you are looking for information on running or distributing this code from\nthe GitHub sources, look at the file `README-developers.md` in this directory.\n\n## PYTHONIZATION\n\n`cspyce` has been designed to replicate the core features of CSPICE for\nusers who wish to translate a program that already exists. Function names in\n`cspyce` match their CSPICE names.\n\nHowever, it is also designed to behave as much as possible like a normal\nPython module. To that end, it has the following features.\n\n- The C language requires buffers to be allocated for output and it requires\n array sizes to be included for both input and output. The `cspyce` module,\n instead, eliminates all extraneous inputs, and all output arguments are\n returned as a list (or as a single object if the function only returns one\n item).\n\n- `cspyce` has been fully integrated with Python's exception handling;\n programmers can still opt to use CSPICE's error handling mechanism if they\n wish to.\n\n- All `cspyce` functions can handle positional arguments as well as arguments\n passed by name.\n\n- All `cspyce` functions have informative docstrings, so typing\n `help(function)` provides useful information.\n\n- Many `cspyce` functions take sensible default values if input arguments are\n omitted.\n\n- All `cspyce` functions that take filename arguments now support\n [path-like-argument](https://docs.python.org/3/glossary.html#term-path-like-object)s.\n A path-like argument could be a strings, a byte string, or a `pathlib.Path`.\n The [`pathlib.Path`](https://docs.python.org/3/library/pathlib.html) class provides an\n object-oriented class for manipulating file-system paths and performing common operations\n on files.\n\n## ENHANCEMENTS\n\nIn addition, the `cspyce` module takes advantage of features of the Python\nlanguage to provide numerous options about how the functions perform their work.\nThese options include:\n\n- Whether to return a CSPICE-style error condition or to raise a Python\n exception.\n\n- How to handle CSPICE functions that return a status flag, e.g., \"found\" or\n \"ok\", instead of using the CSPICE toolkit's error handling mechanism.\n\n- Whether to allow `cspyce` functions to accept arrays of inputs all at once,\n rather than looping through inputs in Python.\n\n- Whether to automate the translation between SPICE body and frame IDs and their\n associated names.\n\n- Whether to allow `cspyce` to support aliases, in which the same body or frame\n is associated with alternative names or IDs.\n\n---\n## EXCEPTION HANDLING\n\nIn CSPICE, the user can designate what to do in the event of an error condition\nusing the function `erract()`. In CSPICE, the available options are \"RETURN\",\n\"REPORT\", \"IGNORE\", \"ABORT\", and \"DEFAULT\". The `cspyce` version of this\nfunction adds new options \"EXCEPTION\" and \"RUNTIME\" to the suite of error\nhandling options supported by CSPICE.\n\n- As usual, the user can select the exception handling mechanism to use by\n calling the function erract(). In `cspyce`, the default is \"EXCEPTION\".\n\n- When using the \"EXCEPTION\" option, each CSPICE error condition raises a\n Python exception rather than setting the `failed()` flag. The exception\n contains the text of the CSPICE error, in the form (short message + \" -- \" +\n long message). The CSPICE error conditions are mapped to standard Python\n exception types in a sensible way:\n - `KeyError` indicates that a SPICE ID or name is unrecognized.\n - `ValueError` indicates that one of the inputs to a function had an invalid\n value.\n - `TypeError` indicates that one of the inputs to a function had an invalid\n type.\n - `IndexError` indicates that an integer index is out of range.\n - `IOError` indicates errors with reading and writing files, including SPICE\n kernels. IOError can also indicate that needed information was not in one\n of the furnished kernels.\n - `MemoryError` indicates that adequate memory could not be allocated, or\n that the defined size of a memory buffer in C is too small.\n - `ZeroDivisionError` indicates that a divide-by-zero has occurred.\n - `RuntimeError` indicates that an action is incompatible with some aspect\n of the CSPICE module's internal configuration.\n\n- When using one of CSPICE's intrinsic error handling methods, no exception\n will be raised, but a call to `failed()` will reveal whether an error has\n occurred. A call to `reset()` is needed to clear the error.\n\n- Care has been taken to reduce the chances that the \"dangerous\" options\n \"IGNORE\" and \"REPORT\" will cause a segmentation fault. However, this\n possibility cannot be entirely ruled out, so caution is advised.\n\n- Because it would be a highly questionable thing to do, the \"ABORT\" and\n \"DEFAULT\" options are overridden by \"EXCEPTION\" when the user is running\n `cspyce` from an interactive shell. However, they resume their standard\n effects during non-interactive runs.\n\n- When using the \"RUNTIME\" option, each CSPICE error condition raises a\n Python `RuntimeError` exception rather than setting the `failed()` flag. This\n is similar to the \"EXCEPTION\" option except the type of exception is always\n the same.\n\n- Certain out-of-memory conditions are beyond the control of the CSPICE\n library. These will always raise a MemoryError exception, regardless of the\n exception handling method chosen.\n\n### HANDLING OF ERROR FLAGS\n\nMany CSPICE functions bypass the library's own error handling mechanism; instead\nthey return a status flag, sometimes called \"found\" or \"ok\", or perhaps an empty\nresponse to indicate failure. The `cspyce` module provides alternative options\nfor these functions.\n\nWithin `cspyce`, functions that return error flags have an alternative\nimplementation with a suffix of \"_error\", which uses the CSPICE/`cspyce` error\nhandling mechanism detailed above instead.\n\nNote that most `_error` versions of functions have fewer return values than the\nassociated non-error versions. The user should be certain which version is being\nused before interpreting the returned value(s).\n\nThe `cspyce` module provides several ways to control which version of the\nfunction to use:\n\n- The function `use_flags()` takes a function name or list of names and\n designates the original version of each function as the default. If the input\n argument is missing, original versions are selected universally.\n\n- The function `use_errors()` takes a function name or list of names and\n designates the `_error` version of each function as the default. If the input\n argument is missing, `_error` versions are selected universally.\n\nTo provide a more consistent Python interface, the `_error` versions of all\n`cspyce` functions are selected by default. You can also choose between the\n\"flag\" and \"error\" versions of a function using `cspyce` function attributes,\nas discussed below.\n\n---\n## VECTORS AND ARRAYS\n\n### VECTORIZATION\nNearly every function that takes floating-point input (be it a\nscalar, 1-D array, or 2-D array) has a vectorized version that allows you to\npass a vector of these items in place of a single value. The CSPICE function is\ncalled for each of the provided inputs, the results are collected, and the\n`cspyce` function returns a vector of results.\n\n- Vectorized versions have the same name but with `_vector` appended.\n\n- In a vectorized function, you can replace any or all floating-point input\n parameters with an array having one extra leading dimension. Integer, boolean,\n and string inputs cannot be replaced by arrays.\n\n- If no inputs have an extra dimension, then the result is the same as\n calling the original, un-vectorized function.\n\n- Otherwise, all returned quantities are replaced by arrays having the size of\n the largest leading axis.\n\n- Note that it is permissible to pass arrays with different leading axis sizes\n to the function. The vectorized function cycles through the elements of each\n array repeatedly if necessary. It may make sense to do this if each leading\n axis is an integer fraction of the largest axis size. For example, if the\n first input array has size 100 and the second has size 25, then the returned\n arrays(s) will have 100 elements and the values of the second will each be\n used four times. However, caution is advised when using this capability.\n\n- Some functions are not vectorized. These include:\n - Functions that have no floating-point inputs.\n - Functions that include strings among the returned quantities.\n - Functions that already return arrays where the leading axis could be\n variable in size.\n\n- In the two cases (`ckgp` and `ckgpav`) where a function can be both vectorized\n and either raise an error or return a flag, the `_vector` suffix comes\n before `_error`.\n\n### ARRAYS\nAn optional import allows the `cspyce` module to support multidimensional\narrays:\n\n```python\nimport cspyce\nimport cspyce.arrays\n```\n\nThe latter import creates a new function in which the suffix `_array` replaces\n`_vector` for every vectorized function. Whereas `_vector` functions support\nonly a single extra dimension, `_array` functions follow all the standard rules\nof shape broadcasting as defined in NumPy. For example, if one input has leading\ndimension (10,4) and another has dimension (4,), then the two shapes will be\nbroadcasted together and returned quantities will be arrays with shape (10,4).\n\nYou can choose between the scalar, vector, and array versions of a function by\nusing their explicit names, or by using `cspyce` function attributes, as discussed\nbelow.\n\n---\n## ALIASES\n\nAliases allow the user to associate multiple names or SPICE codes with the same\nCSPICE body or frame. Aliases can be used for a variety of purposes.\n\n- You can use names and codes interchangeably as input arguments to any `cspyce`\n function.\n- You can use a body name or code in place of a frame name or code, and the\n primary frame associated with that identified body will be used.\n- Strings that represent integers are equivalent to the integers themselves.\n\nMost importantly, you can allow multiple names or codes to refer to the same\nCSPICE body or frame. For bodies and frames that have multiple names or codes,\ncalls to a `cspyce` function will try each option in sequence until it finds one\nthat works. Options are always tried in the order in which they were defined, so\nhigher-priority names and codes are tried first.\n\nExample 1: Jupiter's moon Dia uses code 553, but it previously used code\n55076. With 55076 defined as an alias for 553, a `cspyce` call will return\ninformation about Dia under either of its codes.\n\nExample 2: The Earth's rotation is, by default, modeled by frame \"IAU_EARTH\".\nHowever, \"ITRF93\" is the name of a much more precise description of Earth's\nrotation. If you define \"IAU_EARTH\" as an alias for \"ITRF93\", then the `cspyce`\ntoolkit will use ITRF93 if it is available, and otherwise IAU_EARTH.\n\nImmediately after a `cspyce` call involving aliases, you can find out what value\nor values were actually used by looking at attributes of the function. For\nexample, the first input to the `cspyce` function `spkez` is called `targ` and\nit identifies the code of a target being observed. After a call to\n\n```python\ncspyce.spkez(553, ...)\n```\nthe value of `cspyce.spkez.targ` will be the code actually used, in this case\neither 553 or 55076.\n\nTo enable aliases, you must import an additional module\n\n```python\nimport cspyce\nimport cspyce.aliases\n```\n\n(Note that `cspyce.aliases` and `cspyce.arrays` can both be imported, and in\neither order. Note also that these are unconventional modules, in that they\nintroduce new functionality into the `cspyce` namespace rather than creating\nnew namespaces called `cspyce.aliases` and `cspyce.arrays`.)\n\nWith this import, a new function is defined for every `cspyce` function that takes\na frame or body as input. The new function has the same name as the pre-existing\n`cspyce` function, but with `_alias` inserted immediately after the original\n`cspyce` name (and before any other suffix such as `_vector` or `_error`).\n\nYou can make alias support the default for individual `cspyce` functions or for\nthe entire `cspyce` module by calling `cspyce.use_aliases()`. These versions\ncan subsequently be disabled as the default by calling `cspyce.use_noaliases()`\n(see more detailed discussion below).\n\nTo define a body alias or frame alias, call\n\n cspyce.define_body_aliases(name_or_code, name_or_code, ...)\n cspyce.define_frame_aliases(name_or_code, name_or_code, ...)\n\nwhere the arguments are an arbitrary list of codes and names.\n\nTo determine the aliases associated with a name or code, call\n\n cspyce.get_body_aliases(name_or_code)\n cspyce.get_frame_aliases(name_or_code)\n\nwhere the argument is either a name or a code.\n\nYou can also select between the alias-supporting and alias-nonsupporting\nversions of a function using function attributes as discussed below.\n\n---\n## FUNCTION NAMES, VERSIONS AND SELECTION METHODS\n\nA `cspyce` function can accumulate several suffixes, based on the particular\nbehavior, as so:\n```python\nbasename[_alias][_vector|_array][_error]\n```\nOnly functions that are truly distinct are defined. For example, if a function\ndoes not have a vector option, then no function will exist containing the\n`_vector` suffix.\n\nYou can use these functions to set defaults:\n\n cspyce.use_flags()\n cspyce.use_errors()\n cspyce.use_scalars()\n cspyce.use_vectors()\n cspyce.use_arrays()\n cspyce.use_aliases()\n cspyce.use_noaliases()\n\nEach function can take one or more arguments referencing specific `cspyce`\nfunctions, in which case the defaults only apply to those functions. If no\narguments are specified, the default applies to all functions. For example,\nto use \"flags\" as the default for all functions except `ckgp`, you could use:\n\n cspyce.use_flags()\n cspyce.use_errors(cspyce.ckgp)\n\n### FUNCTION ATTRIBUTES\n\nFunction attributes provide a simpler mechanism for choosing the needed\nversion of a function, without needing to remember the suffix rules. Every\n`cspyce` function has these attributes, each of which identifies another\n(or possibly the same) `cspyce` function:\n\n| Attribute | Meaning |\n|----------------|------------------------------------------------------------|\n| `func.flag` | the equivalent function without the _error suffix, if any. |\n| `func.error` | the equivalent function with the _error suffix, if any. |\n| `func.scalar` | the equivalent function without _array or _vector suffixes.|\n| `func.vector` | the equivalent function with the _vector suffix, if any. |\n| `func.array` | the equivalent function with the _array suffix, if any. |\n| `func.alias` | the equivalent function with the _alias suffix, if any. |\n| `func.noalias` | the equivalent function without the _alias suffix, if any. |\n\nThese attributes are always defined, even if the particular option is not\nsupported by that function. This saves the programmer the effort of remembering,\nfor example, which functions support aliases or which functions support flags.\n\nThus, if the programmer wishes to be sure they are using the error version of\nfunction `bodn2c`, and wants the vector version if it exists (but it doesn't!),\nthey can call\n\n```python\ncspyce.bodn2c.error.vector(args, ...)\n```\n\n---\n## RECORD ENHANCEMENTS\n\n### SpiceCell\n`cspyce` provides an enhanced version of `SpiceCell` to make it simpler to use for\nboth CSPICE and in Python.\n\nIn the documentation that follows, _active elements_ refer to those elements in the\n`SpiceCell` whose `index` is such that `0 \u2264 index < spice_cell.card`.\n\n#### Constructors\nTo create a `SpiceCell`:\n\n```python\nfrom cspyce import SpiceCell, SPICE_CELL_INT, SPICE_CELL_DOUBLE\nspice_cell = SpiceCell(typeno=SPICE_CELL_INT, size=20)\nspice_cell = SpiceCell(typeno=SPICE_CELL_DOUBLE, size=10)\n```\n\nWith these constructors, `spice_cell.card` will be set to 0 and there will initially be\nno active elements.\n\nIf you already have data that you want to convert to a spice cell, you can use a simpler\ninterface:\n```python\nspice_cell = SpiceCell([1, 2, 3, 4, 5])\nspice_cell = SpiceCell(np.arange(1.0, 10.0))\nspice_cell = SpiceCell(np.arange(1.0, 10.0), size=40) # set size explicitly\n```\nIf you use these constructions, Python will create a `SpiceCell` whose size is a little\nbigger than the length of the given data. The passed first argument will be the active\nelements.\n\nAny CSPICE function that expects a `SpiceCell` as an input can also be passed an array,\na tuple, or anything that can reasonably be converted into an appropriately typed\n`SpiceCell`:\n\nAny CSPICE function that returns a `SpiceCell` as a result takes an optional final\nargument.\n* If this argument is omitted, a `SpiceCell` with a function-specific default capacity\n will be created, and the output will be placed into it.\n* If this argument is a `SpiceCell`, it will be used as the output argument.\n* If this argument is an integer, a `SpiceCell` with that capacity will be created and\n used as the output.\n\nIn all cases, the `SpiceCell` output will also be a return value.\n\n```shell\n>>> import cspyce\n>>> cspyce.wninsd(2.0, 4.9, (1.0, 3.0, 5.0, 7.0, 9.0, 11.0))\n<SpiceCell double 6/12 [ 1. 4.9 5. 7. 9. 11. ]>\n```\n\n#### Sequence-like operations\n\n`SpiceCell` offers the following methods so that they behave like Python sequences.\n\n`spice_cell[index]`, `spice_cell[index] = value`\n\n: Gets or sets the `index`-th element of the `SpiceCell`.\n Must have `-len(spice_cell) \u2264 index < spice_cell.size`. As in Python, we allow\n negative indices, but -1, -2, etc count backwards from the last active elements.\n\n`len(spice_cell)`\n: Returns the number of active elements of `spice_cell`.\n\n`spice_cell.append(value)`\n: If `value` is a float or integer, it is added to the `SpiceCell`'s active cells.\nIf `value` is an array, all of its elements are added to the `SpiceCell`'s active cells.\nThe cell's maximum size is grown if necessary.\n\n`spice_cell.extend(values)`\n: Appends each value in `values` to the end of the `SpiceCell`'s active cells.\nEach element of `values` can be a float, an integer, or an array.\nThe `SpiceCell`'s maximum size is grown if necessary.\n\n`spice_cell += values`\n: Synonym for `spice_cell.extend(values)`\n\n`spice_cell.clear()`\n: Make all elements inactive. Same as `spice_cell.card = 0`.\n\n`iter(spice_cell)`\n: Iterates through the active elements of `spice_cell`.\nBecause of this iterator, `list(spice_cell)`, `set(spice_cell)`, and `tuple(spice_cell)`\nwork as expected.\nYou can also write a for loop `for item in spice_cell: ...` to iterate through\nthe active elements.\n\n`bool(spice_cell)`\n: If a `spice_cell` is used in a boolean context, its value is `False` if all elements\nare inactive (`spice.cell.card == 0`), and `True` otherwise.\n\n#### SpiceCell-specific operations\n\n`SpiceCell` also has the following methods and properties specific to a `SpiceCell`.\n\n`spice_cell.size`\n: Gets the current maximum size of the `SpiceCell`.\n\n`spice_cell.size = value`\n: Grows or shrinks the maximum size of the `SpiceCell`.\nIf the number of active elements is greater than `value`, it is reduced to `value`.\nThis operation is a `cspyce` enhancement that does not exist in CSPICE.\n\n`spice_cell.card`\n: Same as `len(spice_cell)`. (Also known as the \"cardinality\", hence the name).\n\n`spice_cell.card = value`\n: Changes the number of active elements in the `SpiceCell`.\nMust have `0 \u2264 value < spice_cell.size`.\n\n`spice_cell.as_array()`\n: Returns a view of the active contents of the array as a numpy array\n\n`spice_cell.as_intervals()`\n: Returns a view of the active contents of the array as a 2-dimensional `card/2`x 2 array.\nMany `SpiceCell`s are used to represent intervals in which each\npair of numbers represents the lower and upper bounds.\n\nAlthough `cspyce`'s `SpiceCell`s can grow and shrink, CSPICE is not aware of this\ncapability. Its functions will still raise a WINDOWOVERFLOW if `SpiceCell.size` is\nnot large enough to hold the results. The user must increase `SpiceCell.size` and try\nagain.\n\n#### Handling intervals and other structures\n\nAlthough internally, a `SpiceCell` is a flat array of integers or floats,\nsome CSPICE routines treat the contents of a `SpiceCell`\nas if it were a 2-dimensional array.\nFor example, some CSPICE routines expect the `SpiceCell` to contain pairs of values\nwhere each pair represents the limits of an interval.\n\nTo simplify dealing with this use case, the methods `append` and `extend` have been enhanced.\nYou can pass an array or an array-like object to `append`, and all elements of the\narray will be added to the `SpiceCell`.\nLikewise you can pass `extend` a sequence of array-like objects, and all of them will\nbe added to the `SpiceCell`.\n\nSo, for example, you could write:\n```python\nspice_cell.append([10, 20])\nspice_cell.extend([[35, 50], [90, 100], [120, 140]])\n```\nto add intervals to your SpiceCell.\n\nTo view a `SpiceCell` containing intervals, you can use `spice_cell.as_intervals()`\nas described above.\nThis is just a shortcut for `spice_cell.as_array().reshape(-1, 2)`, where\n-1 is a special marker to `reshape` saying \"figure out this value from the size of the\narray and the other dimensions\".\nThe expression `spice_cell.as_array().reshape(-1, 3)` would give an array of triples.\n`self.as_array().reshape(-1, 4, 4)` gives an array of 4x4 matrices.\n",
"bugtrack_url": null,
"license": "Apache-2.0",
"summary": "High-performance Python interface to the NAIF CSPICE library",
"version": "2.3.0",
"project_urls": {
"Homepage": "https://github.com/SETI/rms-cspyce",
"Issues": "https://github.com/SETI/rms-cspyce/issues",
"Repository": "https://github.com/SETI/rms-cspyce",
"Source": "https://github.com/SETI/rms-cspyce"
},
"split_keywords": [
"cspyce",
" spice",
" cspice",
" naif",
" jpl",
" space",
" geometry",
" ephemeris"
],
"urls": [
{
"comment_text": "",
"digests": {
"blake2b_256": "1e59ef1ffb0bf58af2b65b95e2312ea7b93f131564bce4ee80af24154949fe7d",
"md5": "c6ab6de7f516272fc0761bb69b51330e",
"sha256": "6691f77243ebf11370048ae414b8b7dee317c23a66e6cd3dc5aef11a5f1e57fe"
},
"downloads": -1,
"filename": "cspyce-2.3.0-cp310-cp310-macosx_10_9_x86_64.whl",
"has_sig": false,
"md5_digest": "c6ab6de7f516272fc0761bb69b51330e",
"packagetype": "bdist_wheel",
"python_version": "cp310",
"requires_python": ">=3.9",
"size": 2050506,
"upload_time": "2024-06-19T02:16:26",
"upload_time_iso_8601": "2024-06-19T02:16:26.546180Z",
"url": "https://files.pythonhosted.org/packages/1e/59/ef1ffb0bf58af2b65b95e2312ea7b93f131564bce4ee80af24154949fe7d/cspyce-2.3.0-cp310-cp310-macosx_10_9_x86_64.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "ed2d23cf0e7f8ebffccf5526bd382bbdad76fb1eb96356a4489bd76c643cfa4f",
"md5": "81a86ef4f2758a2e7b6d09ab2e19cb8f",
"sha256": "05e0a9dd9d0bd64128762426dff2835c73f8c5d229da239876e6ed48a8355a2b"
},
"downloads": -1,
"filename": "cspyce-2.3.0-cp310-cp310-macosx_11_0_arm64.whl",
"has_sig": false,
"md5_digest": "81a86ef4f2758a2e7b6d09ab2e19cb8f",
"packagetype": "bdist_wheel",
"python_version": "cp310",
"requires_python": ">=3.9",
"size": 1828678,
"upload_time": "2024-06-19T02:16:34",
"upload_time_iso_8601": "2024-06-19T02:16:34.506328Z",
"url": "https://files.pythonhosted.org/packages/ed/2d/23cf0e7f8ebffccf5526bd382bbdad76fb1eb96356a4489bd76c643cfa4f/cspyce-2.3.0-cp310-cp310-macosx_11_0_arm64.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "8755859dee80f71a64f5f3df4a7fad6a62b6716f03d063bb5d9fcb90d5d84ca2",
"md5": "d84f48e95c3e6ff9f5a25ef24da581cf",
"sha256": "3bc799cb0802b8f2e3b976143808ea523849b2622edcc6bc790cd02ea490b907"
},
"downloads": -1,
"filename": "cspyce-2.3.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl",
"has_sig": false,
"md5_digest": "d84f48e95c3e6ff9f5a25ef24da581cf",
"packagetype": "bdist_wheel",
"python_version": "cp310",
"requires_python": ">=3.9",
"size": 6468028,
"upload_time": "2024-06-19T02:16:37",
"upload_time_iso_8601": "2024-06-19T02:16:37.662337Z",
"url": "https://files.pythonhosted.org/packages/87/55/859dee80f71a64f5f3df4a7fad6a62b6716f03d063bb5d9fcb90d5d84ca2/cspyce-2.3.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "26fa980f2d5656d1b61f4ff584a71f2b3c8ab1609cb26d75c7ccabf6edc54b3f",
"md5": "b38a21b5119cd982c2f5f1c112f2a51f",
"sha256": "88c3490fba6a3525284043940c0719f5f698b348b2bb70dedde77482d16778af"
},
"downloads": -1,
"filename": "cspyce-2.3.0-cp310-cp310-win_amd64.whl",
"has_sig": false,
"md5_digest": "b38a21b5119cd982c2f5f1c112f2a51f",
"packagetype": "bdist_wheel",
"python_version": "cp310",
"requires_python": ">=3.9",
"size": 1826492,
"upload_time": "2024-06-19T02:16:42",
"upload_time_iso_8601": "2024-06-19T02:16:42.977460Z",
"url": "https://files.pythonhosted.org/packages/26/fa/980f2d5656d1b61f4ff584a71f2b3c8ab1609cb26d75c7ccabf6edc54b3f/cspyce-2.3.0-cp310-cp310-win_amd64.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "a45259429693876847bd8598d8e499036fd47787877f5278884ff8f7ed6bf09a",
"md5": "8a35f219a64ed7671fe6b948241287f4",
"sha256": "178f355a5d230eda7937b48b770138aeeec71975f0212857658d53fdf4ae4d71"
},
"downloads": -1,
"filename": "cspyce-2.3.0-cp311-cp311-macosx_10_9_x86_64.whl",
"has_sig": false,
"md5_digest": "8a35f219a64ed7671fe6b948241287f4",
"packagetype": "bdist_wheel",
"python_version": "cp311",
"requires_python": ">=3.9",
"size": 2050510,
"upload_time": "2024-06-19T02:16:51",
"upload_time_iso_8601": "2024-06-19T02:16:51.941471Z",
"url": "https://files.pythonhosted.org/packages/a4/52/59429693876847bd8598d8e499036fd47787877f5278884ff8f7ed6bf09a/cspyce-2.3.0-cp311-cp311-macosx_10_9_x86_64.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "61223d87df1fb0a4380cb29306034b8b3a92ebd9fb82e1bdb03288e5b4e45564",
"md5": "c40dc108b6f8b9d3a0dc72ebea1ca248",
"sha256": "335d813cdb02e3c41b6ff57b9727023b7d5cb0c78baceb47cc2fc97d5a120a1e"
},
"downloads": -1,
"filename": "cspyce-2.3.0-cp311-cp311-macosx_11_0_arm64.whl",
"has_sig": false,
"md5_digest": "c40dc108b6f8b9d3a0dc72ebea1ca248",
"packagetype": "bdist_wheel",
"python_version": "cp311",
"requires_python": ">=3.9",
"size": 1828680,
"upload_time": "2024-06-19T02:16:56",
"upload_time_iso_8601": "2024-06-19T02:16:56.837715Z",
"url": "https://files.pythonhosted.org/packages/61/22/3d87df1fb0a4380cb29306034b8b3a92ebd9fb82e1bdb03288e5b4e45564/cspyce-2.3.0-cp311-cp311-macosx_11_0_arm64.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "f2de319424812136b58ba16ae321c021fcb15abe1814cf0a803a08acf72bf9c2",
"md5": "0725f1a2bdbbe7fe47dddd197d11871d",
"sha256": "68b314b3f32d6a66852703eb6e11ee1740c3dc871cf49047705b78c31286af41"
},
"downloads": -1,
"filename": "cspyce-2.3.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl",
"has_sig": false,
"md5_digest": "0725f1a2bdbbe7fe47dddd197d11871d",
"packagetype": "bdist_wheel",
"python_version": "cp311",
"requires_python": ">=3.9",
"size": 6589657,
"upload_time": "2024-06-19T02:17:02",
"upload_time_iso_8601": "2024-06-19T02:17:02.536313Z",
"url": "https://files.pythonhosted.org/packages/f2/de/319424812136b58ba16ae321c021fcb15abe1814cf0a803a08acf72bf9c2/cspyce-2.3.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "3e3519aac05a647ae1abe5830224ecea7e6446e8a5d87bc6c3d7c02ca239d416",
"md5": "f05ac3a1d9959ec6e757490a27ae5b7e",
"sha256": "65c97cc0a6f2ce3a1b439a19808cfb6d9884422e3ab47bf238f1fe5f6d31bec8"
},
"downloads": -1,
"filename": "cspyce-2.3.0-cp311-cp311-win_amd64.whl",
"has_sig": false,
"md5_digest": "f05ac3a1d9959ec6e757490a27ae5b7e",
"packagetype": "bdist_wheel",
"python_version": "cp311",
"requires_python": ">=3.9",
"size": 1826502,
"upload_time": "2024-06-19T02:17:07",
"upload_time_iso_8601": "2024-06-19T02:17:07.448543Z",
"url": "https://files.pythonhosted.org/packages/3e/35/19aac05a647ae1abe5830224ecea7e6446e8a5d87bc6c3d7c02ca239d416/cspyce-2.3.0-cp311-cp311-win_amd64.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "ea9512c46f3d69be15d77412aa1ed2857a1beceea9cd60e36d41c09a00933457",
"md5": "13b6996af26555f8cf1aebc872551d27",
"sha256": "fa051f2ee5267bd4c23a218e0baa89317179cbcfd062a28286924cc912cce81b"
},
"downloads": -1,
"filename": "cspyce-2.3.0-cp312-cp312-macosx_10_9_x86_64.whl",
"has_sig": false,
"md5_digest": "13b6996af26555f8cf1aebc872551d27",
"packagetype": "bdist_wheel",
"python_version": "cp312",
"requires_python": ">=3.9",
"size": 2048967,
"upload_time": "2024-06-19T02:17:12",
"upload_time_iso_8601": "2024-06-19T02:17:12.091656Z",
"url": "https://files.pythonhosted.org/packages/ea/95/12c46f3d69be15d77412aa1ed2857a1beceea9cd60e36d41c09a00933457/cspyce-2.3.0-cp312-cp312-macosx_10_9_x86_64.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "1e8d54701ad18c1e83fee5a3002f0dc9b5724e49ed3d709994f3de6ae7a41d09",
"md5": "f7ba09bc90cc4d0f956822a4003e7abb",
"sha256": "04a975401d6255189af3beba13f7646fdba53c1a0b42ab613c94da245035f4e2"
},
"downloads": -1,
"filename": "cspyce-2.3.0-cp312-cp312-macosx_11_0_arm64.whl",
"has_sig": false,
"md5_digest": "f7ba09bc90cc4d0f956822a4003e7abb",
"packagetype": "bdist_wheel",
"python_version": "cp312",
"requires_python": ">=3.9",
"size": 1818593,
"upload_time": "2024-06-19T02:17:20",
"upload_time_iso_8601": "2024-06-19T02:17:20.995604Z",
"url": "https://files.pythonhosted.org/packages/1e/8d/54701ad18c1e83fee5a3002f0dc9b5724e49ed3d709994f3de6ae7a41d09/cspyce-2.3.0-cp312-cp312-macosx_11_0_arm64.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "dc6b6178c86192c9e66808a77c6b39a5aa5726a1cd6226258ee2deb5eb9070fd",
"md5": "a19094528ce084708e60af9f8b26e2a4",
"sha256": "ac0b7f6c166be5758423d211c3cc762c32c613489e1215cb8e8e05a8e89aced9"
},
"downloads": -1,
"filename": "cspyce-2.3.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl",
"has_sig": false,
"md5_digest": "a19094528ce084708e60af9f8b26e2a4",
"packagetype": "bdist_wheel",
"python_version": "cp312",
"requires_python": ">=3.9",
"size": 6517906,
"upload_time": "2024-06-19T02:17:24",
"upload_time_iso_8601": "2024-06-19T02:17:24.059909Z",
"url": "https://files.pythonhosted.org/packages/dc/6b/6178c86192c9e66808a77c6b39a5aa5726a1cd6226258ee2deb5eb9070fd/cspyce-2.3.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "b2cb6a14c6a659fa04f76239d3a4ed454def091605dcf01f083f21d11b57ca27",
"md5": "6aa7c3cdd595e0366c3e48206f64152d",
"sha256": "9076caaf26260fc1ce1b4ccfd50add85cecedd2d4b30975c87d7f759e9325ec9"
},
"downloads": -1,
"filename": "cspyce-2.3.0-cp312-cp312-win_amd64.whl",
"has_sig": false,
"md5_digest": "6aa7c3cdd595e0366c3e48206f64152d",
"packagetype": "bdist_wheel",
"python_version": "cp312",
"requires_python": ">=3.9",
"size": 1831450,
"upload_time": "2024-06-19T02:17:28",
"upload_time_iso_8601": "2024-06-19T02:17:28.262008Z",
"url": "https://files.pythonhosted.org/packages/b2/cb/6a14c6a659fa04f76239d3a4ed454def091605dcf01f083f21d11b57ca27/cspyce-2.3.0-cp312-cp312-win_amd64.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "74005d6b40292a51abce6b06d47c41789d4b10424efdab83306956337afc0fb7",
"md5": "0a8fa975b76d90b6308e29986bcf1184",
"sha256": "7d4a1354960bb2d62ef113238a5be06a009c5173da18c8cfff3ceb5a24bb0d82"
},
"downloads": -1,
"filename": "cspyce-2.3.0-cp39-cp39-macosx_10_9_x86_64.whl",
"has_sig": false,
"md5_digest": "0a8fa975b76d90b6308e29986bcf1184",
"packagetype": "bdist_wheel",
"python_version": "cp39",
"requires_python": ">=3.9",
"size": 2050443,
"upload_time": "2024-06-19T02:17:32",
"upload_time_iso_8601": "2024-06-19T02:17:32.172156Z",
"url": "https://files.pythonhosted.org/packages/74/00/5d6b40292a51abce6b06d47c41789d4b10424efdab83306956337afc0fb7/cspyce-2.3.0-cp39-cp39-macosx_10_9_x86_64.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "6867a5044d1a3be08daa016d8fce87cf8e72ab88ac02b7e117e726ffff852851",
"md5": "0f40a2c3c68c935a611ac45c3c21f71a",
"sha256": "a1bc90496aa1edab648b4b806ca61afbb84a0a24102cec017ceed197cc5fdd58"
},
"downloads": -1,
"filename": "cspyce-2.3.0-cp39-cp39-macosx_11_0_arm64.whl",
"has_sig": false,
"md5_digest": "0f40a2c3c68c935a611ac45c3c21f71a",
"packagetype": "bdist_wheel",
"python_version": "cp39",
"requires_python": ">=3.9",
"size": 1828462,
"upload_time": "2024-06-19T02:17:42",
"upload_time_iso_8601": "2024-06-19T02:17:42.955150Z",
"url": "https://files.pythonhosted.org/packages/68/67/a5044d1a3be08daa016d8fce87cf8e72ab88ac02b7e117e726ffff852851/cspyce-2.3.0-cp39-cp39-macosx_11_0_arm64.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "420855dc0cfec755a4835e0b60495eaefcf58e9048b2373f9eb3cca9a61e259a",
"md5": "0d32baa3ee2751020900b9dd3bb00bac",
"sha256": "15389c02c51d2f21d9cbf53c27e61e530127bc6f60406bfeb0ef83ed0698daa0"
},
"downloads": -1,
"filename": "cspyce-2.3.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl",
"has_sig": false,
"md5_digest": "0d32baa3ee2751020900b9dd3bb00bac",
"packagetype": "bdist_wheel",
"python_version": "cp39",
"requires_python": ">=3.9",
"size": 6466142,
"upload_time": "2024-06-19T02:17:46",
"upload_time_iso_8601": "2024-06-19T02:17:46.742144Z",
"url": "https://files.pythonhosted.org/packages/42/08/55dc0cfec755a4835e0b60495eaefcf58e9048b2373f9eb3cca9a61e259a/cspyce-2.3.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "797c80a9a047946823217de0bc6fca8d33169891d78c82310153525bdb237d6d",
"md5": "6200edc13287e72994e3cab58e730868",
"sha256": "2e8ad24ef428b34888a43661d2d82608c1c1368ce1324520a4e0d93762a99124"
},
"downloads": -1,
"filename": "cspyce-2.3.0-cp39-cp39-win_amd64.whl",
"has_sig": false,
"md5_digest": "6200edc13287e72994e3cab58e730868",
"packagetype": "bdist_wheel",
"python_version": "cp39",
"requires_python": ">=3.9",
"size": 1825278,
"upload_time": "2024-06-19T02:17:51",
"upload_time_iso_8601": "2024-06-19T02:17:51.874674Z",
"url": "https://files.pythonhosted.org/packages/79/7c/80a9a047946823217de0bc6fca8d33169891d78c82310153525bdb237d6d/cspyce-2.3.0-cp39-cp39-win_amd64.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "1ee898bd184ceed07f4d403b676dfe03874d12f2fdf423632bfac5abd9e196c3",
"md5": "e9fa19ee81715074c8ea0f821ab3fdc3",
"sha256": "b51b7d9da1f8138ed61483f0a80c82d6a7c3066f7b9d1ddcf25fc1300ea31c03"
},
"downloads": -1,
"filename": "cspyce-2.3.0.tar.gz",
"has_sig": false,
"md5_digest": "e9fa19ee81715074c8ea0f821ab3fdc3",
"packagetype": "sdist",
"python_version": "source",
"requires_python": ">=3.9",
"size": 59418164,
"upload_time": "2024-06-19T02:17:57",
"upload_time_iso_8601": "2024-06-19T02:17:57.143962Z",
"url": "https://files.pythonhosted.org/packages/1e/e8/98bd184ceed07f4d403b676dfe03874d12f2fdf423632bfac5abd9e196c3/cspyce-2.3.0.tar.gz",
"yanked": false,
"yanked_reason": null
}
],
"upload_time": "2024-06-19 02:17:57",
"github": true,
"gitlab": false,
"bitbucket": false,
"codeberg": false,
"github_user": "SETI",
"github_project": "rms-cspyce",
"travis_ci": false,
"coveralls": true,
"github_actions": true,
"requirements": [],
"lcname": "cspyce"
}
JSON
