osiris-utils 1.1.6__py3-none-any.whl → 1.1.8__py3-none-any.whl

docs/source/api/sim_diag.rst

@@ -0,0 +1,257 @@
+Simulation Interface
+====================
+
+.. _simulation-api:
+
+The `Simulation` class provides a high-level interface for handling OSIRIS simulation data and accessing various diagnostics.
+
+Simulation Class
+----------------
+
+.. autoclass:: osiris_utils.data.simulation.Simulation
+   :members:
+   :special-members: __init__, __getitem__
+   :undoc-members:
+   :noindex:
+
+   A wrapper class that manages access to multiple diagnostic quantities from an OSIRIS simulation.
+   
+   The Simulation class simplifies working with multiple diagnostics from the same simulation by:
+   
+   * Providing dictionary-style access to diagnostics using field/quantity names
+   * Managing the simulation path and species information centrally
+   * Caching loaded diagnostics for efficient reuse
+   
+   **Key Attributes:**
+   
+   * ``species`` - The plasma species being analyzed
+   * ``simulation_folder`` - Path to the OSIRIS simulation data
+   * ``diagnostics`` - Dictionary of loaded diagnostic objects
+   
+   **Usage Examples:**
+   
+   Basic usage with lazy loading:
+   
+   .. code-block:: python
+   
+       from osiris_utils.data import Simulation
+       
+       # Create a simulation interface for electron data
+       sim = Simulation('path/to/simulation', "name_of_input_deck")
+       
+       # Access the E1 field diagnostic (doesn't load data yet) - this is a Diagnostic object
+       # Since it is a diagnostic not related with the species, the species argument is not needed
+       sim['e1']
+       
+       # For diagnostics related with the species, the species argument is needed
+       sim['electrons']['charge']
+
+       # Load all timesteps for this diagnostic
+       e1_diag.load_all()
+       
+       # The diagnostic is now cached in the simulation object
+       # Access it again without recreating
+       same_e1_diag = sim['e1']
+   
+   Working with multiple diagnostics:
+   
+   .. code-block:: python
+   
+       # Access several diagnostics
+       e1 = sim['e1']
+       e2 = sim['e2']
+       b3 = sim['b3']
+       
+       # Load specific timesteps
+       e1[10:20]  # Load timesteps 10-19
+       
+       # Clean up to free memory
+       sim.delete_diagnostic('e1')
+       sim.delete_all_diagnostics()
+
+Integration with Diagnostics
+----------------------------
+
+The Simulation class works seamlessly with the :ref:`diagnostic-system` system:
+
+1. When you request a diagnostic with ``sim[quantity_name]`` or ``sim[species_name][quantity_name]``, it creates a Diagnostic object
+2. The first time you load data with ``.load_all()`` or indexing, the diagnostic is cached
+3. Subsequent accesses return the cached diagnostic for efficiency
+4. You can explicitly remove diagnostics from the cache to manage memory
+5. ``.load_all()`` loads all timesteps for the diagnostic
+6. To access a single iteration of the quantity, indexing gives you the data for the requested timesteps.
+
+This approach allows for efficient workflow when analyzing large simulations with multiple fields and timesteps.
+
+.. _diagnostic-system:
+
+Diagnostic System
+=================
+
+The `Diagnostic` class is the foundation of osiris_utils data handling, providing access to OSIRIS simulation diagnostics and support for derived quantities.
+
+Diagnostic Base Class
+---------------------
+
+.. autoclass:: osiris_utils.data.diagnostic.Diagnostic
+   :members:
+   :special-members: __init__, __getitem__, __add__, __sub__, __mul__, __truediv__, __pow__
+   :undoc-members:
+   :noindex:
+
+   The core class for accessing and manipulating OSIRIS diagnostic data. This class handles both raw OSIRIS data files and derived data from operations.
+   
+   **Key Features:**
+   
+   * Lazy loading system that only reads data when needed
+   * Support for mathematical operations between diagnostics
+   * Generator-based access for memory-efficient processing
+   * Automatic attribute handling for derived quantities
+   
+   **Key Attributes:**
+   
+   * ``species`` - The plasma species being analyzed (Specie object)
+   * ``dx`` - Grid spacing in each direction
+   * ``nx`` - Number of grid points in each direction
+   * ``x`` - Grid coordinates
+   * ``data`` - The actual diagnostic data (when loaded)
+   * ``dim`` - Dimensionality of the data
+   * ``units`` - Physical units of the data
+   * ``dt`` - Time step between outputs
+   * ``ndump`` - Number of steps between dumps
+   * ``grid`` - Boundaries of the simulation grid in each direction (physical units)
+   * ``name`` - Name of the diagnostic quantity (for quantities directly obtained from OSIRIS data)
+   * ``label`` - LaTeX label for the quantity (for quantities directly obtained from OSIRIS data)
+   * ``axis`` - Axis information
+   * ``maxiter`` - Maximum number of iterations of the diagnostic
+   * ``tunits`` - Time units of the simulation
+
+   
+   **Usage Examples:**
+   
+   Basic loading and access:
+   
+   .. code-block:: python
+   
+       # Create diagnostic for electron charge
+       diag = Diagnostic("/path/to/simulation", species)
+       diag.get_quantity("charge")
+       
+       # Access specific timestep (without loading all data)
+       timestep_5 = diag[5]
+       
+       # Load all timesteps into memory
+       diag.load_all()
+       
+       # Now data is available as an array
+       print(diag.data.shape)
+   
+   Mathematical operations:
+   
+   .. code-block:: python
+   
+       # Operations between diagnostics
+       sim = Simulation("/path/to/simulation", species)
+       e1 = sim["e1"]
+       vfl1 = sim["electron"]["vfl1"]
+       
+       # Create a derived diagnostic without loading data
+       e_times_v = (e1**2 + vfl1**2)**0.5
+       
+       # Access specific timestep of the result (calculated on-demand)
+       timestep_10 = e_times_v[10]
+
+Available Diagnostic Quantities in OSIRIS
+-----------------------------------------
+
+The following diagnostic quantities are available for OSIRIS simulations:
+
+**Field Quantities:**
+
+* ``e1``, ``e2``, ``e3`` - Electric field components
+* ``b1``, ``b2``, ``b3`` - Magnetic field components
+
+**Particle Quantities:**
+
+* ``n`` - Density
+* ``charge`` - Charge density
+* ``j1``, ``j2``, ``j3`` - Current density components
+* ``q1``, ``q2``, ``q3`` - Charge flux components
+
+**Velocity Distribution Quantities:**
+
+* ``vfl1``, ``vfl2``, ``vfl3`` - Flow velocity components
+* ``ufl1``, ``ufl2``, ``ufl3`` - Momentum components
+* Various pressure and temperature tensor components
+
+**Phase Space Quantities:**
+
+* ``p1x1``, ``p1x2``, etc. - Phase space diagnostics
+
+To see all available quantities:
+
+.. code-block:: python
+
+    from osiris_utils.data.diagnostic import which_quantities
+    which_quantities()
+
+Memory-Efficient Processing
+---------------------------
+
+The `Diagnostic` class provides several ways to work with large datasets without loading everything into memory:
+
+1. **Item access with** ``diag[index]`` - Loads only the requested timestep
+2. **Iteration with** ``for timestep in diag:`` - Processes one timestep at a time
+3. **Generator-based operations** - Mathematical operations create new diagnostics without loading data
+
+This lazy evaluation system allows you to work with large simulations that would otherwise exceed available memory.
+
+Visualization Methods
+---------------------
+
+The `Diagnostic` class provides visualization methods for quick inspection of 3D data:
+
+* ``plot_3d()`` - Creates 3D scatter plots of 3D field data
+
+Derived Diagnostics
+-------------------
+
+One of the most powerful features of the Diagnostic system is that new diagnostics can be created through operations on existing ones. These derived diagnostics maintain all the benefits of the base class:
+
+.. code-block:: python
+
+    # Create base diagnostics
+    sim = Simulation("/path/to/simulation", "file_input_deck")
+    e1 = sim["e1"]
+    e2 = sim["e2"] 
+    e3 = sim["e3"]
+    
+    # Create derived diagnostics through operations - e_magnitude and normalized_1 are Diagnostic objects
+    e_magnitude = (e1**2 + e2**2 + e3**2)**0.5  # E-field magnitude
+    normalized_e1 = e1 / e_magnitude            # Normalized E1 component
+    
+    # These are full diagnostics objects that support:
+    # - Lazy loading
+    # - Indexing
+    # - Further operations
+    # - Visualization
+    
+    # Access specific timesteps (calculated on demand)
+    timestep_10 = e_magnitude[10]
+    
+    # Apply mathematical functions
+    import numpy as np
+    log_e_magnitude = np.log10(e_magnitude)
+
+**Automatic Attribute Inheritance**
+
+When creating diagnostics through operations, metadata is intelligently propagated:
+
+1. Grid information (``dx``, ``nx``, ``x``) is preserved
+2. Axis information is maintained
+3. Time information (``dt``, ``ndump``) is maintained
+4. Dimension and array shapes remain consistent, as well as maximum iteration number
+
+**Chaining Operations**
+
+Operations can be chained to create complex derivations.

