tomobase-v0.0.0.dev1/ 0000775 0001751 0001752 00000000000 15237630637 015353 5 ustar blagandzig blagandzig tomobase-v0.0.0.dev1/.gitlab-ci.yml 0000664 0001751 0001752 00000001670 15237630637 020013 0 ustar blagandzig blagandzig include:
- project: dau/ci/pyci
file: .gitlab-ci-template.yml
variables:
DISABLE_BLACK_FLAKE8: "yes"
# style/linting
ruff:
extends: .ruff
# tests with dev deps
test_python3_12_dev:
extends: .test-3.12_glx
variables:
COVERAGE_SOURCE: "./$INTERNAL_PROJECT_NAME"
PYTEST_WARNINGS: "-W error ${IGNORE_WARNINGS}"
PYTEST_COV: "true"
# tests with PyPI deps
test_sdist-3.10_glx:
extends: .test_sdist-3.10_glx
variables:
PYTEST_WARNINGS: "-W error ${IGNORE_WARNINGS}"
test_sdist-3.12_glx:
extends: .test_sdist-3.12_glx
variables:
PYTEST_WARNINGS: "-W error ${IGNORE_WARNINGS}"
PYTEST_COV: "true"
test_sdist-3.13_glx:
extends: .test_sdist-3.13_glx
variables:
PYTEST_WARNINGS: "-W error ${IGNORE_WARNINGS}"
# doc
build_doc:
extends: .build_doc
build_sdist:
extends: .build_sdist
# deploy
assets:
extends: .assets
pages:
extends: .pages
testpypi:
extends: .testpypi
pypi:
extends: .pypi
tomobase-v0.0.0.dev1/.readthedocs.yaml 0000664 0001751 0001752 00000001144 15237630637 020602 0 ustar blagandzig blagandzig # Read the Docs configuration file
# See https://docs.readthedocs.io/en/stable/config-file/v2.html for details
# Required
version: 2
# Set the version of Python and other tools you might need
build:
os: ubuntu-24.04
tools:
python: "3.12"
# Build documentation in the docs/ directory with Sphinx
sphinx:
configuration: doc/conf.py
# If using Sphinx, optionally build your docs in additional formats such as PDF
# formats:
# - pdf
# Optionally declare the Python requirements required to build your docs
python:
install:
- method: pip
path: .
extra_requirements:
- doc
tomobase-v0.0.0.dev1/doc/ 0000775 0001751 0001752 00000000000 15237630637 016120 5 ustar blagandzig blagandzig tomobase-v0.0.0.dev1/doc/_templates/ 0000775 0001751 0001752 00000000000 15237630637 020255 5 ustar blagandzig blagandzig tomobase-v0.0.0.dev1/doc/_templates/version.html 0000664 0001751 0001752 00000000100 15237630637 022617 0 ustar blagandzig blagandzig
{{ version }} tomobase-v0.0.0.dev1/doc/_templates/autosummary/ 0000775 0001751 0001752 00000000000 15237630637 022643 5 ustar blagandzig blagandzig tomobase-v0.0.0.dev1/doc/_templates/autosummary/class.rst 0000664 0001751 0001752 00000001142 15237630637 024500 0 ustar blagandzig blagandzig {{ fullname | escape | underline}}
.. currentmodule:: {{ module }}
.. autoclass:: {{ objname }}
:members:
:show-inheritance:
:inherited-members:
{% block methods %}
.. automethod:: __init__
{% if methods %}
.. rubric:: {{ _('Methods') }}
.. autosummary::
{% for item in methods %}
~{{ name }}.{{ item }}
{%- endfor %}
{% endif %}
{% endblock %}
{% block attributes %}
{% if attributes %}
.. rubric:: {{ _('Attributes') }}
.. autosummary::
{% for item in attributes %}
~{{ name }}.{{ item }}
{%- endfor %}
{% endif %}
{% endblock %} tomobase-v0.0.0.dev1/doc/_templates/autosummary/module.rst 0000664 0001751 0001752 00000002145 15237630637 024664 0 ustar blagandzig blagandzig {{ fullname | escape | underline}}
.. automodule:: {{ fullname }}
{% block attributes %}
{% if attributes %}
.. rubric:: Module Attributes
.. autosummary::
:toctree:
{% for item in attributes %}
{{ item }}
{%- endfor %}
{% endif %}
{% endblock %}
{% block functions %}
{% if functions %}
.. rubric:: {{ _('Functions') }}
.. autosummary::
:toctree:
{% for item in functions %}
{{ item }}
{%- endfor %}
{% endif %}
{% endblock %}
{% block classes %}
{% if classes %}
.. rubric:: {{ _('Classes') }}
.. autosummary::
:toctree:
{% for item in classes %}
{{ item }}
{%- endfor %}
{% endif %}
{% endblock %}
{% block exceptions %}
{% if exceptions %}
.. rubric:: {{ _('Exceptions') }}
.. autosummary::
:toctree:
{% for item in exceptions %}
{{ item }}
{%- endfor %}
{% endif %}
{% endblock %}
{% block modules %}
{% if modules %}
.. rubric:: Modules
.. autosummary::
:toctree:
:recursive:
{% for item in modules %}
{{ item }}
{%- endfor %}
{% endif %}
{% endblock %} tomobase-v0.0.0.dev1/doc/api.rst 0000664 0001751 0001752 00000000141 15237630637 017417 0 ustar blagandzig blagandzig API reference
=============
.. autosummary::
:toctree: generated
:recursive:
tomobase
tomobase-v0.0.0.dev1/doc/img/ 0000775 0001751 0001752 00000000000 15237630637 016674 5 ustar blagandzig blagandzig tomobase-v0.0.0.dev1/doc/img/tomobase-lockup.svg 0000664 0001751 0001752 00000001502 15237630637 022517 0 ustar blagandzig blagandzig
tomobase-v0.0.0.dev1/doc/img/tomobase.png 0000664 0001751 0001752 00000022361 15237630637 021217 0 ustar blagandzig blagandzig PNG
IHDR \rf IDATx^ $E0{g*#&
(sgq.EqWE w(EEM'U=ӕqsUiz*3{#wN9=Yy*3bhnBL>1$1$1$1$1$1$ !x LD"# ?AD \?~' Vq|\E `<7u
\F$u~ I 3mc!"@$J"I l6jgKY;^$7|D$jUJ/oy= L
Prccc[ o]fbqI(1爸rlݹ~[v}bI() f6 y#{ Pk-?PBZ똈n@ .p]Wn6 4M DT~e"7$>(JA@R
D<ϦD$ J|AEo |4]i=D)H( 4;MZW}`'} sII(FqP^溜n鱭VZ Fz~1 Q cR>?tm۷" sddNFDt 0"X JB)u"1D穩C'''E466O1>G1}}MK@ (CĻJD/n[n> "6$Z '4ƘO%~- |z;j$$ pFZ>D\k1Z$inn A I Z ޜL 1/>2
X}6$# `㏇ΜdD[֡h[ m3^EaRFw@ CA@3} 6w~n5nb$J)BDLʔ z$c~IC@R@g4I m1D$QWW#$ƘB>" @q E' S@V;0kO}@A@R z5{] b_ ' ":Z{ >ZbYi^樻='&&fyA)7"61Dtv> H ###i}ƘR@ͫQtvm۷Xv ~; | YD)k- 3 ʬ9ޒ$G}@,;I QJ}լ4Mj:Ope5.>IJWin9瞆_"# "b-ƘyIJZYBDZkyXD^UǵU'&&Tm,I 9Q}}Iݏpn=Z ˪ܯQJglܓzlcIJ*b}0@IZvLV1MbHض+W̬KDZkOc055ڵkةXf h4vy?hy_
XQ)4MwnZwX6 ~Q] "zL XQ5c"ZZ=$ JCgY!7Ykq(>NsPe# f)Z9o!)YMt $J! sWt$@(^9KƘ/%l$Bk 87,)IbHD ǯh(N
+$\ ~ID GGQ@sG&Ire# +w OYe1 |$$h krZ kCgGŲFqPE@RϦCD u]n tW5I x(x6_\x$I I aBoq07?DkW A `N` I Q SgUf*B@R@g4D "3 f9/ HRvD|LFd/Dk} ҫIDt:|$Hk} xADWZkI *\>jyKI^Y > .
i$c~IA@Ƶַl=`эk|DA@4Ws9I|3]=$L)cD<,&GƘc$ZjQ1ꩩ]~ A(SLD\~s7"Ӓ$ m V J"yjGj 6< K%wIK _x;\(I h46ٔc^, t:l(%I @,$
J@H % $P BI I b$T$ P *@X(I @,$5Z1qُD9">#kSh[D]G WwFi"j"_;}dct,%iI HX fs(rm "
!"@>E{)z {hãs($I S@wżZj+VBDDQpmFD~^4E'c^hB& N79LOOߺf͚?fqY9+" ~7;NƢM%ѭ p+"ꜻ%M['&&x# 0#XrZm" OroWX)Z?(D"KVD iEܻ{,< XE'c^hr" qb$I~/6 l>V ADGp .D |3d,ZK:"gOJVuT+0>>Dt8"I?십d$ 3"bΪ3BD5:}O:!=g mQJNsUݾm^t>1>>ȑDtlwڭrWO,|X''[DD7u]'s Eʙ?k!'k8EQd}'iDɷ3îdlK~ /rbb
4u;>,EeݼMQ}f
I+J&{ UQsSgN2
QdiƬi8'I5,R cccی,' a >;55u$e(R$իW 522 ؛jUO`~!\Jw ]?g.*/X}
q7snÿ (tέh(6 &ݡ O`;xÌofcDǫh u)Ύyn~5k *l6ϩjQ,& =}{˿#"wYNfʕU͔G)VյZmC ͈Q5xhnQ !4ijZf :^Q+Vbf3ܞy*c;6Y-2 Ngzsk&
[v?u'h>Z WFQ7
w" t:wGQt$ %$v = ; ȱ%{y$,-P hZ?[Of.6=lϸ<(ڑ~HolZ Wgq7N Or>ىhO$Iȶ* < l C9nf^ V*&+ p1=\, p <ɯߋ/tX w$0m`,!ߠ#ygQu_w[k+FO J=haRN,ZkGƘcRʐ Ed;~IB Hԯ>i
K) WHV2(ypΓ)@ Zs!";!DkݾO2|͆, G pt֎s(u 5͝kJ.MR$ xzΞ<s_b)^_9tk{} PH fZҬ}HDZkO!< 8p $>R$ CkY]B R귈@M/h*K ~"k?Z8#] *v'>OƘRʔ .DD jD8><|`">$ WtQW9^$g} `I q EZD b(n@6t+M` (M>("k4yD=~-| [?Z{ȔR/E9"k-*R% 5c~IE&">6VNiJ Fcz7 'ZU>2
Ҕ/U`J b^CuXTJ>k1(c(Ac;Dkӽ(KJ jZDtgA!6֚os8O$VuJ X@V!O)R2(.@{":Zӈ (R b^1CUQeZy<!RJ Ddk|$J R"k?ڟ QQe߭Ő9| _s?gy_bRG D1km݁6qQXk#[ QΥM Lk {"[kBS ϊ>0iiK h\6}Zt b\>0a}LNQݑϹTO 466_0g~ܰPJjsI? OZ[|`"ZPYٽEVt,OY h |cE~IJ!|`ck1P T; s_R 9$I^%U0>>y`zzz?R >Ѓsn$ID`Zk.rpq /!2|* Z+Yǂ֧iT
yoVW ι$I9L* jA"W UxX t{"3x1[ѥ"3XN!wYk%WUkڽy 4c]Jw!b^Nm\ Z ^u\S$,f[9}ZWt* R9S7| CO)u*"~4kGQgzzz5kpʨ\`J/!bLc -݃ERsϾ ڗ@ET24͝(`˒$ɜM 8O輬-smZ#O*);%Y ȿF cOD-k}B* 8/Z7CT\ /syYnM L)u" = 1LFR\#7 \n9/UL@ GFQtE1sν=IZk.'wfaڟ@T:AB0ԷYvEeu;k9ucRE
Eh4j,8cNK_fm qȝ`E
E`Z +&&&rRG6>e}T$GFF89c.SJٌ5ιm$ z/"=YpEQm=*n WJ5;=hATxoހ 曏Z aK .:D
LDgYkOQzJ
c דC =]2_Ntv}.ЭƘݹs aL 8^Z_ mNZk}`H e`J y9w|$|XTQxFD־& ^R9~cNemZ1,ODgiZ\<χ1oK4 59$I.!3 u v Z; ZED7Zy'= 1{IYnݲZ̉=11;lF ǟyLD֞"Xq EDD־$PDt[Ai(~T~|xqoElƘ'Hl6Z.@
?4Mj.!& fQJ}sk{>?ZcHxR8$!_JI>/$ >1Kbh? ok ]d͛/r(IKF# u5pqL8><^>gA) D f>"sj[|0M@]c(D#
P=]cKb)ހg=']BH(]"Zt ~2>>{^[~+9wD$?I }PJ + LKg +o& I Zd{HocNKb)>/ a<[ЧfsV"f+ǵZ X4J@@okhak1Hԋ>O7o$wdq Ee H'E pv1f_%hVky]}"Z" $ .Dd2ѷ`Zq>m>(
IX > >sIp?u@Zk {a2Bs$,֚@D,&#zh_$ O.)wNJ|\ B~|5ޤ&iVt/N=Gz(6wQtk_N&vʕ\NީR[L ?Y_~ϵkb$,wQ1ۓ$(NG3|x$,5WzED ڢ:ClPոS.x$,>WOAIծ *f_(9"mX\ W= VRj; ὺ`7HE& `gn7%R
~]4gq-c,$%D3k s
2DDtL$?IX"q Ey>mh;ӑыX4 R,D|d;>4RF~X1~I,*I K REªijz"~M1&4 Jԯf﹈tcLnҲSJqoq} |P,:I z-VX{֣?
QJ
\?w5ݓ~v>($i4_qy\Wō1
x(8*Vڟ}D,I : ~%:hZ`u_|?ML?R?ap$ X<>\ }֭{| 6 IDATƶ 7kX E/B8~eElNZC>X"㏬"EvΝ$> B2>8Z{0wZs}k `;uҐS~eYpHV+xd FEDXkb$,35?f% H$l_1vKG?}4%$OD߷>8I aZ4ќP|NZk9MX 1I h|Q >8u\Qqv1EDιC$1>"$t/ʊu-w$hlVx$jIׁ,!CD?A`6 0I O w:#'&&Kp 6q_܁?\ 7$pԡK5iw`/q{ vKv%E$| "LVu,FK^ l/ I %IV">\ONgdJ} D$Hwx-ʭ/5\# h4G>4M\H@4|BkQy BZ|p O=Z XaN@9qsQNH>؇8\(zo #|KF@yՕRRE-k|0D>ʖmksyj QxEx/!I}ƴc|$k=D)I;=l]Sf:錏o^ׯ J@h_ g Vq |-^$>(JM@q(f jt sѳQz *g Bݼ<"z9w\պE%HFFF}t:>"*C@###!"7"mGɈP}cJ"T] j%$ `Hh? /ss?c;
$ ; Yܽ$I>䃢$ D}Gfo:Mщ 4$Mj4ݺ4M_j~5cIb#bn6ĻaIbIbIbc deBG7A1C3C5559EA248FM IENDB` tomobase-v0.0.0.dev1/doc/img/tomobase.svg 0000664 0001751 0001752 00000001340 15237630637 021224 0 ustar blagandzig blagandzig tomobase-v0.0.0.dev1/doc/index.rst 0000664 0001751 0001752 00000000640 15237630637 017761 0 ustar blagandzig blagandzig tomobase
========
Common base classes and utilities shared by `tomoscan `_
(tomography scan reading) and `volio `_ (volume load/save):
the ``TomoObject``/``BaseIdentifier`` hierarchy, ``Series``, ``Source``, ``Progress``,
``CoordinateSystem``, and shared IO/geometry/deprecation utilities.
.. toctree::
:maxdepth: 2
api.rst
tomobase-v0.0.0.dev1/doc/conf.py 0000664 0001751 0001752 00000003133 15237630637 017417 0 ustar blagandzig blagandzig from importlib.metadata import version as get_version
extensions = [
"sphinx.ext.autodoc",
"sphinx.ext.intersphinx",
"sphinx.ext.autosummary",
"sphinx_design",
"sphinx_autodoc_typehints",
"myst_parser",
]
templates_path = ["_templates"]
source_suffix = {
".rst": "restructuredtext",
".md": "markdown",
}
master_doc = "index"
project = "tomobase"
copyright = "2026, ESRF"
author = "ESRF"
release = get_version(project)
version = ".".join(release.split(".")[:2])
language = "en"
exclude_patterns = [
"build",
]
pygments_style = "sphinx"
todo_include_todos = False
html_theme = "pydata_sphinx_theme"
html_logo = "img/tomobase.svg"
html_static_path = ["_static"]
htmlhelp_basename = "tomobase"
man_pages = [(master_doc, "tomobase", "tomobase documentation", [author], 1)]
autosummary_generate = True
autodoc_default_flags = [
"members",
"undoc-members",
"show-inheritance",
]
html_theme_options = {
"icon_links": [
{
"name": "pypi",
"url": "https://pypi.org/project/tomobase",
"icon": "_static/navbar_icons/pypi.svg",
"type": "local",
},
{
"name": "gitlab",
"url": "https://gitlab.esrf.fr/tomotools/tomobase",
"icon": "_static/navbar_icons/gitlab.svg",
"type": "local",
},
],
"show_toc_level": 1,
"navbar_align": "left",
"show_version_warning_banner": True,
"navbar_start": ["navbar-logo", "version"],
"navbar_center": ["navbar-nav"],
"footer_start": ["copyright"],
"footer_center": ["sphinx-version"],
}
tomobase-v0.0.0.dev1/pyproject.toml 0000664 0001751 0001752 00000004045 15237630637 020272 0 ustar blagandzig blagandzig [project]
name = "tomobase"
version = "0.0.0dev1"
authors = [
{ name = "Henri Payno", email = "henri.payno@esrf.fr" },
{ name = "Pierre Paleo", email = "pierre.paleo@esrf.fr" },
{ name = "Pierre-Olivier Autran", email = "pierre-olivier.autran@esrf.fr" },
{ name = "Jérôme Lesaint", email = "jerome.lesaint@esrf.fr" },
]
description = "Common base classes for tomography data objects"
readme = { file = "README.md", content-type = "text/markdown" }
license = "MIT"
requires-python = ">=3.10"
keywords = ["NXtomo", "nexus", "tomography", "esrf"]
classifiers = [
"Intended Audience :: Education",
"Intended Audience :: Science/Research",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3.10",
"Programming Language :: Python :: 3.11",
"Programming Language :: Python :: 3.12",
"Programming Language :: Python :: 3.13",
"Programming Language :: Python :: 3.14",
"Environment :: Console",
"Operating System :: POSIX",
"Natural Language :: English",
"Topic :: Scientific/Engineering :: Physics",
"Topic :: Software Development :: Libraries :: Python Modules"
]
dependencies = [
"h5py>=3.0",
"silx>=2.0",
"numpy",
]
[project.optional-dependencies]
test = [
"pytest",
"ruff",
]
doc = [
"Sphinx>=4.0.0, <5.2.0",
"pydata_sphinx_theme",
"sphinx-design",
"sphinx-autodoc-typehints",
"myst-parser",
]
[build-system]
requires = [
"setuptools>=61.0",
"wheel",
"numpy"
]
build-backend = "setuptools.build_meta"
[tool.sphinx]
source-dir = "./doc"
[tool.ruff]
line-length = 88
target-version = "py310"
[tool.ruff.lint]
# `select` (not `extend-select`): pin the rule set explicitly so a new ruff
# release changing its defaults cannot break the CI.
select = [
"E", # pycodestyle errors
"F", # pyflakes
"I", # isort
"S", # flake8-bandit
]
ignore = [
"E501", # line length: `ruff format` is the authority
"S101", # assert
]
[tool.ruff.lint.isort]
known-first-party = ["tomobase"]
[tool.setuptools.packages.find]
where = ["."]
tomobase-v0.0.0.dev1/.gitignore 0000664 0001751 0001752 00000000121 15237630637 017335 0 ustar blagandzig blagandzig __pycache__/
*.py[cod]
*.egg-info/
.pytest_cache/
build/
dist/
doc/generated
html tomobase-v0.0.0.dev1/README.md 0000664 0001751 0001752 00000001402 15237630637 016627 0 ustar blagandzig blagandzig # tomobase
Common base classes and utilities shared by [tomoscan](https://gitlab.esrf.fr/tomotools/tomoscan)
(tomography scan reading) and [volio](https://gitlab.esrf.fr/tomotools/volio) (volume load/save):
* the `TomoObject` / `BaseIdentifier`
* `Series`, `Source`, `Progress`, `CoordinateSystem`
* shared IO, geometry and deprecation utilities
## installation
### using pypi
To install the latest 'tomobase' pip package
``` bash
pip install tomobase
```
### using gitlab repository
``` bash
pip install git+https://gitlab.esrf.fr/tomotools/tomobase.git
```
## documentation
General documentation can be found here: [https://tomotools.gitlab-pages.esrf.fr/tomobase/](https://tomotools.gitlab-pages.esrf.fr/tomobase/)
tomobase-v0.0.0.dev1/LICENSE 0000664 0001751 0001752 00000002362 15237630637 016363 0 ustar blagandzig blagandzig
The tomobase library provides common base classes shared by the ESRF tomography tools (tomoscan, volio).
tomobase is distributed under the MIT license.
The MIT license follows:
Copyright (c) European Synchrotron Radiation Facility (ESRF)
Permission is hereby granted, free of charge, to any person obtaining a copy of
this software and associated documentation files (the "Software"), to deal in
the Software without restriction, including without limitation the rights to
use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
the Software, and to permit persons to whom the Software is furnished to do so,
subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
tomobase-v0.0.0.dev1/tomobase/ 0000775 0001751 0001752 00000000000 15237630637 017164 5 ustar blagandzig blagandzig tomobase-v0.0.0.dev1/tomobase/geometry/ 0000775 0001751 0001752 00000000000 15237630637 021017 5 ustar blagandzig blagandzig tomobase-v0.0.0.dev1/tomobase/geometry/shape.py 0000664 0001751 0001752 00000000623 15237630637 022472 0 ustar blagandzig blagandzig def get_subvolume_shape(chunk, volume_shape):
"""
Get the shape of a sub-volume to extract in a volume.
:param chunk: tuple of slice
:param volume_shape: tuple of int
"""
shape = []
for c, v in zip(chunk, volume_shape):
start = c.start or 0
end = c.stop or v
if end < 0:
end += v
shape.append(end - start)
return tuple(shape)
tomobase-v0.0.0.dev1/tomobase/geometry/bounding_box.py 0000664 0001751 0001752 00000005120 15237630637 024044 0 ustar blagandzig blagandzig import numpy
class _BoundingBox:
def __init__(self, v1, v2):
if not numpy.isscalar(v1):
v1 = tuple(v1)
if not numpy.isscalar(v2):
v2 = tuple(v2)
self._min = min(v1, v2)
self._max = max(v1, v2)
@property
def min(self) -> float:
return self._min
@property
def max(self) -> float:
return self._max
def __str__(self):
return f"({self.min}, {self.max})"
def __eq__(self, other):
if not isinstance(other, _BoundingBox):
return False
else:
return self.min == other.min and self.max == other.max
def get_overlap(self, other_bb):
raise NotImplementedError("Base class")
class BoundingBox1D(_BoundingBox):
def get_overlap(self, other_bb):
if not isinstance(other_bb, BoundingBox1D):
raise TypeError(f"Can't compare a {BoundingBox1D} with {type(other_bb)}")
if (
(self.max >= other_bb.min and self.min <= other_bb.max)
or (other_bb.max >= self.min and other_bb.min <= self.max)
or (other_bb.min <= self.min and other_bb.max >= self.max)
):
return BoundingBox1D(
max(self.min, other_bb.min), min(self.max, other_bb.max)
)
else:
return None
def __eq__(self, other):
if isinstance(other, (tuple, list)):
return len(other) == 2 and self.min == other[0] and self.max == other[1]
else:
return super().__eq__(other)
def __hash__(self):
return hash((self._min, self._max))
class BoundingBox3D(_BoundingBox):
def get_overlap(self, other_bb):
if not isinstance(other_bb, BoundingBox3D):
raise TypeError(f"Can't compare a {BoundingBox3D} with {type(other_bb)}")
self_bb_0 = BoundingBox1D(self.min[0], self.max[0])
self_bb_1 = BoundingBox1D(self.min[1], self.max[1])
self_bb_2 = BoundingBox1D(self.min[2], self.max[2])
other_bb_0 = BoundingBox1D(other_bb.min[0], other_bb.max[0])
other_bb_1 = BoundingBox1D(other_bb.min[1], other_bb.max[1])
other_bb_2 = BoundingBox1D(other_bb.min[2], other_bb.max[2])
overlap_0 = self_bb_0.get_overlap(other_bb_0)
overlap_1 = self_bb_1.get_overlap(other_bb_1)
overlap_2 = self_bb_2.get_overlap(other_bb_2)
if overlap_0 is not None and overlap_1 is not None and overlap_2 is not None:
return BoundingBox3D(
(overlap_0.min, overlap_1.min, overlap_2.min),
(overlap_0.max, overlap_1.max, overlap_2.max),
)
tomobase-v0.0.0.dev1/tomobase/geometry/__init__.py 0000664 0001751 0001752 00000000557 15237630637 023137 0 ustar blagandzig blagandzig """Geometry helpers used by tomobase.
This package exposes simple bounding box types and small utilities
for working with shapes and sub-volumes. The helpers are intentionally
minimal and designed to be easy to reuse in higher-level code.
"""
from .bounding_box import BoundingBox1D, BoundingBox3D # noqa: F401
from .shape import get_subvolume_shape # noqa: F401
tomobase-v0.0.0.dev1/tomobase/tests/ 0000775 0001751 0001752 00000000000 15237630637 020326 5 ustar blagandzig blagandzig tomobase-v0.0.0.dev1/tomobase/tests/test_progress.py 0000664 0001751 0001752 00000001127 15237630637 023604 0 ustar blagandzig blagandzig # coding: utf-8
import tomobase.progress
def test_progress():
"""Simple test of the Progress API"""
progress = tomobase.progress.Progress("this is progress")
progress.reset()
progress.startProcess()
progress.setMaxAdvancement(80)
for adv in (10, 20, 50, 70):
progress.setAdvancement(adv)
for _ in range(10):
progress.increaseAdvancement(1)
def test_advancement():
"""Simple test of the _Advancement API"""
for i in range(4):
tomobase.progress._Advancement.getNextStep(
tomobase.progress._Advancement.getStep(i)
)
tomobase-v0.0.0.dev1/tomobase/tests/test_identifiers.py 0000664 0001751 0001752 00000000736 15237630637 024252 0 ustar blagandzig blagandzig # coding: utf-8
"""test of the tomobase.identifiers module"""
import pytest
from tomobase.identifiers import BaseIdentifier
from tomobase.tomoobject import TomoObject
def test_base_identifier():
identifier = BaseIdentifier(TomoObject)
assert identifier == identifier
assert identifier != "some other str"
with pytest.raises(NotImplementedError):
identifier.scheme
with pytest.raises(NotImplementedError):
BaseIdentifier.from_str("test")
tomobase-v0.0.0.dev1/tomobase/tests/test_shape.py 0000664 0001751 0001752 00000000572 15237630637 023043 0 ustar blagandzig blagandzig # coding: utf-8
from tomobase.geometry.shape import get_subvolume_shape
def test_get_subvolume_shape():
volume_shape = (10, 20, 30)
assert get_subvolume_shape(
(slice(0, 5), slice(0, 20), slice(0, 30)), volume_shape
) == (5, 20, 30)
assert get_subvolume_shape(
(slice(2, 8), slice(None, None), slice(0, -5)), volume_shape
) == (6, 20, 25)
tomobase-v0.0.0.dev1/tomobase/tests/test_bounding_box.py 0000664 0001751 0001752 00000004460 15237630637 024420 0 ustar blagandzig blagandzig # coding: utf-8
import pytest
from tomobase.geometry.bounding_box import BoundingBox1D, BoundingBox3D, _BoundingBox
def test_bounding_box_base():
bb = _BoundingBox(0, 1)
with pytest.raises(NotImplementedError):
bb.get_overlap(None)
def test_bounding_box_1D():
"""
check if BoundingBox1D is working properly
"""
# check overlaping
bb1 = BoundingBox1D(0.0, 1.0)
bb2 = BoundingBox1D(0.2, 1.0)
assert bb1.get_overlap(bb2) == BoundingBox1D(0.2, 1.0)
assert bb2.get_overlap(bb1) == BoundingBox1D(0.2, 1.0)
bb1 = BoundingBox1D(0.0, 1.0)
bb2 = BoundingBox1D(0.2, 0.8)
assert bb1.get_overlap(bb2) == BoundingBox1D(0.2, 0.8)
assert bb2.get_overlap(bb1) == BoundingBox1D(0.2, 0.8)
bb1 = BoundingBox1D(0.0, 1.0)
bb2 = BoundingBox1D(1.0, 1.2)
assert bb2.get_overlap(bb1) == BoundingBox1D(1.0, 1.0)
# check outside
bb1 = BoundingBox1D(0.0, 1.0)
bb2 = BoundingBox1D(2.0, 2.2)
assert bb2.get_overlap(bb1) is None
assert bb1.get_overlap(bb2) is None
# check on fully including in the other
bb1 = BoundingBox1D(0.0, 1.0)
bb2 = BoundingBox1D(0.1, 0.3)
assert bb2.get_overlap(bb1) == BoundingBox1D(0.1, 0.3)
assert bb1.get_overlap(bb2) == BoundingBox1D(0.1, 0.3)
with pytest.raises(TypeError):
bb1.get_overlap(None)
def test_bounding_box_3D():
"""
check if BoundingBox3D is working properly
"""
# check overlaping
bb1 = BoundingBox3D((0.0, -0.1, 0.0), [1.0, 0.8, 0.9])
bb2 = BoundingBox3D([0.2, 0.0, 0.1], (1.0, 2.0, 3.0))
assert bb1.get_overlap(bb2) == BoundingBox3D((0.2, 0.0, 0.1), (1.0, 0.8, 0.9))
assert bb2.get_overlap(bb1) == BoundingBox3D((0.2, 0.0, 0.1), (1.0, 0.8, 0.9))
# check outside
bb1 = BoundingBox3D((0.0, -0.1, 0.0), [1.0, 0.8, 0.9])
bb2 = BoundingBox3D([0.2, 0.0, -2.1], (1.0, 2.0, -1.0))
assert bb2.get_overlap(bb1) is None
assert bb1.get_overlap(bb2) is None
# check on fully including in the other
bb1 = BoundingBox3D((0.0, 0.1, 0.2), (1.0, 1.1, 1.2))
bb2 = BoundingBox3D((-2.0, -3.0, -4.0), (2.0, 2.0, 2.0))
assert bb2.get_overlap(bb1) == BoundingBox3D((0.0, 0.1, 0.2), (1.0, 1.1, 1.2))
assert bb1.get_overlap(bb2) == BoundingBox3D((0.0, 0.1, 0.2), (1.0, 1.1, 1.2))
with pytest.raises(TypeError):
bb1.get_overlap(None)
tomobase-v0.0.0.dev1/tomobase/tests/test_tomoobject.py 0000664 0001751 0001752 00000000505 15237630637 024104 0 ustar blagandzig blagandzig # coding: utf-8
"""test of the tomobase.tomoobject module"""
import pytest
from tomobase.tomoobject import TomoObject
def test_tomoobject():
obj = TomoObject()
with pytest.raises(NotImplementedError):
obj.from_identifier("test")
with pytest.raises(NotImplementedError):
obj.get_identifier()
tomobase-v0.0.0.dev1/tomobase/tests/__init__.py 0000664 0001751 0001752 00000000000 15237630637 022425 0 ustar blagandzig blagandzig tomobase-v0.0.0.dev1/tomobase/tests/conftest.py 0000664 0001751 0001752 00000000404 15237630637 022523 0 ustar blagandzig blagandzig from tempfile import TemporaryDirectory
import pytest
@pytest.fixture(scope="session", autouse=True)
def changetmp(request):
with TemporaryDirectory(prefix="pytest-tomobase-") as temp_dir:
request.config.option.basetemp = temp_dir
yield
tomobase-v0.0.0.dev1/tomobase/tests/test_version.py 0000664 0001751 0001752 00000000203 15237630637 023417 0 ustar blagandzig blagandzig # coding: utf-8
import tomobase
def test_version():
assert isinstance(tomobase.__version__, str), "version should be a str"
tomobase-v0.0.0.dev1/tomobase/tests/test_io.py 0000664 0001751 0001752 00000003246 15237630637 022353 0 ustar blagandzig blagandzig import os
import h5py
import numpy
from tomobase.utils.io import cast_to_default_types, check_virtual_sources_exist
def test_vds(tmp_path):
h5_file_without_vds = os.path.join(tmp_path, "h5_file_without_vds.hdf5")
with h5py.File(h5_file_without_vds, mode="w") as h5f:
h5f["data"] = numpy.random.random((120, 120))
assert check_virtual_sources_exist(h5_file_without_vds, "data")
h5_file_with_vds = os.path.join(tmp_path, "h5_file_with_vds.hdf5")
# create some dataset
for i in range(4):
filename = os.path.join(tmp_path, f"{i}.h5")
with h5py.File(filename, mode="w") as h5f:
h5f.create_dataset("data", (100,), "i4", numpy.arange(100))
layout = h5py.VirtualLayout(shape=(4, 100), dtype="i4")
for i in range(4):
filename = os.path.join(tmp_path, f"{i}.h5")
layout[i] = h5py.VirtualSource(filename, "data", shape=(100,))
with h5py.File(h5_file_with_vds, mode="w") as h5f:
# create the virtual dataset
h5f.create_virtual_dataset("data", layout, fillvalue=-5)
assert check_virtual_sources_exist(h5_file_with_vds, "data")
def test_cast_to_default_types():
"""test 'cast_to_default_types' function"""
assert cast_to_default_types(
{
"a": numpy.float64(25.6),
"b": {
"c": numpy.zeros(5, dtype=numpy.int32),
"d": numpy.ones(4, dtype=numpy.uint64),
},
"e": (numpy.float32(45.5), numpy.float32(5.5)),
"f": numpy.int16(5),
}
) == {
"a": 25.6,
"b": {
"c": [0] * 5,
"d": [1] * 4,
},
"e": [45.5, 5.5],
"f": 5,
}
tomobase-v0.0.0.dev1/tomobase/series.py 0000664 0001751 0001752 00000011147 15237630637 021034 0 ustar blagandzig blagandzig # coding: utf-8
"""Module with the Series class for grouping TomoObjects"""
from __future__ import annotations
import numpy
from tomobase.identifiers import BaseIdentifier
from tomobase.tomoobject import TomoObject
__all__ = [
"Series",
]
class Series(list):
"""
A series can be view as an extended list of :class:`TomoObject`.
This allow the user to define a relation between tomo objects like scans or volumes.
"""
def __init__(
self,
name: str | None = None,
iterable: (
list[TomoObject] | tuple[TomoObject, ...] | numpy.ndarray | None
) = None,
use_identifiers=False,
) -> None:
if name is not None and not isinstance(name, str):
raise TypeError(
f"name should be None or an instance of str. Get {type(name)} instead"
)
self._name = "Unknow" if name is None else name
self.__use_identifiers = use_identifiers
if iterable is None:
iterable = []
super().__init__()
for item in iterable:
self.append(item)
@property
def name(self) -> str:
return self._name
@name.setter
def name(self, name: str):
if not isinstance(name, str):
raise TypeError("name is expected to be an instance of str")
self._name = name
@property
def use_identifiers(self):
return self.__use_identifiers
def append(self, object: TomoObject):
if not isinstance(object, TomoObject):
raise TypeError(
f"object is expected to be an instance of {TomoObject} not {type(object)}"
)
if self.use_identifiers:
super().append(object.get_identifier().to_str())
else:
super().append(object)
def remove(self, object: TomoObject):
if not isinstance(object, TomoObject):
raise TypeError(
f"object is expected to be an instance of {TomoObject} not {type(object)}"
)
if self.use_identifiers:
super().remove(object.get_identifier().to_str())
else:
super().remove(object)
def to_dict_of_str(self) -> dict:
"""
call for each scan DatasetIdentifier.to_str() if use dataset identifier.
Otherwise return a default list with dataset identifiers
"""
objects = []
for dataset in self:
if self.use_identifiers:
objects.append(dataset)
else:
objects.append(dataset.get_identifier().to_str())
return {
"objects": objects,
"name": self.name,
"use_identifiers": self.use_identifiers,
}
@staticmethod
def from_dict_of_str(dict_, factory=None, use_identifiers: bool | None = None):
"""
create a Series from its definition from a dictionary
:param dict_: dictionary containing the series to create
:param factory: factory to use in order to create objects defined from their Identifier.
Must provide a ``create_tomo_object_from_identifier`` method.
:param use_identifiers: use_identifiers can be overwrite when creating the series
:return: created Series
"""
if factory is None:
raise ValueError(
"factory must be provided to reconstruct objects from identifiers"
)
name = dict_["name"]
objects = dict_["objects"]
if use_identifiers is None:
use_identifiers = dict_.get("use_identifiers", False)
instanciated_scans = []
for tomo_obj in objects:
if isinstance(tomo_obj, (str, BaseIdentifier)):
instanciated_scans.append(
factory.create_tomo_object_from_identifier(identifier=tomo_obj)
)
else:
raise TypeError(
f"elements of dict_['objects'] are expected to be an instance of TomoObject, DatasetIdentifier or str representing a DatasetIdentifier. Not {type(tomo_obj)}"
)
return Series(
name=name, use_identifiers=use_identifiers, iterable=instanciated_scans
)
def __contains__(self, tomo_obj: BaseIdentifier):
if self.use_identifiers:
key = tomo_obj.get_identifier().to_str()
else:
key = tomo_obj
return super().__contains__(key)
def __eq__(self, other):
if not isinstance(other, Series):
return False
return self.name == other.name and super().__eq__(other)
def __ne__(self, other):
return not self.__eq__(other)
tomobase-v0.0.0.dev1/tomobase/progress.py 0000664 0001751 0001752 00000004264 15237630637 021410 0 ustar blagandzig blagandzig # coding: utf-8
"""Utilities for reporting simple progress indicators to stdout.
This module provides the :class:`Progress` helper for displaying a
basic ASCII progress bar on the terminal and the internal
``_Advancement`` enum used to render simple spinner-like steps.
The implementation is intentionally minimal and dependency-free so it
can be used in scripts that don't require a heavy progress library.
"""
import logging
import sys
from enum import Enum
_logger = logging.getLogger(__name__)
__all__ = [
"Progress",
]
class _Advancement(Enum):
step_1 = "\\"
step_2 = "-"
step_3 = "/"
step_4 = "|"
@staticmethod
def getNextStep(step):
if step is _Advancement.step_1:
return _Advancement.step_2
elif step is _Advancement.step_2:
return _Advancement.step_3
elif step is _Advancement.step_3:
return _Advancement.step_4
else:
return _Advancement.step_1
@staticmethod
def getStep(value):
if value % 4 == 0:
return _Advancement.step_4
elif value % 3 == 0:
return _Advancement.step_3
elif value % 2 == 0:
return _Advancement.step_2
else:
return _Advancement.step_1
class Progress(object):
"""Simple interface for defining advancement on a 100 percentage base"""
def __init__(self, name):
self._name = name
self.reset()
def reset(self, max_=None):
self._nProcessed = 0
self._maxProcessed = max_
def startProcess(self):
self.setAdvancement(0)
def setAdvancement(self, value):
length = 20 # modify this to change the length
block = int(round(length * value / 100))
msg = f"\r{self._name}: [{'#' * block + '-' * (length - block)}] {round(value, 2)}%"
if value >= 100:
msg += " DONE\r\n"
sys.stdout.write(msg)
sys.stdout.flush()
def endProcess(self):
self.setAdvancement(100)
def setMaxAdvancement(self, n):
self._maxProcessed = n
def increaseAdvancement(self, i=1):
self._nProcessed += i
self.setAdvancement((self._nProcessed / self._maxProcessed) * 100)
tomobase-v0.0.0.dev1/tomobase/utils/ 0000775 0001751 0001752 00000000000 15237630637 020324 5 ustar blagandzig blagandzig tomobase-v0.0.0.dev1/tomobase/utils/io.py 0000664 0001751 0001752 00000013065 15237630637 021312 0 ustar blagandzig blagandzig from __future__ import annotations
import functools
import io
import logging
import os
import traceback
from contextlib import contextmanager
import numpy
from silx.io.utils import open as hdf5_open
_logger = logging.getLogger(__name__)
depreclog = logging.getLogger("tomoscan.DEPRECATION")
deprecache = set([])
def deprecated_warning(
type_,
name,
reason=None,
replacement=None,
since_version=None,
only_once=True,
skip_backtrace_count=0,
):
"""
Function to log a deprecation warning
:param type_: Nature of the object to be deprecated:
"Module", "Function", "Class" ...
:param name: Object name.
:param reason: Reason for deprecating this function
(e.g. "feature no longer provided",
:param replacement: Name of replacement function (if the reason for
deprecating was to rename the function)
:param since_version: First version for which the function was
deprecated (e.g. "0.5.0").
:param only_once: If true, the deprecation warning will only be
generated one time for each different call locations. Default is true.
:param skip_backtrace_count: Amount of last backtrace to ignore when
logging the backtrace
"""
if not depreclog.isEnabledFor(logging.WARNING):
return
msg = "%s %s is deprecated"
if since_version is not None:
msg += " since version %s" % since_version
msg += "."
if reason is not None:
msg += " Reason: %s." % reason
if replacement is not None:
msg += " Use '%s' instead." % replacement
msg += "\n%s"
limit = 2 + skip_backtrace_count
backtrace = "".join(traceback.format_stack(limit=limit)[0])
backtrace = backtrace.rstrip()
if only_once:
data = (msg, type_, name, backtrace)
if data in deprecache:
return
else:
deprecache.add(data)
depreclog.warning(msg, type_, name, backtrace)
def deprecated(
func=None,
reason=None,
replacement=None,
since_version=None,
only_once=True,
skip_backtrace_count=1,
):
"""
Decorator that deprecates the use of a function
:param reason: Reason for deprecating this function
(e.g. "feature no longer provided",
:param replacement: Name of replacement function (if the reason for
deprecating was to rename the function)
:param since_version: First version for which the function was
deprecated (e.g. "0.5.0").
:param only_once: If true, the deprecation warning will only be
generated one time. Default is true.
:param skip_backtrace_count: Amount of last backtrace to ignore when
logging the backtrace
"""
def decorator(func):
@functools.wraps(func)
def wrapper(*args, **kwargs):
deprecated_warning(
type_="Function",
name=func.__name__,
reason=reason,
replacement=replacement,
since_version=since_version,
only_once=only_once,
skip_backtrace_count=skip_backtrace_count,
)
return func(*args, **kwargs)
return wrapper
if func is not None:
return decorator(func)
return decorator
def filter_esrf_mounting_points(path: str):
"""
filter path like '/mnt/multipath-shares' or '/gpfs/easy'
"""
parts = path.split(os.sep)
if len(parts) > 4:
if parts[0] == "" and parts[1] in ("gpfs", "mnt"):
new_parts = list(parts[0:1]) + list(parts[3:])
path = os.sep.join(new_parts)
return path
@contextmanager
def catch_log_messages(logger_name=depreclog.name, level=logging.WARNING):
log_capture = io.StringIO()
logger = logging.getLogger(logger_name)
handler = logging.StreamHandler(log_capture)
handler.setLevel(level)
logger.addHandler(handler)
try:
yield log_capture
finally:
logger.removeHandler(handler)
def check_virtual_sources_exist(fname, data_path):
"""
Check that a virtual dataset points to actual data.
:param fname: HDF5 file path
:param data_path: Path within the HDF5 file
:return bool res: Whether the virtual dataset points to actual data.
"""
with hdf5_open(fname) as f:
if data_path not in f:
_logger.error(f"No dataset {data_path} in file {fname}")
return False
dptr = f[data_path]
if not dptr.is_virtual:
return True
for vsource in dptr.virtual_sources():
vsource_fname = os.path.join(
os.path.dirname(dptr.file.filename), vsource.file_name
)
if not os.path.isfile(vsource_fname):
_logger.error(f"No such file: {vsource_fname}")
return False
elif not check_virtual_sources_exist(vsource_fname, vsource.dset_name):
_logger.error(f"Error with virtual source {vsource_fname}")
return False
return True
def cast_to_default_types(data: any):
"""Function that cast non default python types to default python type"""
if isinstance(data, dict):
return {key: cast_to_default_types(value) for key, value in data.items()}
elif isinstance(data, (list, tuple)):
return [cast_to_default_types(item) for item in data]
elif isinstance(data, (numpy.integer, numpy.int_)):
return int(data)
elif isinstance(data, numpy.floating):
return float(data)
elif isinstance(data, numpy.ndarray):
return data.tolist()
elif isinstance(data, numpy.bool_):
return bool(data)
else:
return data
tomobase-v0.0.0.dev1/tomobase/utils/hdf5.py 0000664 0001751 0001752 00000004415 15237630637 021530 0 ustar blagandzig blagandzig import contextlib
from os import path
import h5py
from silx.io.url import DataUrl
from silx.io.utils import open as hdf5_open
class _BaseReader(contextlib.AbstractContextManager):
def __init__(self, url: DataUrl):
if not isinstance(url, DataUrl):
raise TypeError(f"url should be an instance of DataUrl. Not {type(url)}")
if url.scheme() not in ("silx", "h5py"):
raise ValueError("Valid scheme are silx and h5py")
if url.data_slice() is not None:
raise ValueError(
"Data slices are not managed. Data path should "
"point to a bliss node (h5py.Group)"
)
self._url = url
self._file_handler = None
def __exit__(self, *exc):
return self._file_handler.close()
class DatasetReader(_BaseReader):
"""Context manager used to read a bliss node"""
def __enter__(self):
self._file_handler = hdf5_open(filename=self._url.file_path())
entry = self._file_handler[self._url.data_path()]
if not isinstance(entry, h5py.Dataset):
raise ValueError(
f"Data path ({self._url.path()}) should point to a dataset (h5py.Dataset)"
)
return entry
def get_data_sources(fname: str, data_path: str, recursive=True) -> dict:
"""
Return the nested dict of data_sources.
Key are (source) file path and keys are identical dict or data_path to the source
:param recursive: If True then go trhough all linked files else won't 'solve' link
"""
with hdf5_open(fname) as f:
if data_path not in f:
return None
dptr = f[data_path]
if not dptr.is_virtual:
return {fname: data_path}
sources = {}
for vsource in dptr.virtual_sources():
vsource_fname = path.normpath(
path.join(path.dirname(dptr.file.filename), vsource.file_name)
)
if not path.isfile(vsource_fname):
sources[vsource_fname] = None
if recursive:
sources[path.normpath(vsource_fname)] = get_data_sources(
vsource_fname, vsource.dset_name
)
else:
sources[path.normpath(vsource_fname)] = vsource.dset_name
return sources
tomobase-v0.0.0.dev1/tomobase/utils/decorator.py 0000664 0001751 0001752 00000002140 15237630637 022655 0 ustar blagandzig blagandzig import functools
def _docstring(dest, origin):
"""Implementation of docstring decorator.
It patches dest.__doc__.
"""
if not isinstance(dest, type) and isinstance(origin, type):
# func is not a class, but origin is, get the method with the same name
try:
origin = getattr(origin, dest.__name__)
except AttributeError:
raise ValueError(f"origin class has no {dest.__name__} method")
dest.__doc__ = origin.__doc__
return dest
def docstring(origin):
"""Decorator to initialize the docstring from another source.
This is useful to duplicate a docstring for inheritance and composition.
If origin is a method or a function, it copies its docstring.
If origin is a class, the docstring is copied from the method
of that class which has the same name as the method/function
being decorated.
:param origin:
The method, function or class from which to get the docstring
:raises ValueError:
If the origin class has not method n case the
"""
return functools.partial(_docstring, origin=origin)
tomobase-v0.0.0.dev1/tomobase/utils/__init__.py 0000664 0001751 0001752 00000000340 15237630637 022432 0 ustar blagandzig blagandzig """General utils"""
from .decorator import docstring # noqa F401
import numpy
def is_numpy_scalar_dtype(par):
try:
numpy.dtype(par)
res = True
except TypeError:
res = False
return res
tomobase-v0.0.0.dev1/tomobase/utils/url.py 0000664 0001751 0001752 00000002076 15237630637 021505 0 ustar blagandzig blagandzig # coding: utf-8
import numpy
class UrlSettings:
FILE_PATH_KEY = "file_path"
DATA_PATH_KEY = "path"
FILE_PREFIX = "file_prefix"
def split_query(query: str) -> dict:
result = dict()
for s in query.split("&"):
if not s:
continue
name, _, value = s.partition("=")
prev_value = result.get(name)
if prev_value:
value = join_string(prev_value, value, "/")
result[name] = value
return result
def join_query(
query_items: list[tuple[str, str]] | tuple[tuple[str, str], ...] | numpy.ndarray,
) -> str:
return "&".join(f"{k}={v}" for k, v in query_items)
def join_string(a: str, b: str, sep: str):
aslash = a.endswith(sep)
bslash = b.startswith(sep)
if aslash and bslash:
return a[:-1] + b
elif aslash or bslash:
return a + b
else:
return a + sep + b
def join_path(path_items: tuple) -> str:
if not isinstance(path_items, tuple):
raise TypeError
return ":".join(path_items)
def split_path(path: str):
return path.split(":")
tomobase-v0.0.0.dev1/tomobase/identifiers/ 0000775 0001751 0001752 00000000000 15237630637 021471 5 ustar blagandzig blagandzig tomobase-v0.0.0.dev1/tomobase/identifiers/base.py 0000664 0001751 0001752 00000002033 15237630637 022753 0 ustar blagandzig blagandzig """Module dedicated to identifiers. Identifiers allow to retrieve an object (scan or volume) from an url - identifier"""
class BaseIdentifier:
TOMO_TYPE = None
def __init__(self, object):
self._dataset_builder = object.from_identifier
@property
def tomo_type(self):
return self.TOMO_TYPE
def recreate_object(self):
"""Recreate the dataset from the identifier"""
return self._dataset_builder(self)
def short_description(self) -> str:
"""short description of the identifier"""
return ""
@property
def scheme(self) -> str:
raise NotImplementedError("Base class")
def to_str(self):
return str(self)
@staticmethod
def from_str(identifier):
raise NotImplementedError("base class")
def __eq__(self, __o: object) -> bool:
if isinstance(__o, BaseIdentifier):
return __o.to_str() == self.to_str()
elif isinstance(__o, str):
return __o == self.to_str()
else:
return False
tomobase-v0.0.0.dev1/tomobase/identifiers/__init__.py 0000664 0001751 0001752 00000000505 15237630637 023602 0 ustar blagandzig blagandzig """Identifier helpers to locate and reconstruct tomo objects.
Identifiers are small objects that encode how to re-create a
tomographic object (scan or volume). This package exposes base
identifier classes and mixins for common identifier types (HDF5,
folder-based, etc.).
"""
from .base import BaseIdentifier # noqa: F401
tomobase-v0.0.0.dev1/tomobase/identifiers/folderidentifiers.py 0000664 0001751 0001752 00000010116 15237630637 025543 0 ustar blagandzig blagandzig # coding: utf-8
import os
from urllib.parse import ParseResult, urlparse
from tomobase.utils.url import (
UrlSettings,
join_path,
join_query,
split_path,
split_query,
)
__all__ = ["BaseFolderIdentifierMixIn", "BaseFolderAndfilePrefixIdentifierMixIn"]
class BaseFolderIdentifierMixIn:
"""Identifier specific to a folder. Used for single frame edf and jp2g for example"""
def __init__(self, object, folder, tomo_type):
super().__init__(object)
self._folder = os.path.abspath(os.path.abspath(folder))
self.__tomo_type = tomo_type
def short_description(self) -> str:
return ParseResult(
scheme=self.scheme,
path=join_path((self.tomo_type, os.path.basename(self.folder))),
query=None,
netloc=None,
params=None,
fragment=None,
).geturl()
@property
def tomo_type(self):
# warning: this property will probably be overwrite
return self.__tomo_type
@property
def folder(self):
return self._folder
@property
def scheme(self) -> str:
raise NotImplementedError("base class")
def __str__(self):
return ParseResult(
scheme=self.scheme,
path=join_path((self.tomo_type, self.folder)),
query=None,
netloc=None,
params=None,
fragment=None,
).geturl()
def __eq__(self, other):
if isinstance(other, BaseFolderIdentifierMixIn):
return self.folder == other.folder and self.tomo_type == other.tomo_type
else:
return super().__eq__(other)
def __hash__(self):
return hash(self.folder)
class BaseFolderAndfilePrefixIdentifierMixIn(BaseFolderIdentifierMixIn):
def __init__(self, object, folder, file_prefix, tomo_type):
super().__init__(object, folder, tomo_type)
self._file_prefix = file_prefix
def short_description(self) -> str:
query = []
if self.file_prefix not in (None, ""):
query.append(
("file_prefix", self.file_prefix),
)
return ParseResult(
scheme=self.scheme,
path=join_path((self.tomo_type, self.folder)),
query=join_query(query),
netloc=None,
params=None,
fragment=None,
).geturl()
@property
def file_prefix(self) -> str:
return self._file_prefix
def __str__(self):
query = []
if self.file_prefix not in (None, ""):
query.append(
("file_prefix", self.file_prefix),
)
return ParseResult(
scheme=self.scheme,
path=join_path((self.tomo_type, self.folder)),
query=join_query(query),
netloc=None,
params=None,
fragment=None,
).geturl()
def __eq__(self, other):
return super().__eq__(other) and self.file_prefix == other.file_prefix
def __hash__(self):
return hash(self.folder) + hash(self.file_prefix)
@staticmethod
def _from_str_to_single_frame_identifier(
identifier: str, SingleFrameIdentifierClass, ObjClass: type
):
"""
Common function to build an identifier from a str. Might be moved to the factory directly one day ?
"""
info = urlparse(identifier)
paths = split_path(info.path)
if len(paths) == 1:
jp2k_folder = paths[0]
tomo_type = None
elif len(paths) == 2:
tomo_type, jp2k_folder = paths
else:
raise ValueError("Failed to parse path string:", info.path)
if tomo_type is not None and tomo_type != SingleFrameIdentifierClass.TOMO_TYPE:
raise TypeError(
f"provided identifier fits {tomo_type} and not {SingleFrameIdentifierClass.TOMO_TYPE}"
)
queries = split_query(info.query)
file_prefix = queries.get(UrlSettings.FILE_PREFIX, None)
return SingleFrameIdentifierClass(
object=ObjClass, folder=jp2k_folder, file_prefix=file_prefix
)
tomobase-v0.0.0.dev1/tomobase/identifiers/hdf5identifier.py 0000664 0001751 0001752 00000004372 15237630637 024742 0 ustar blagandzig blagandzig # coding: utf-8
import os
from urllib.parse import ParseResult
from tomobase.identifiers.base import BaseIdentifier
from tomobase.utils import docstring
from tomobase.utils.url import UrlSettings, join_path, join_query
__all__ = ["HDF5IdentifierMixIn"]
class HDF5IdentifierMixIn:
"""Shared logic for identifiers pointing to an entry inside an HDF5 file.
Used by both scan identifiers (e.g. tomoscan's NXtomoScanIdentifier) and
volume identifiers (e.g. volio's HDF5VolumeIdentifier).
"""
def __init__(self, object, hdf5_file, entry, tomo_type):
super().__init__(object)
self._file_path = os.path.abspath(os.path.abspath(hdf5_file))
self._data_path = entry
self._tomo_type = tomo_type
@property
def tomo_type(self):
return self._tomo_type
@docstring(BaseIdentifier)
def short_description(self) -> str:
return ParseResult(
scheme=self.scheme,
path=join_path(
(self.tomo_type, os.path.basename(self._file_path)),
),
query=join_query(
((UrlSettings.DATA_PATH_KEY, self.data_path),),
),
netloc=None,
params=None,
fragment=None,
).geturl()
@property
def file_path(self):
return self._file_path
@property
def data_path(self):
return self._data_path
@property
@docstring(BaseIdentifier)
def scheme(self) -> str:
return "hdf5"
def __str__(self):
return ParseResult(
scheme=self.scheme,
path=join_path(
(self.tomo_type, self._file_path),
),
query=join_query(
((UrlSettings.DATA_PATH_KEY, self.data_path),),
),
netloc=None,
params=None,
fragment=None,
).geturl()
def __eq__(self, other):
if isinstance(other, HDF5IdentifierMixIn):
return (
self.tomo_type == other.tomo_type
and self._file_path == other._file_path
and self._data_path == other._data_path
)
else:
return super().__eq__(other)
def __hash__(self):
return hash((self._file_path, self._data_path))
tomobase-v0.0.0.dev1/tomobase/tomoobject.py 0000664 0001751 0001752 00000003166 15237630637 021711 0 ustar blagandzig blagandzig # coding: utf-8
"""Base interfaces for tomographic objects.
This module defines :class:`TomoObject`, the abstract base interface for
objects representing tomographic data (scans or volumes). Concrete
implementations should provide methods to build identifiers, obtain
bounding boxes and to materialise objects from identifiers.
"""
from __future__ import annotations
from tomobase.geometry import BoundingBox1D
from .identifiers import BaseIdentifier
__all__ = [
"TomoObject",
]
class TomoObject:
"""Parent class of all tomographic object in tomoscan"""
@staticmethod
def from_identifier(identifier: str | BaseIdentifier):
"""Return the Dataset from a identifier"""
raise NotImplementedError("Base class")
def get_identifier(self) -> BaseIdentifier:
"""dataset unique identifier. Can be for example a hdf5 and
en entry from which the dataset can be rebuild"""
raise NotImplementedError("Base class")
def get_bounding_box(self, axis: str | int | None = None) -> BoundingBox1D:
"""
Return the bounding box covered by the Tomo object
axis is expected to be in (0, 1, 2) or (x==0, y==1, z==2)
"""
raise NotImplementedError("Base class")
def build_drac_metadata(self) -> dict:
"""
build icat metadata dictionary filling NXtomo definition following icat definition
"""
raise NotImplementedError()
def clear_cache(self) -> None:
"""
A TomoObj can have some values store in the cache (some metadata read for example).
This function should clear all caches.
"""
pass
tomobase-v0.0.0.dev1/tomobase/__init__.py 0000664 0001751 0001752 00000000705 15237630637 021277 0 ustar blagandzig blagandzig """Top-level package for tomobase.
This package provides lightweight helpers and base classes used by
tomography-related tools: identifiers for locating datasets, small
geometry utilities (bounding boxes and shapes), and base interfaces
for tomographic objects and series collections.
Keep this module minimal: the public API lives in the submodules.
"""
from importlib.metadata import version as _get_version
__version__ = _get_version("tomobase")
tomobase-v0.0.0.dev1/tomobase/source.py 0000664 0001751 0001752 00000003732 15237630637 021043 0 ustar blagandzig blagandzig """Information regarding beamline or radiation sources used for scans.
This module defines the :class:`SourceType` enumeration describing common
beamline and source types (synchrotron, reactor, laser, etc.) and the
:class:`Source` helper that stores a source `name` and `type`.
"""
from __future__ import annotations
from enum import Enum
class SourceType(Enum):
SPALLATION_NEUTRON = "Spallation Neutron Source"
PULSED_REACTOR_NEUTRON_SOURCE = "Pulsed Reactor Neutron Source"
REACTOR_NEUTRON_SOURCE = "Reactor Neutron Source"
SYNCHROTRON_X_RAY_SOURCE = "Synchrotron X-ray Source"
PULSED_MUON_SOURCE = "Pulsed Muon Source"
ROTATING_ANODE_X_RAY = "Rotating Anode X-ray"
FIXED_TUBE_X_RAY = "Fixed Tube X-ray"
UV_LASER = "UV Laser"
FREE_ELECTRON_LASER = "Free-Electron Laser"
OPTICAL_LASER = "Optical Laser"
ION_SOURCE = "Ion Source"
UV_PLASMA_SOURCE = "UV Plasma Source"
METAL_JET_X_RAY = "Metal Jet X-ray"
class Source:
"""Small container for metadata about the experimental source.
The :class:`Source` object stores a human-readable `name` and a
`type` drawn from :class:`SourceType`. It is intentionally lightweight
and used as metadata attached to higher-level objects.
"""
def __init__(self, name=None, type=None):
self._name = name
self._type = type
@property
def name(self) -> str | None:
return self._name
@name.setter
def name(self, name: str | None):
if not isinstance(name, (str, type(None))):
raise TypeError("name is expected to be None or a str")
self._name = name
@property
def type(self) -> SourceType | None:
return self._type
@type.setter
def type(self, type_: str | SourceType | None):
if type_ is None:
self._type = None
else:
type_ = SourceType(type_)
self._type = type_
def __str__(self):
return f"source (name: {self.name}, type: {self.type})"
tomobase-v0.0.0.dev1/tomobase/coordinatesystem.py 0000664 0001751 0001752 00000001027 15237630637 023132 0 ustar blagandzig blagandzig from enum import Enum
class CoordinateSystem(Enum):
"""
* ESRF coordinate system::
Z axis
^ Y axis
| /
x-ray |/
--------> ------> X axis
* McStas coordinate system::
Y axis
^ X axis
| /
x-ray | /
--------> ------> Z axis
"""
McStas = "McStas"
ESRF = "ESRF"
tomobase-v0.0.0.dev1/CHANGELOG.md 0000664 0001751 0001752 00000001547 15237630637 017173 0 ustar blagandzig blagandzig # Changelog
All notable changes to this project will be documented in this file.
The format follows the [Keep a Changelog](https://keepachangelog.com/en/1.0.0/) conventions and this project adheres to [Semantic Versioning 2.0.0](https://semver.org/spec/v2.0.0.html).
## [0.0.0dev0] - Unreleased
### Added
- Initial extraction of `tomobase` from `tomoscan` (2.5.1): common base classes and utilities shared by `tomoscan` (>=3.0.0) and the new `volio` package.
- `TomoObject`, `BaseIdentifier`, `BaseFolderIdentifierMixIn`/`BaseFolderAndfilePrefixIdentifierMixIn`, `HDF5IdentifierMixIn`.
- `Series`, `Source`, `Progress`, `CoordinateSystem`.
- `utils.io` (`deprecated`, `deprecated_warning`, `filter_esrf_mounting_points`), `utils.geometry` (`BoundingBox1D`, `BoundingBox3D`), `utils.decorator` (`docstring`), `utils.hdf5` (`DatasetReader`, `get_data_sources`).