| Name | numericalunits JSON |
| Version |
1.26
JSON |
| download |
| home_page | None |
| Summary | A package that lets you define quantities with units, which can then be used in almost any numerical calculation in any programming language. Checks that calculations pass dimensional analysis, performs unit conversions, and defines physical constants. |
| upload_time | 2024-11-26 18:02:53 |
| maintainer | None |
| docs_url | None |
| author | None |
| requires_python | >=3 |
| license | MIT |
| keywords |
units
quantities
physical constants
dimensional analysis
|
| VCS |
 |
| bugtrack_url |
|
| requirements |
No requirements were recorded.
|
| Travis-CI |
No Travis.
|
| coveralls test coverage |
No coveralls.
|
=========================================================================
numericalunits: Units and dimensional analysis compatible with everything
=========================================================================
`Package homepage at PyPI <http://pypi.python.org/pypi/numericalunits>`_ --
`Source code at github <http://github.com/sbyrnes321/numericalunits>`_ --
Written by `Steve Byrnes <http://sjbyrnes.com>`_
This package implements units and dimensional analysis in an unconventional
way that has the following unique advantages:
* **Compatible with everything:** Compatible with virtually any numerical
calculation routine, including numpy and scipy, and even including routines
not written in Python! That means, for example, if you have a decades-old
closed-source C routine for numerical integration, you can pass it a
quantity with units of velocity and an integration range with units of
time, and the final answer will magically have units of distance. This
extreme compatibility is possible because if the variable ``x`` represents
a quantity with dimensions (like "3.3 kg"), ``x`` is actually stored
internally as an ordinary floating-point number. The dimension is
encoded in the value as a multiplicative factor. When two numbers are
multiplied, their dimensions are automatically multiplied, and so on.
* **Modular and non-intrusive:** When you input data, you say what units
they are in. When you display results, you say what units you want to
display them in. These steps are very little trouble, and in fact help you
create nice, self-documenting code. Other than that, you have to do nothing
at all to pass dimensionful quantities into and out of any already-written
programs or routines.
* **Powerful tool for debugging:** Not *all* calculation mistakes cause
violations of dimensional analysis, but *most* do--for example, if you
accidentally multiply two lengths instead of adding them, the result will
have the wrong dimension. If you use this package, it will alert you to
these sorts of mistakes.
* **Zero storage overhead**
* **Zero calculation overhead**
These great features come with the disadvantage that the interface is less
*slick* than other unit packages. If you have a quantity with units, you
cannot directly see what the units are. You are supposed to already know
what the units are, and then the package will tell you whether you made a
mistake. Even worse, you only get alerted to the mistake after running a
calculation all the way through twice.
Therefore the package is *not* suggested for students exploring how units work.
It *is* suggested for engineering and science professionals who want to make
their code more self-documenting and self-debugging.
Installation
============
You can install from PyPI: ::
pip install numericalunits
Alternatively---since it's a single module that requires no setup or
compilation---you can download ``numericalunits.py`` from `PyPI
<http://pypi.python.org/pypi/numericalunits>`_ or `github
<http://github.com/sbyrnes321/numericalunits>`_ and use it directly.
Usage and examples
==================
To assign a unit to a quantity, **multiply** by the unit, e.g.
``my_length = 100 * mm``. (In normal text you would write "100 mm", but
unfortunately Python does not have "implied multiplication".)
To express a dimensionful quantity in a certain unit, **divide** by that unit,
e.g. when you see ``my_length / cm``, you pronounce it "my_length expressed
in cm".
Unit errors, like trying to add a length to a mass, will not *immediately*
announce themselves as unit errors. Instead, you need to run the whole
calculation twice (in a new Python session each time). If you get the
same final answers both times, then congratulations, all your calculations
are almost guaranteed to pass dimensional analysis! If you get different
answers every time you run, then you made a unit error! It is up to you to
figure out where and what the error is.
**Example 1:** What is 5 mL expressed in cubic nanometers?::
from numericalunits import mL, nm
x = 5 * mL # "Read: x is equal to 5 milliliters"
print(x / nm**3) # "Read: x expressed in cubic nanometers is..." --> 5e21
**Example 2:** An electron is in a 1e5 V/cm electric field. What is its
acceleration? (Express the answer in m/s².) ::
from numericalunits import V, cm, e, me, m, s
Efield = 1e5 * (V / cm)
force = e * Efield # (e is the elementary charge)
accel = force / me # (me is the electron mass)
print(accel / (m / s**2)) # Answer --> 1.7588e18
**Example 3:** You measured a voltage as a function of the position of dial:
10 volts when the dial is at 1cm, 11 volts when the dial is at 2cm, etc.
etc. Interpolate from this data to get the expected voltage when the dial is
at 41mm, and express the answer in mV. ::
from numericalunits import cm, V, mm, mV
from numpy import array
from scipy.interpolate import interp1d
voltage_data = array([[1 * cm, 10 * V],
[2 * cm, 11 * V],
[3 * cm, 13 * V],
[4 * cm, 16 * V],
[5 * cm, 18 * V]])
f = interp1d(voltage_data[:,0], voltage_data[:,1])
print(f(41 * mm) / mV) # Answer --> 16200
**Example 4:** A unit mistake ... what is 1 cm expressed in atmospheres? ::
from numericalunits import cm, atm
print((1 * cm) / atm) # --> a randomly-varying number
# The answer randomly varies every time you run this (in a new Python
# session), indicating that you are violating dimensional analysis.
How it works
============
A complete set of independent base units (meters, kilograms, seconds,
coulombs, kelvins) are defined as randomly-chosen positive floating-point
numbers. All other units and constants are defined in terms of those. In a
dimensionally-correct calculation, the units all cancel out, so the final
answer is deterministic, not random. In a dimensionally-incorrect
calculations, there will be random factors causing a randomly-varying final
answer.
Included units and constants
============================
Includes a variety of common units, both SI and non-SI, everything from
frequency to magnetic flux. Also includes common physical constants like
Planck's constant and the speed of light. Browse the source code to see a
complete list. It is very easy to add in any extra units and constants that
were left out.
Notes
=====
Notes on implementation and use
-------------------------------
* **What does it mean to "run the calculation again in a new Python
session?"** You know that you've started a new Python session if all
the variable definitions have been forgotten. Three examples: In Spyder, each "Console"
tab is its own session. In Jupyter, make a new Python session by selecting
"Restart kernel". From the command line, each time you type
``python blah.py``, you are opening a new Python session.
* For little, self-contained calculations (a few lines that are all within a
single module), it is possible to check the units without opening a new Python
session: Run the function ``numericalunits.reset_units()`` at the beginning of
the calculation before any variables are defined; then check for
dimensional errors by re-running the whole calculation (including the
``reset_units()`` part). Note that if you are using ``from``-style imports,
like ``from numericalunits import cm``, you need to put them *after*
``reset_units()`` in the code.
* While debugging a program, it may be annoying to have intermediate values
in the calculation that randomly vary every time you run the program. In
this case, you can use ``reset_units('SI')`` instead of the normal
``reset_units()``. This puts all dimensionful variables in standard (MKS)
SI units: All times are in seconds, all lengths are in meters, all forces
are in newtons, etc. Alternatively, ``reset_units(123)`` uses ``123`` as
the seed for the random-number generator. Obviously, in these modes, you
will *not* get any indication of dimensional-analysis errors. As above,
if you are going to use any version of ``reset_units()``, make sure you do
it before any dimensionful variable is defined in any module.
* If you have a quantity you want to plot, store, pass between different
parallel processes, etc., make sure you first express it in a known unit.
(e.g. "energy expressed in joules" can be passed between processses, but
"energy" cannot.) For parallel processing in particular, see `README appendix <https://github.com/sbyrnes321/numericalunits/blob/master/README_appendix.rst>`_
for different ways of using the package, with example code.
* There are very rare, strange cases where the final answer does not seem to
randomly vary even though there was a dimensional-analysis violation: For
example, the expression ``(1 + 1e-50 * cm / atm)`` fails dimensional
analysis, so if you calculate it the answer is randomly-varying. But, it is
only randomly varying around the 50th decimal point, so the variation is
hidden from view. You would not notice it as an error.
* Since units are normal Python ``float``-type numbers, they follow the normal
casting rules. For example, ``2 * cm`` is a python ``float``, not an ``int``.
This is usually what you would want and expect.
* You can give a dimension to complex numbers in the same way as real
numbers--for example ``(2.1e3 + 3.9e4j) * ohm``.
* Requires Python 3. (For Python 2 compatibility, install numericalunits
version 1.23 or earlier.)
* If you find bugs, please tell me by `email <http://sjbyrnes.com>`_ or
`github issue board <https://github.com/sbyrnes321/numericalunits/issues>`_.
* If you get overflows or underflows, you can edit the unit initializations.
For example, the package sets the meter to a random numerical value between 0.1
and 10. Therefore, if you're doing molecular simulation, most lengths you
use will be tiny numbers. You should probably set the meter instead to be
between, say, a random numerical value between 1e8 and 1e10.
* Some numerical routines use a default *absolute* tolerance, rather than
relative tolerance, to decide convergence. This can cause the calculation
result to randomly vary even though there is no dimensional analysis error.
When this happens, you should set the absolute tolerance to a value with the
appropriate units. Alternatively, you can scale the data before running the
algorithm and scale it back afterwards. Maybe this sounds like a hassle, but
it's actually a benefit: If your final result is very sensitive to some
numerical tolerance setting, then you really want to be aware of that.
Notes on unit definitions
-------------------------
* For electromagnetism, all units are intended for use in SI formulas. If
you plug them into cgs-gaussian electromagnetism formulas, or cgs-esu
electromagnetism formulas, etc., you will get nonsense results.
* The package does not keep track of "radians" as an independent unit
assigned a random number. The reason is that the "radians" factor does not
always neatly cancel out of formulas.
* The package does not keep track of "moles" as an independent unit assigned
a random number; instead ``mol`` is just a pure number (~6e23), like you
would say "dozen"=12. That means: (1) gram/mol is exactly the same as amu,
and Boltzmann constant is exactly the same as the ideal gas constant, and so
on. (2) You should rarely need to use Avogadro's number ``NA`` -- it is just a
synonym of ``mol`` (``NA = mol ~ 6e23``). Here are a few examples using moles: ::
from numericalunits import um, uM, kcal, mol, fmol, J
# There are eight copies of a protein inside a yeast nucleus of volume
# 3 cubic microns. What is the concentration of the protein, in micromolar (uM)?
print((8 / (3 * um**3)) / uM) # Answer --> 0.0044
# 5 kcal / mol is how many joules?
print((5 * kcal / mol) / J) # Answer --> 3.47e-20
# How many molecules are in 2.3 femtomoles?
print(2.3 * fmol) # Answer --> 1.39e9
* The package cannot convert temperatures between Fahrenheit, Celsius, and
kelvin. The reason is that these scales have different zeros, so the units
cannot be treated as multiplicative factors. It is, however, possible to
convert temperature *intervals*, via the units ``degCinterval`` (which is a
synonym of kelvin, ``K``) and ``degFinterval``.
Raw data
{
"_id": null,
"home_page": null,
"name": "numericalunits",
"maintainer": null,
"docs_url": null,
"requires_python": ">=3",
"maintainer_email": null,
"keywords": "units, quantities, physical constants, dimensional analysis",
"author": null,
"author_email": "Steven Byrnes <steven.byrnes@gmail.com>",
"download_url": "https://files.pythonhosted.org/packages/63/f3/f52ab9234b9dc057729a03f1b84dd7ad51b3a4ef018e68a44d563e880556/numericalunits-1.26.tar.gz",
"platform": null,
"description": "=========================================================================\r\nnumericalunits: Units and dimensional analysis compatible with everything\r\n=========================================================================\r\n\r\n`Package homepage at PyPI <http://pypi.python.org/pypi/numericalunits>`_ -- \r\n`Source code at github <http://github.com/sbyrnes321/numericalunits>`_ -- \r\nWritten by `Steve Byrnes <http://sjbyrnes.com>`_\r\n\r\nThis package implements units and dimensional analysis in an unconventional \r\nway that has the following unique advantages:\r\n\r\n* **Compatible with everything:** Compatible with virtually any numerical \r\n calculation routine, including numpy and scipy, and even including routines \r\n not written in Python! That means, for example, if you have a decades-old \r\n closed-source C routine for numerical integration, you can pass it a \r\n quantity with units of velocity and an integration range with units of \r\n time, and the final answer will magically have units of distance. This \r\n extreme compatibility is possible because if the variable ``x`` represents \r\n a quantity with dimensions (like \"3.3 kg\"), ``x`` is actually stored \r\n internally as an ordinary floating-point number. The dimension is \r\n encoded in the value as a multiplicative factor. When two numbers are \r\n multiplied, their dimensions are automatically multiplied, and so on. \r\n\r\n\r\n* **Modular and non-intrusive:** When you input data, you say what units \r\n they are in. When you display results, you say what units you want to \r\n display them in. These steps are very little trouble, and in fact help you \r\n create nice, self-documenting code. Other than that, you have to do nothing \r\n at all to pass dimensionful quantities into and out of any already-written \r\n programs or routines.\r\n\r\n* **Powerful tool for debugging:** Not *all* calculation mistakes cause \r\n violations of dimensional analysis, but *most* do--for example, if you \r\n accidentally multiply two lengths instead of adding them, the result will \r\n have the wrong dimension. If you use this package, it will alert you to \r\n these sorts of mistakes.\r\n\r\n* **Zero storage overhead**\r\n\r\n* **Zero calculation overhead**\r\n\r\nThese great features come with the disadvantage that the interface is less \r\n*slick* than other unit packages. If you have a quantity with units, you \r\ncannot directly see what the units are. You are supposed to already know \r\nwhat the units are, and then the package will tell you whether you made a \r\nmistake. Even worse, you only get alerted to the mistake after running a \r\ncalculation all the way through twice.\r\n\r\nTherefore the package is *not* suggested for students exploring how units work.\r\nIt *is* suggested for engineering and science professionals who want to make\r\ntheir code more self-documenting and self-debugging.\r\n\r\nInstallation\r\n============\r\n\r\nYou can install from PyPI: ::\r\n\r\n pip install numericalunits\r\n\r\nAlternatively---since it's a single module that requires no setup or \r\ncompilation---you can download ``numericalunits.py`` from `PyPI \r\n<http://pypi.python.org/pypi/numericalunits>`_ or `github \r\n<http://github.com/sbyrnes321/numericalunits>`_ and use it directly.\r\n\r\nUsage and examples\r\n==================\r\n\r\nTo assign a unit to a quantity, **multiply** by the unit, e.g.\r\n``my_length = 100 * mm``. (In normal text you would write \"100 mm\", but\r\nunfortunately Python does not have \"implied multiplication\".)\r\n\r\nTo express a dimensionful quantity in a certain unit, **divide** by that unit,\r\ne.g. when you see ``my_length / cm``, you pronounce it \"my_length expressed\r\nin cm\".\r\n\r\nUnit errors, like trying to add a length to a mass, will not *immediately*\r\nannounce themselves as unit errors. Instead, you need to run the whole\r\ncalculation twice (in a new Python session each time). If you get the\r\nsame final answers both times, then congratulations, all your calculations\r\nare almost guaranteed to pass dimensional analysis! If you get different\r\nanswers every time you run, then you made a unit error! It is up to you to\r\nfigure out where and what the error is.\r\n\r\n**Example 1:** What is 5 mL expressed in cubic nanometers?::\r\n\r\n from numericalunits import mL, nm\r\n x = 5 * mL # \"Read: x is equal to 5 milliliters\"\r\n print(x / nm**3) # \"Read: x expressed in cubic nanometers is...\" --> 5e21\r\n\r\n**Example 2:** An electron is in a 1e5 V/cm electric field. What is its\r\nacceleration? (Express the answer in m/s\u00b2.) ::\r\n\r\n from numericalunits import V, cm, e, me, m, s\r\n Efield = 1e5 * (V / cm)\r\n force = e * Efield # (e is the elementary charge)\r\n accel = force / me # (me is the electron mass)\r\n print(accel / (m / s**2)) # Answer --> 1.7588e18\r\n\r\n**Example 3:** You measured a voltage as a function of the position of dial: \r\n10 volts when the dial is at 1cm, 11 volts when the dial is at 2cm, etc. \r\netc. Interpolate from this data to get the expected voltage when the dial is \r\nat 41mm, and express the answer in mV. ::\r\n\r\n from numericalunits import cm, V, mm, mV\r\n from numpy import array\r\n from scipy.interpolate import interp1d\r\n voltage_data = array([[1 * cm, 10 * V],\r\n [2 * cm, 11 * V],\r\n [3 * cm, 13 * V],\r\n [4 * cm, 16 * V],\r\n [5 * cm, 18 * V]])\r\n f = interp1d(voltage_data[:,0], voltage_data[:,1])\r\n print(f(41 * mm) / mV) # Answer --> 16200\r\n\t\r\n\r\n**Example 4:** A unit mistake ... what is 1 cm expressed in atmospheres? ::\r\n\r\n from numericalunits import cm, atm\r\n print((1 * cm) / atm) # --> a randomly-varying number\r\n # The answer randomly varies every time you run this (in a new Python\r\n # session), indicating that you are violating dimensional analysis.\r\n\r\nHow it works\r\n============\r\n\r\nA complete set of independent base units (meters, kilograms, seconds, \r\ncoulombs, kelvins) are defined as randomly-chosen positive floating-point \r\nnumbers. All other units and constants are defined in terms of those. In a \r\ndimensionally-correct calculation, the units all cancel out, so the final \r\nanswer is deterministic, not random. In a dimensionally-incorrect \r\ncalculations, there will be random factors causing a randomly-varying final \r\nanswer.\r\n\r\nIncluded units and constants\r\n============================\r\n\r\nIncludes a variety of common units, both SI and non-SI, everything from \r\nfrequency to magnetic flux. Also includes common physical constants like \r\nPlanck's constant and the speed of light. Browse the source code to see a \r\ncomplete list. It is very easy to add in any extra units and constants that\r\nwere left out.\r\n\r\nNotes\r\n=====\r\n\r\nNotes on implementation and use\r\n-------------------------------\r\n\r\n* **What does it mean to \"run the calculation again in a new Python\r\n session?\"** You know that you've started a new Python session if all\r\n the variable definitions have been forgotten. Three examples: In Spyder, each \"Console\"\r\n tab is its own session. In Jupyter, make a new Python session by selecting\r\n \"Restart kernel\". From the command line, each time you type\r\n ``python blah.py``, you are opening a new Python session. \r\n\r\n* For little, self-contained calculations (a few lines that are all within a\r\n single module), it is possible to check the units without opening a new Python\r\n session: Run the function ``numericalunits.reset_units()`` at the beginning of\r\n the calculation before any variables are defined; then check for\r\n dimensional errors by re-running the whole calculation (including the\r\n ``reset_units()`` part). Note that if you are using ``from``-style imports,\r\n like ``from numericalunits import cm``, you need to put them *after*\r\n ``reset_units()`` in the code.\r\n\r\n* While debugging a program, it may be annoying to have intermediate values \r\n in the calculation that randomly vary every time you run the program. In \r\n this case, you can use ``reset_units('SI')`` instead of the normal \r\n ``reset_units()``. This puts all dimensionful variables in standard (MKS)\r\n SI units: All times are in seconds, all lengths are in meters, all forces\r\n are in newtons, etc. Alternatively, ``reset_units(123)`` uses ``123`` as\r\n the seed for the random-number generator. Obviously, in these modes, you\r\n will *not* get any indication of dimensional-analysis errors. As above,\r\n if you are going to use any version of ``reset_units()``, make sure you do\r\n it before any dimensionful variable is defined in any module.\r\n\r\n* If you have a quantity you want to plot, store, pass between different\r\n parallel processes, etc., make sure you first express it in a known unit.\r\n (e.g. \"energy expressed in joules\" can be passed between processses, but\r\n \"energy\" cannot.) For parallel processing in particular, see `README appendix <https://github.com/sbyrnes321/numericalunits/blob/master/README_appendix.rst>`_\r\n for different ways of using the package, with example code.\r\n\r\n* There are very rare, strange cases where the final answer does not seem to \r\n randomly vary even though there was a dimensional-analysis violation: For \r\n example, the expression ``(1 + 1e-50 * cm / atm)`` fails dimensional \r\n analysis, so if you calculate it the answer is randomly-varying. But, it is \r\n only randomly varying around the 50th decimal point, so the variation is\r\n hidden from view. You would not notice it as an error.\r\n\r\n* Since units are normal Python ``float``-type numbers, they follow the normal\r\n casting rules. For example, ``2 * cm`` is a python ``float``, not an ``int``.\r\n This is usually what you would want and expect.\r\n\r\n* You can give a dimension to complex numbers in the same way as real \r\n numbers--for example ``(2.1e3 + 3.9e4j) * ohm``.\r\n\r\n* Requires Python 3. (For Python 2 compatibility, install numericalunits\r\n version 1.23 or earlier.)\r\n\r\n* If you find bugs, please tell me by `email <http://sjbyrnes.com>`_ or \r\n `github issue board <https://github.com/sbyrnes321/numericalunits/issues>`_.\r\n\r\n* If you get overflows or underflows, you can edit the unit initializations.\r\n For example, the package sets the meter to a random numerical value between 0.1\r\n and 10. Therefore, if you're doing molecular simulation, most lengths you\r\n use will be tiny numbers. You should probably set the meter instead to be\r\n between, say, a random numerical value between 1e8 and 1e10.\r\n\r\n* Some numerical routines use a default *absolute* tolerance, rather than\r\n relative tolerance, to decide convergence. This can cause the calculation\r\n result to randomly vary even though there is no dimensional analysis error.\r\n When this happens, you should set the absolute tolerance to a value with the\r\n appropriate units. Alternatively, you can scale the data before running the\r\n algorithm and scale it back afterwards. Maybe this sounds like a hassle, but\r\n it's actually a benefit: If your final result is very sensitive to some\r\n numerical tolerance setting, then you really want to be aware of that.\r\n\r\nNotes on unit definitions\r\n-------------------------\r\n\r\n* For electromagnetism, all units are intended for use in SI formulas. If \r\n you plug them into cgs-gaussian electromagnetism formulas, or cgs-esu \r\n electromagnetism formulas, etc., you will get nonsense results.\r\n\r\n* The package does not keep track of \"radians\" as an independent unit \r\n assigned a random number. The reason is that the \"radians\" factor does not \r\n always neatly cancel out of formulas.\r\n\r\n* The package does not keep track of \"moles\" as an independent unit assigned \r\n a random number; instead ``mol`` is just a pure number (~6e23), like you\r\n would say \"dozen\"=12. That means: (1) gram/mol is exactly the same as amu,\r\n and Boltzmann constant is exactly the same as the ideal gas constant, and so\r\n on. (2) You should rarely need to use Avogadro's number ``NA`` -- it is just a\r\n synonym of ``mol`` (``NA = mol ~ 6e23``). Here are a few examples using moles: ::\r\n \r\n from numericalunits import um, uM, kcal, mol, fmol, J\r\n \r\n # There are eight copies of a protein inside a yeast nucleus of volume\r\n # 3 cubic microns. What is the concentration of the protein, in micromolar (uM)?\r\n print((8 / (3 * um**3)) / uM) # Answer --> 0.0044\r\n \r\n # 5 kcal / mol is how many joules?\r\n print((5 * kcal / mol) / J) # Answer --> 3.47e-20\r\n \r\n # How many molecules are in 2.3 femtomoles?\r\n print(2.3 * fmol) # Answer --> 1.39e9\r\n\r\n* The package cannot convert temperatures between Fahrenheit, Celsius, and \r\n kelvin. The reason is that these scales have different zeros, so the units \r\n cannot be treated as multiplicative factors. It is, however, possible to \r\n convert temperature *intervals*, via the units ``degCinterval`` (which is a \r\n synonym of kelvin, ``K``) and ``degFinterval``.\r\n",
"bugtrack_url": null,
"license": "MIT",
"summary": "A package that lets you define quantities with units, which can then be used in almost any numerical calculation in any programming language. Checks that calculations pass dimensional analysis, performs unit conversions, and defines physical constants.",
"version": "1.26",
"project_urls": {
"Homepage": "http://pypi.python.org/pypi/numericalunits",
"Repository": "https://github.com/sbyrnes321/numericalunits"
},
"split_keywords": [
"units",
" quantities",
" physical constants",
" dimensional analysis"
],
"urls": [
{
"comment_text": "",
"digests": {
"blake2b_256": "6159a811abad42d63d7b649a95f370dc30d8c56f254fd8e1c659207b995abe81",
"md5": "995aabdf029626f82cdcbad7c66ae2e8",
"sha256": "579ec38610052c2f4de88119ba0437a76834c4bf81739ac7045412029f0f300e"
},
"downloads": -1,
"filename": "numericalunits-1.26-py3-none-any.whl",
"has_sig": false,
"md5_digest": "995aabdf029626f82cdcbad7c66ae2e8",
"packagetype": "bdist_wheel",
"python_version": "py3",
"requires_python": ">=3",
"size": 14257,
"upload_time": "2024-11-26T18:02:51",
"upload_time_iso_8601": "2024-11-26T18:02:51.937589Z",
"url": "https://files.pythonhosted.org/packages/61/59/a811abad42d63d7b649a95f370dc30d8c56f254fd8e1c659207b995abe81/numericalunits-1.26-py3-none-any.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "63f3f52ab9234b9dc057729a03f1b84dd7ad51b3a4ef018e68a44d563e880556",
"md5": "cebd7aa2e54e010f598268f848a7d725",
"sha256": "8a0b69945dd65eacf6eef8c868bcd3298d7439f5882f507bb6060ec20c723e12"
},
"downloads": -1,
"filename": "numericalunits-1.26.tar.gz",
"has_sig": false,
"md5_digest": "cebd7aa2e54e010f598268f848a7d725",
"packagetype": "sdist",
"python_version": "source",
"requires_python": ">=3",
"size": 18263,
"upload_time": "2024-11-26T18:02:53",
"upload_time_iso_8601": "2024-11-26T18:02:53.148776Z",
"url": "https://files.pythonhosted.org/packages/63/f3/f52ab9234b9dc057729a03f1b84dd7ad51b3a4ef018e68a44d563e880556/numericalunits-1.26.tar.gz",
"yanked": false,
"yanked_reason": null
}
],
"upload_time": "2024-11-26 18:02:53",
"github": true,
"gitlab": false,
"bitbucket": false,
"codeberg": false,
"github_user": "sbyrnes321",
"github_project": "numericalunits",
"travis_ci": false,
"coveralls": false,
"github_actions": false,
"lcname": "numericalunits"
}