docs/source/api/utilities.rst

@@ -0,0 +1,254 @@
+Utilities API
+=============
+
+This document provides a reference to the osiris_utils utilities API.
+
+Data Readers Structures
+-----------------------
+
+The package provides several classes for handling different types of OSIRIS data.
+
+OsirisData
+~~~~~~~~~~
+
+.. autoclass:: osiris_utils.data.data.OsirisData
+   :members: dt, dim, time, iter, name, type, verbose
+   :special-members: __init__
+   :noindex:
+   
+   Base class for all OSIRIS data types. All other data classes inherit from this class.
+   
+   **Key Attributes:**
+   
+   * ``dt`` - Time step of the simulation
+   * ``dim`` - Dimensionality of the data
+   * ``time`` - Physical time of the data
+   * ``iter`` - Iteration number
+   * ``name`` - Name of the dataset
+   * ``type`` - Type of the data
+   * ``verbose`` - Verbosity flag for logging
+
+Grid-Based Data
+~~~~~~~~~~~~~~~
+
+.. autoclass:: osiris_utils.data.data.OsirisGridFile
+   :members: grid, nx, dx, x, axis, data, units, label
+   :inherited-members:
+
+   Specialized class for handling grid-based field data such as electromagnetic fields.
+   
+   **Key Attributes:**
+   
+   * ``grid`` - Grid information
+   * ``nx`` - Number of grid points
+   * ``dx`` - Grid spacing
+   * ``x`` - Grid coordinates
+   * ``axis`` - Coordinate labels
+   * ``data`` - The actual field data
+   * ``units`` - Physical units of the data
+   * ``label`` - Data labels for visualization
+
+Particle Data
+~~~~~~~~~~~~~
+
+.. autoclass:: osiris_utils.data.data.OsirisRawFile  
+   :members: raw_to_file_tags  
+   :inherited-members:  
+
+   **Description:**  
+   This class is responsible for reading and structuring raw particle data from an OSIRIS HDF5 file. It provides direct access to raw simulation data, in a structured dictionary format.  
+
+   **Key Attributes:**  
+
+   * ``axis`` - Dictionary where each key is a dataset name, and each value is another dictionary containing
+            name (str): The name of the quantity (e.g., r'x1', r'ene').
+            units (str): The units associated with that dataset in LaTeX (e.g., r'c/\\omega_p', r'm_e c^2').
+            long_name (str): The name of the quantity in LaTeX (e.g., r'x_1', r'En2').
+            dictionary of dictionaries
+   * ``data`` - Dictionary mapping dataset names to their corresponding NumPy arrays.  
+   * ``dim`` - Number of spatial dimensions in the simulation.  
+   * ``dt`` - Simulation time step.  
+   * ``grid`` - Array specifying the min/max coordinates of the simulation box along each axis.  
+   * ``iter`` - Iteration number of the simulation snapshot.  
+   * ``name`` - Name of the particle species in the dataset.  
+   * ``time`` - List containing the simulation time and its associated units.  
+   * ``type`` - Type of the dataset (e.g., "particles" for raw particle data).  
+
+   **Example Usage:**
+
+   .. code-block:: python
+  
+      import osiris_utils as ou  
+      raw = ou.raw = ou.OsirisRawFile("path/to/raw/file.h5")
+      print(raw.data.keys())
+      print(raw.data["x1"][0:10])  # Access x1 position of first 10 particles
+
+   **Methods:**  
+
+   * ``raw_to_file_tags(filename, type="all", n_tags=10, mask=None)``  
+
+     - Converts raw particle data into a `file_tags` format, used for selecting particles in OSIRIS tracking diagnostics.  
+
+     - **Parameters:**  
+
+       - ``filename`` (str): Path to the output tag file.  
+       - ``type`` (str, optional): Selection mode (`"all"` for all tags, `"random"` for a random subset).  
+       - ``n_tags`` (int, optional): Number of tags to select when `type="random"`. Default is 10.  
+       - ``mask`` (np.ndarray, optional): Boolean mask to filter valid particle tags before selection.  
+
+     - **Output:**  
+
+       - Generates a file storing selected particle tags to initialize OSIRIS track diagnostic.  
+      
+     - **Example Usage:**
+
+      .. code-block:: python
+
+         raw = ou.OsirisRawFile("path/to/raw/file/.../.h5")
+         # Selecting 5 random tags from particles with energy>5
+         mask = raw.data["ene"] >    5.
+         raw_to_file_tags("output.tag", type="random", n_tags=5, mask=mask)
+
+
+
+HIST Data
+~~~~~~~~~
+
+.. autoclass:: osiris_utils.data.data.OsirisHIST
+   :inherited-members: grid, nx, dx, x, axis, data, units, label
+
+   Processes HIST file from OSIRIS diagnostics.
+
+TRACK Data
+~~~~~~~~~~
+
+.. autoclass:: osiris_utils.data.data.OsirisTrackFile  
+   :members: grid, data, units, labels, quants, num_particles, num_time_iters, __array__, __str__  
+   :inherited-members:  
+
+   Specialized class for handling particle track data from OSIRIS HDF5 simulations. This class processes and organizes particle tracking data into a structured numpy array, providing an intuitive interface for accessing particle properties over time.  
+
+   **Key Attributes:**  
+
+   * ``grid`` - Grid boundaries of the simulation  
+   * ``data`` - Structured numpy array with tracked particle data, accessed as ``data[particle, time_iter][quant]``  
+   * ``units`` - List of units corresponding to each tracked field  
+   * ``labels`` - LaTeX-formatted labels for each tracked quantity  
+   * ``quants`` - Field names of the tracked data  
+   * ``num_particles`` - Number of tracked particles, indexed from ``0`` to ``num_particles - 1``  
+   * ``num_time_iters`` - Number of time iterations, indexed from ``0`` to ``num_time_iters - 1``  
+
+   **Methods:**  
+
+   * ``__array__()`` - Returns the ``data`` attribute as a standard numpy array.  
+   * ``__str__()`` - Provides a string summary of the object, including simulation grid, iteration, and dimensions.  
+   * ``_load_basic_attributes(f: h5py.File)`` - Loads essential attributes such as simulation time step (``dt``), dimensionality (``dim``), and file metadata.  
+
+   **Example Usage:**
+
+   .. code-block:: python
+  
+      import osiris_utils as ou
+      track = ou.OsirisTrackFile(path/to/track_file.h5)
+      print(track.data[0:10, :]["x1"]) # Access x1 position of first 10 particles over all time steps
+
+
+Convert track file to the older more readable format
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+.. function:: convert_tracks(filename_in)
+
+   **Description:**  
+   Converts a new OSIRIS track file aka IDL-formatted aka tracks-2 to an older format that is more human-readable.  
+   In the old format, each particle is stored in a separate folder, with datasets for each quantity.  
+   The function reads data from the input file, processes it, and writes it to a new file with the suffix "-v2".
+
+   **Parameters:**  
+   - ``filename_in`` (str): The path to the input IDL-formatted track file.  
+
+   **Output File:**  
+   - A new HDF5 file is created with the same name as the input file, but with the suffix `-v2` added to the filename.  
+   This file will be in the old, more readable format.
+
+   **Example:**  
+
+   .. code-block:: python
+      
+      >>> import osiris_utils as ou 
+      >>> ou.utils.convert_tracks('path/to/input_trackfile.h5')
+      >>> # The output will be saved as 'path/to/input_trackfile-v2.h5'
+
+   **Notes:**  
+   - The old format stores each particle's data in separate groups within the file.
+   - This function assumes the input file follows the IDL (new) format as expected by OSIRIS.
+   - Code from https://github.com/GoLP-IST/RaDi-x/blob/main/tools/convert_idl_tracks_py3.py 
+
+Create `file_tags` file for track diagnostics
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+To create a tag file directly from raw data, see :class:`osiris_utils.data.data.OsirisRawFile.raw_to_file_tags()`.
+
+.. function:: create_file_tags(filename, tags_array)
+
+   **Description:**  
+   Writes a `file_tags` file from a NumPy array containing particle tags.  
+   The file is used to select specific particles for the OSIRIS track diagnostic.  
+   The tags file includes the particle ID and the associated tag value.
+
+   **Parameters:**  
+   - ``filename`` (str): The path to the output `file_tags` file where the tags will be saved.  
+   - ``tags_array`` (np.ndarray): A 2D NumPy array with shape `(number_of_tags, 2)`, with the tags.  
+
+   **Output:**  
+   - A `file_tags` file will be written to the specified `filename`, which can be used in OSIRIS diagnostics for particle tracking.
+
+   **Example:**  
+
+   .. code-block:: python
+      
+      import osiris_utils as ou 
+      import numpy as np
+      tags = np.array([[1, 12345], [2, 67890], [3, 11111]])  # Example tags
+      ou.utils.create_file_tags('output.tag', tags)
+      # This will generate a file 'output.tag' with the particle tags.
+
+   **Notes:**  
+   - The function generates the `file_tags` file in a format that can be used by the OSIRIS track diagnostic.
+
+Physics & Analysis
+------------------
+
+Numerical Methods
+~~~~~~~~~~~~~~~~~
+
+.. automodule:: osiris_utils.utils
+   :members: courant2D, transverse_average
+   :noindex:
+
+   Methods for common physics calculations:
+   
+   * ``courant2D`` - Calculate the Courant condition for 2D simulations
+   * ``transverse_average`` - Compute averages along transverse directions
+
+Data Utilities
+-------------- 
+
+File Operations
+~~~~~~~~~~~~~~~
+
+.. automodule:: osiris_utils.utils
+   :members: 
+       time_estimation,
+       filesize_estimation,
+       integrate,
+       save_data,
+       read_data
+   :noindex:
+
+   Utilities for data handling and file operations:
+   
+   * ``time_estimation`` - Estimate runtime for operations
+   * ``filesize_estimation`` - Estimate file sizes
+   * ``integrate`` - Numerical integration routines
+   * ``save_data`` - Save data to disk
+   * ``read_data`` - Read data from disk

