{ "cells": [ { "cell_type": "markdown", "id": "b48c6c14-8d8f-4355-9ec7-fc0391af5d88", "metadata": {}, "source": [ "# Using HDF5 file(s) as a database\n", "\n", "HDF files can be considered databases itself, however `h5py` does not implementation query functions. This chapter will take you through everything you need to know to find data within one or more HDF5 files based on attributes or properties. The explanation will be conducted using practical examples.\n", "\n", "In addition to the normal import, we will need some tutorial data:" ] }, { "cell_type": "code", "execution_count": 1, "id": "2b901cbd-b051-49c0-a82c-1c31ecda5ea6", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "using(\"h5py\")" ] }, "execution_count": 1, "metadata": {}, "output_type": "execute_result" } ], "source": [ "import h5rdmtoolbox as h5tbx\n", "from h5rdmtoolbox import tutorial\n", "\n", "h5tbx.use(None)" ] }, { "cell_type": "markdown", "id": "1daa3eeb-b33a-4c31-82e6-8a428aed276e", "metadata": {}, "source": [ "## Test file\n", "\n", "Throughout this section the following test file will be used:" ] }, { "cell_type": "code", "execution_count": 2, "id": "b02c0d3b-1695-4106-afe6-808f54118190", "metadata": {}, "outputs": [ { "data": { "text/html": [ "\n", "
\n", "\n", " \n", "
" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "filename = tutorial.generate_sample_file()\n", "h5tbx.dump(filename)" ] }, { "cell_type": "markdown", "id": "8c851066-f76d-4ef4-bf91-29cff0334ad0", "metadata": {}, "source": [ "## Attribute search\n", "\n", "HDF attribute generally are describing groups or datasets and hence are ideal to search for.\n", "\n", "One such attribute used in the test file is \"standard_name\". The `find` methods uses a filter argument `flt` of type dictionary, similar to MongoDB syntax. The return value will be a list of (lazy) objects:" ] }, { "cell_type": "code", "execution_count": 3, "id": "5dc95dce-4d20-4c72-a95c-a6c4412ca87b", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[,\n", " ,\n", " ]" ] }, "execution_count": 3, "metadata": {}, "output_type": "execute_result" } ], "source": [ "with h5tbx.File(filename) as h5:\n", " res = h5.find(flt={'standard_name': 'velocity', 'units': 'm/s'})\n", "\n", "res" ] }, { "cell_type": "markdown", "id": "7c8040d8-f92e-43d6-b419-d64ca575c602", "metadata": {}, "source": [ "If we are only interested in the first occurrence, then `find_one` should be used." ] }, { "cell_type": "code", "execution_count": 4, "id": "9b97388f-9611-4b29-b5ed-2140dcf8a50b", "metadata": {}, "outputs": [], "source": [ "with h5tbx.File(filename) as h5:\n", " res = h5.find_one(flt={'standard_name': 'velocity', 'units': 'm'})\n", "\n", "res" ] }, { "cell_type": "markdown", "id": "1ee608f2-d157-4d3b-a040-1c7a2a481609", "metadata": {}, "source": [ "Both function are also part of the `database` module and can be called on HDF5 filenames:" ] }, { "cell_type": "code", "execution_count": 5, "id": "71403092-3576-4bef-943b-1c2ef0b0d9f2", "metadata": {}, "outputs": [], "source": [ "res_find = h5tbx.database.find(filename, flt={'standard_name': 'velocity'})\n", "assert len(res_find) == 3\n", "res_one = h5tbx.database.find_one(filename, flt={'standard_name': 'velocity'})" ] }, { "cell_type": "markdown", "id": "6adf80f8-05a2-40e2-9d91-42873b3b69c3", "metadata": {}, "source": [ "### Property search\n", "\n", "It might be reasonable to search for properties of HDF5 objects, like a specific shape, dimension etc.. For this, a dollar sign must be added to the property name:" ] }, { "cell_type": "code", "execution_count": 6, "id": "527ea4af-3835-4fd7-ad33-b1be2d8a9067", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[]" ] }, "execution_count": 6, "metadata": {}, "output_type": "execute_result" } ], "source": [ "h5tbx.database.find(filename, flt={'$ndim': 0})" ] }, { "cell_type": "markdown", "id": "c2c4a51b-8e05-4b03-8f08-07761e27eeb1", "metadata": {}, "source": [ "Let's search for all velocity datasets in the file. Velocity datasets are indicated by the attribute \"standard_name\":" ] }, { "cell_type": "code", "execution_count": 7, "id": "3e448312-2217-4fc7-9bc6-f985c11f353b", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[,\n", " ,\n", " ]" ] }, "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ "with h5tbx.File(filename) as h5:\n", " res = h5.find(flt={'standard_name': 'velocity'})\n", "\n", "res" ] }, { "cell_type": "markdown", "id": "33114158-befc-42e5-b194-6cfbd5c1278d", "metadata": {}, "source": [ "If we are only interested in the **first** occurrence, then `find_one()` does the job:" ] }, { "cell_type": "code", "execution_count": 8, "id": "e366fa76-ed31-41eb-8832-3c61e87d65fa", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 8, "metadata": {}, "output_type": "execute_result" } ], "source": [ "with h5tbx.File(filename) as h5:\n", " res = h5.find_one(flt={'standard_name': 'velocity'})\n", "\n", "res" ] }, { "cell_type": "markdown", "id": "a08e59ad-4b63-45a7-8569-67cdcbd70d7e", "metadata": {}, "source": [ "## Object filter\n", "By providing `objfilter=dataset` or `objfilter=group` only those type of objects are include in the result:" ] }, { "cell_type": "code", "execution_count": 9, "id": "88bbc524-8490-4c54-b581-4f5524229621", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[,\n", " ,\n", " ]" ] }, "execution_count": 9, "metadata": {}, "output_type": "execute_result" } ], "source": [ "h5tbx.database.find(filename, flt={'check_value': {'$exists': True}}, objfilter='group')" ] }, { "cell_type": "markdown", "id": "aecfcbff-e72a-4d57-88b4-304b036f743c", "metadata": {}, "source": [ "## Special operators\n", "\n", "### \"$exists\"\n", "\n", "In the below example, all objects that have an attribute \"units\" are returned" ] }, { "cell_type": "code", "execution_count": 10, "id": "bf6623ab-599a-46af-8636-fed29453935e", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[,\n", " ,\n", " ,\n", " ,\n", " ,\n", " ]" ] }, "execution_count": 10, "metadata": {}, "output_type": "execute_result" } ], "source": [ "results = h5tbx.database.find(filename, {'units': {'$exists': True}})\n", "results" ] }, { "cell_type": "markdown", "id": "ed73ecb3-9f78-44ff-8fa2-e42069439a56", "metadata": {}, "source": [ "### $regex\n", "\n", "Regex expressions are usefull to find objects by path name pattern:" ] }, { "cell_type": "code", "execution_count": 11, "id": "e78ad508-b931-4234-aa73-6ea8b0c3e0fb", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[,\n", " ,\n", " ]" ] }, "execution_count": 11, "metadata": {}, "output_type": "execute_result" } ], "source": [ "results = h5tbx.database.find(filename, {'$name': {'$regex': '^.*/velocity$'}})\n", "results" ] }, { "cell_type": "markdown", "id": "f9f8de61-3ffc-4521-afaf-0b30169f1595", "metadata": {}, "source": [ "### $basename\n", "\n", "\"Basename\" is not a property but could be useful. It is implemented as an \"virtual property\": " ] }, { "cell_type": "code", "execution_count": 12, "id": "c540fbb1-a8a5-461a-8289-307507fe2705", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[]" ] }, "execution_count": 12, "metadata": {}, "output_type": "execute_result" } ], "source": [ "results = h5tbx.database.find(filename, {'$basename': 'pressure2'})\n", "results" ] }, { "cell_type": "markdown", "id": "75fd3bad-f6d9-4972-b161-6cb43e74586d", "metadata": {}, "source": [ "### Mathematical operation (>, >=, <, <=)\n", "\n", "The datasets and groups in the example files all have the attribute \"check_value\", let's identify objects that match certain values of this attribute:" ] }, { "cell_type": "code", "execution_count": 13, "id": "3570e4df-96e9-4180-8c4a-a877cbe1f683", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "object names with check value greater than 0.1:\n", " /group2/velocity\n", " /velocity\n", "\n", "object names with check value equal to 0:\n", " /group2\n", " /group1\n", " /\n", "\n", "object names with check value lower equal -3.3:\n", " /pressure1\n", " /group2/pressure2\n" ] } ], "source": [ "print('object names with check value greater than 0.1:')\n", "\n", "results = h5tbx.database.find(filename, {'check_value': {'$gt': 0.1}})\n", "for r in results:\n", " print(' ', r.name)\n", "\n", "\n", "print('\\nobject names with check value equal to 0:')\n", "\n", "results = h5tbx.database.find(filename, {'check_value': {'$eq': 0}})\n", "for r in results:\n", " print(' ', r.name)\n", "\n", "\n", "print('\\nobject names with check value lower equal -3.3:')\n", "\n", "\n", "results = h5tbx.database.find(filename, {'check_value': {'$lte': -3.3}})\n", "for r in results:\n", " print(' ', r.name)" ] }, { "cell_type": "markdown", "id": "79ee7e4d-558d-47c7-8aa0-fe467f51013a", "metadata": {}, "source": [ "### User-defined operator\n", "\n", "Let's take the regex example and turn it into a new operator:\n", "\n", "The regex query filter `\"{'$name': {'$regex': '^.*/velocity$'}}\"` means, that we are looking for \"basenames\" of objects, so not the full internal HDF5 path but the name.\n", "\n", "All operator functions are stored in `database.hdfdb.query`. In fact, the `\"$basename\"`-operator exists, so we first delete it and add it again by our own function:" ] }, { "cell_type": "code", "execution_count": 14, "id": "2e449ad3-79fd-4fdc-ba63-e347daedf856", "metadata": {}, "outputs": [], "source": [ "from h5rdmtoolbox.database.hdfdb import query\n", "\n", "# note, all operator functions are stored in this dictionary: query.operator\n", "query.operator.pop('$basename', None) # remove existing operator\n", "\n", "def my_basename_operator(obj_name, basename) -> bool:\n", " \"\"\"calling regex under the hood\"\"\"\n", " print(f'Checking if basename of object name \"{obj_name}\" is matching pattern \"^.*/{basename}$\"')\n", " return query._regex(obj_name, pattern=f'^.*/{basename}$')\n", "\n", "query.operator['$basename'] = my_basename_operator" ] }, { "cell_type": "code", "execution_count": 15, "id": "46d22550-5697-4a10-a761-4a74c1023c2b", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Checking if basename of object name \"/group1/velocity\" is matching pattern \"^.*/velocity$\"\n", "Checking if basename of object name \"/group2/pressure2\" is matching pattern \"^.*/velocity$\"\n", "Checking if basename of object name \"/group2/velocity\" is matching pattern \"^.*/velocity$\"\n", "Checking if basename of object name \"/group2/z\" is matching pattern \"^.*/velocity$\"\n", "Checking if basename of object name \"/pressure1\" is matching pattern \"^.*/velocity$\"\n", "Checking if basename of object name \"/velocity\" is matching pattern \"^.*/velocity$\"\n", "/group2/velocity\n", "/group1/velocity\n", "/velocity\n" ] } ], "source": [ "results = h5tbx.database.find(filename, {'$name': {'$basename': 'velocity'}}, 'dataset')\n", "\n", "for r in results:\n", " print(r.name)" ] }, { "cell_type": "markdown", "id": "cd2cd861-498d-43ce-8fb5-150a525af43c", "metadata": {}, "source": [ "**Working with the results**\n", "\n", "Let's investigate the return values of queries. The method `find_one` returns a so-called \"lazy\" object, and the `find` method a generator of this class." ] }, { "cell_type": "code", "execution_count": 16, "id": "39bc56e7-19b4-489f-abbd-f343976777d5", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Checking if basename of object name \"/group1/velocity\" is matching pattern \"^.*/velocity$\"\n", "Checking if basename of object name \"/group2/pressure2\" is matching pattern \"^.*/velocity$\"\n", "Checking if basename of object name \"/group2/velocity\" is matching pattern \"^.*/velocity$\"\n", "Checking if basename of object name \"/group2/z\" is matching pattern \"^.*/velocity$\"\n", "Checking if basename of object name \"/pressure1\" is matching pattern \"^.*/velocity$\"\n", "Checking if basename of object name \"/velocity\" is matching pattern \"^.*/velocity$\"\n" ] }, { "data": { "text/plain": [ "[]" ] }, "execution_count": 16, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "results = h5tbx.database.find_one(filename, {'$name': {'$basename': 'velocity'}}, 'dataset')\n", "\n", "# let's directly plot the result:\n", "results[()].plot(marker='o')" ] } ], "metadata": { "kernelspec": { "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.8.19" } }, "nbformat": 4, "nbformat_minor": 5 }