docs/source/conf.py

@@ -0,0 +1,188 @@
+# Configuration file for the Sphinx documentation builder.
+#
+# This file only contains a selection of the most common options. For a full
+# list see the documentation:
+# https://www.sphinx-doc.org/en/master/usage/configuration.html
+
+# -- Path setup --------------------------------------------------------------
+
+# If extensions (or modules to document with autodoc) are in another directory,
+# add these directories to sys.path here. If the directory is relative to the
+# documentation root, use os.path.abspath to make it absolute, like shown here.
+#
+# import os
+# import sys
+# sys.path.insert(0, os.path.abspath('.'))
+
+
+# -- Project information -----------------------------------------------------
+
+import os
+import sys
+
+sys.path.insert(0, os.path.abspath("."))
+sys.path.append(os.path.abspath("../.."))
+
+project = "osiris_utils"
+copyright = "2025, João Biu, João Cândido, Diogo Carvalho"
+author = "João Biu, João Cândido, Diogo Carvalho"
+version = "v1.1.8"
+release = version
+
+
+# -- General configuration ---------------------------------------------------
+
+# Add any Sphinx extension module names here, as strings. They can be
+# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
+# ones.
+extensions = [
+    "sphinx.ext.autodoc",
+    "sphinx.ext.autosummary",
+    "sphinx.ext.coverage",
+    "sphinx.ext.doctest",
+    "sphinx.ext.githubpages",
+    "sphinx.ext.intersphinx",
+    "sphinx.ext.mathjax",
+    "sphinx.ext.napoleon",
+    "sphinx_copybutton",
+    "sphinx_github_style",
+]
+
+nb_execution_mode = "off"  # use stored output; avoids long CI builds
+# options for sphinx_github_style
+top_level = "OSIRIS Utils"
+linkcode_blob = "head"
+linkcode_url = r"https://github.com/joaopedrobiu6/osiris_utils/"
+linkcode_link_text = "Source"
+
+
+# numpydoc_class_members_toctree = False
+# Napoleon settings
+napoleon_google_docstring = False
+napoleon_numpy_docstring = True
+napoleon_include_init_with_doc = False
+napoleon_include_private_with_doc = False
+napoleon_include_special_with_doc = True
+napoleon_use_admonition_for_examples = False
+napoleon_use_admonition_for_notes = False
+napoleon_use_admonition_for_references = False
+napoleon_use_ivar = False
+napoleon_use_param = True
+napoleon_use_rtype = False
+
+autodoc_default_options = {
+    "member-order": "bysource",
+    "exclude-members": "__init__",
+}
+# Add any paths that contain templates here, relative to this directory.
+templates_path = ["_templates"]
+
+# The suffix(es) of source filenames.
+# You can specify multiple suffix as a list of string:
+#
+source_suffix = [".rst", ".md"]
+# source_suffix = {
+#     '.rst': 'restructuredtext',
+#     '.md': 'markdown',
+# }
+# The master toctree document.
+master_doc = "index"
+
+# The language for content autogenerated by Sphinx. Refer to documentation
+# for a list of supported languages.
+#
+# This is also used if you do content translation via gettext catalogs.
+# Usually you set 'language' from the command line for these cases.
+language = "en"
+
+# List of patterns, relative to source directory, that match files and
+# directories to ignore when looking for source files.
+# This pattern also affects html_static_path and html_extra_path.
+exclude_patterns = ["_build", "Thumbs.db", ".DS_Store", "README.rst"]
+
+
+# -- Options for HTML output -------------------------------------------------
+
+# The theme to use for HTML and HTML Help pages.  See the documentation for
+# a list of builtin themes.
+#
+html_theme = "sphinx_rtd_theme"
+
+# Theme options are theme-specific and customize the look and feel of a theme
+# further.  For a list of options available for each theme, see the
+# documentation.
+#
+html_theme_options = {
+    #    'canonical_url': '',
+    #    'analytics_id': 'UA-XXXXXXX-1',  #  Provided by Google in your dashboard
+    "logo_only": True,
+    "prev_next_buttons_location": "both",
+    "style_external_links": False,
+    "style_nav_header_background": "#3c4142",
+    # Toc options
+    "collapse_navigation": True,
+    "sticky_navigation": True,
+    "navigation_depth": 2,
+    "includehidden": True,
+    "titles_only": False,
+}
+
+# Add any paths that contain custom static files (such as style sheets) here,
+# relative to this directory. They are copied after the builtin static files,
+# so a file named 'default.css' will overwrite the builtin 'default.css'.
+html_static_path = ["_static"]
+html_css_files = ["custom.css"]
+
+# The name of an image file (relative to this directory) to place at the top
+# of the sidebar.
+# html_logo = '_static/images/logo_small_clear.png'
+
+# The name of an image file (within the static path) to use as favicon of the
+# docs.  This file should be a Windows icon file (.ico) being 16x16 or 32x32
+# pixels large.
+# html_favicon = '_static/images/desc_icon.ico'
+
+
+# If not '', a 'Last updated on:' timestamp is inserted at every page bottom,
+# using the given strftime format.
+html_last_updated_fmt = "%b %d, %Y"
+
+# If true, SmartyPants will be used to convert quotes and dashes to
+# typographically correct entities.
+html_use_smartypants = True
+
+# Custom sidebar templates, maps document names to template names.
+# html_sidebars = {}
+
+# Additional templates that should be rendered to pages, maps page names to
+# template names.
+# html_additional_pages = {}
+
+# If false, no module index is generated.
+html_domain_indices = True
+
+# If false, no index is generated.
+html_use_index = True
+
+# If true, the index is split into individual pages for each letter.
+html_split_index = False
+
+# If true, links to the reST sources are added to the pages.
+html_show_sourcelink = True
+
+# If true, 'Created using Sphinx' is shown in the HTML footer. Default is True.
+html_show_sphinx = True
+
+# If true, '(C) Copyright ...' is shown in the HTML footer. Default is True.
+html_show_copyright = True
+
+# If true, an OpenSearch description file will be output, and all pages will
+# contain a <link> tag referring to it.  The value of this option must be the
+# base URL from which the finished HTML is served.
+# html_use_opensearch = ''
+
+# This is the file name suffix for HTML files (e.g. '.xhtml').
+# html_file_suffix = None
+
+# Output file base name for HTML help builder.
+htmlhelp_basename = "osiris_utils"

docs/source/contrib.rst

@@ -0,0 +1 @@
+.. include:: ../../CONTRIBUTING.rst