HydPy 6.2.dev1__cp313-cp313-win_amd64.whl

hydpy-6.2.dev1.data/scripts/hyd.py

@@ -0,0 +1,277 @@
+#!python
+"""The script for executing HydPy workflows.
+
+.. _`Python Launcher for Windows`: \
+https://docs.python.org/3/using/windows.html#launcher
+
+.. _`here`: https://bitbucket.org/vinay.sajip/pylauncher/downloads
+
+This script is thought to be called from a command line.  After successfully
+installating HydPy, you caninvoke it from anywhere on your computer.  Test this by just
+typing `hyd.py` into your command line:
+
+>>> import subprocess
+>>> from hydpy import run_subprocess
+>>> result = run_subprocess("hyd.py")  # doctest: +ELLIPSIS
+Invoking hyd.py without arguments resulted in the following error:
+The first positional argument defining the function to be called is missing.
+<BLANKLINE>
+See the following stack traceback for debugging:
+...
+
+If this test example does not work on your machine, you should first make sure there is
+a `hyd.py` file in the `Scripts` folder of your Python distribution and that the
+environment variable `Path` is pointing to this folder.  Windows users should also make
+shure to install the `Python Launcher for Windows`_.  The Python standard distribution
+contains this launcher, but other distributions like Anaconda do not.  You can find a
+suitable installer `here`_.  As a stopgap, you could directly call Python and pass the
+complete path of the `hyd.py` file available in your *HydPy* site-packages folder as an
+argument:
+
+>>> import sys
+>>> from hydpy.exe import hyd
+>>> command = f"{sys.executable} {hyd.__file__}"
+>>> from hydpy import repr_
+>>> repr_(command)  # doctest: +ELLIPSIS
+'...python... .../hydpy/exe/hyd.py'
+>>> result = run_subprocess(command)  # doctest: +ELLIPSIS
+Invoking hyd.py without arguments resulted in the following error:
+The first positional argument defining the function to be called is missing.
+...
+
+You are free to redirect output to a log file:
+
+>>> from hydpy import TestIO
+>>> TestIO.clear()
+>>> with TestIO():
+...     result = run_subprocess("hyd.py logfile=my_log_file.txt")
+>>> with TestIO(), open("my_log_file.txt") as logfile:
+...     print(logfile.read())  # doctest: +ELLIPSIS
+Invoking hyd.py with argument `logfile=my_log_file.txt` resulted in the following \
+error:
+The first positional argument defining the function to be called is missing.
+...
+
+When passing `default` as keyword argument `logfile`, function |prepare_logfile|
+generates a default name containing the current date and time:
+
+>>> with TestIO():
+...     result = run_subprocess("hyd.py logfile=default")
+>>> import os
+>>> with TestIO():
+...     for filename in os.listdir("."):
+...         if filename.endswith(".log"):
+...             print(filename)  # doctest: +ELLIPSIS
+hydpy_...-...-..._...-...-....log
+
+Without any further arguments, `hyd.py` does not know which function to call:
+
+>>> result = run_subprocess("hyd.py")  # doctest: +ELLIPSIS
+Invoking hyd.py without arguments resulted in the following error:
+The first positional argument defining the function to be called is missing.
+...
+
+The first additional argument must be an available "script function":
+
+>>> result = run_subprocess("hyd.py "
+...                         "wrong_argument")  # doctest: +ELLIPSIS
+Invoking hyd.py with argument `wrong_argument` resulted in the following error:
+There is no `wrong_argument` function callable by `hyd.py`.  Choose one of the \
+following instead: await_server, exec_commands, exec_script, run_doctests, \
+run_simulation, start_server, start_shell, xml_replace, and xml_validate.
+...
+
+Further argument requirements depend on the selected "script function":
+
+>>> result = run_subprocess("hyd.py "
+...                         "exec_commands")  # doctest: +ELLIPSIS
+Invoking hyd.py with argument `exec_commands` resulted in the following error:
+Function `exec_commands` requires `1` positional arguments (commands), but `0` are \
+given.
+...
+>>> result = run_subprocess("hyd.py "
+...                         "exec_commands "
+...                         "first_name "
+...                         "second_name")  # doctest: +ELLIPSIS
+Invoking hyd.py with arguments `exec_commands, first_name, second_name` resulted in \
+the following error:
+Function `exec_commands` allows `1` positional arguments (commands), but `2` are \
+given (first_name and second_name).
+...
+
+Optional keyword arguments are supported: (on Linux, we have to escape the characters \
+"(", ")", ";", and "'" in the following)
+
+>>> import platform
+>>> esc = "" if "windows" in platform.platform().lower() else "\\\\"
+>>> result = run_subprocess("hyd.py "
+...                         "exec_commands "
+...                         f"print{esc}(x+y{esc}) "
+...                         f"x={esc}'2{esc}' "
+...                         f"y={esc}'=1+1{esc}'")
+Start to execute the commands ['print(x+y)'] for testing purposes.
+2=1+1
+
+Error messages raised by the "script function" itself also find their way into the
+console or log file:
+
+>>> result = run_subprocess(  # doctest: +ELLIPSIS
+...    "hyd.py exec_commands "
+...    f"raise_RuntimeError{esc}({esc}'it_fails{esc}'{esc})")
+Start to execute the commands ["raise_RuntimeError('it_fails')"] for testing purposes.
+Invoking hyd.py with arguments `exec_commands, raise_RuntimeError('it_fails')` \
+resulted in the following error:
+it fails
+...
+
+The same is true for warning messages:
+
+>>> result = run_subprocess("hyd.py "  # doctest: +ELLIPSIS
+...                         "exec_commands "
+...                         f"import_warnings{esc};"
+...                         f"warnings.warn{esc}({esc}'it_stumbles{esc}'{esc})")
+Start to execute the commands ['import_warnings', "warnings.warn('it_stumbles')"] for \
+testing purposes...
+...UserWarning: it stumbles
+
+And the same is true for printed messages:
+
+>>> result = run_subprocess("hyd.py "
+...                         "exec_commands "
+...                         f"print{esc}({esc}'it_works{esc}'{esc})")
+Start to execute the commands ["print('it_works')"] for testing purposes.
+it works
+
+To report the importance level of individual log messages, use the optional `logstyle`
+keyword argument:
+
+>>> result = run_subprocess(   # doctest: +ELLIPSIS
+...     "hyd.py exec_commands "
+...     f"print{esc}({esc}'it_works{esc}'{esc}){esc};"
+...     f"import_warnings{esc};"
+...     f"warnings.warn{esc}({esc}'it_stumbles{esc}'{esc}){esc};"
+...     f"raise_RuntimeError{esc}({esc}'it_fails{esc}'{esc}) "
+...     "logstyle=prefixed")
+info: Start to execute the commands ["print('it_works')", 'import_warnings', \
+"warnings.warn('it_stumbles')", "raise_RuntimeError('it_fails')"] for testing purposes.
+info: it works
+warning: ...UserWarning: it stumbles
+error: Invoking hyd.py with arguments `exec_commands, print('it_works');\
+import_warnings;warnings.warn('it_stumbles');raise_RuntimeError('it_fails'), \
+logstyle=prefixed` resulted in the following error:
+error: it fails
+...
+
+So far, only `prefixed` and the default style `plain` have been implemented:
+
+>>> result = run_subprocess("hyd.py "  # doctest: +ELLIPSIS
+...                         "exec_commands "
+...                         "None "
+...                         "logstyle=missing")
+Invoking hyd.py with arguments `exec_commands, None, logstyle=missing` resulted in \
+the following error:
+The given log file style missing is not available.  Please choose one of the \
+following: plain and prefixed.
+...
+
+A related option is `errorstyle`, which allows for modifying the print style of
+exception messages.  So far, three error message printing styles are available:
+
+>>> result = run_subprocess("hyd.py exec_commands "  # doctest: +ELLIPSIS
+...                         "errorstyle=wrong")
+Invoking hyd.py with arguments `exec_commands, errorstyle=wrong` resulted in the \
+following error:
+The given error message style `wrong` is not available.  Please choose one of the \
+following: `multiline`, `single_line`, and `splittable`.
+...
+
+The (so far used) default is `multiline`.  It prints the context, the message, and the
+individual traceback components of the occurred error in separate lines:
+
+>>> result = run_subprocess(  # doctest: +ELLIPSIS
+...    "hyd.py exec_commands "
+...    "errorstyle=multiline "
+...    f"raise_RuntimeError{esc}({esc}'it_fails{esc}'{esc})")
+Start to execute the commands ["raise_RuntimeError('it_fails')"] for testing purposes.
+Invoking hyd.py with arguments `exec_commands, errorstyle=multiline, \
+raise_RuntimeError('it_fails')` resulted in the following error:
+it fails
+<BLANKLINE>
+See the following stack traceback for debugging:
+...
+
+.. _`Delft-FEWS`: https://oss.deltares.nl/web/delft-fews
+
+`multiline` provides exhaustive information in a human-readable form.  However,
+printing separate lines can confuse other tools that parse and forward HydPy's error
+messages (for example, `Delft-FEWS`_).  Hence, the first alternative, `single_line`,
+prints a single line.  It does so also in a readable form by omitting the traceback:
+
+>>> result = run_subprocess(  # doctest: +ELLIPSIS
+...    "hyd.py exec_commands "
+...    "errorstyle=single_line "
+...    f"raise_RuntimeError{esc}({esc}'it_fails{esc}'{esc})")
+Start to execute the commands ["raise_RuntimeError('it_fails')"] for testing purposes.
+Invoking hyd.py with arguments `exec_commands, errorstyle=single_line, \
+raise_RuntimeError('it_fails')` resulted in the following error: it fails
+
+The second alternative, `splittable`, squeezes the whole information (including the
+traceback) into a single line that uses the string `__hydpy_newline__` as a surrogate
+newline character, and so allows to convert the complete error message into the
+multiline form later:
+
+>>> result = run_subprocess(  # doctest: +ELLIPSIS
+...    "hyd.py exec_commands "
+...    "errorstyle=splittable "
+...    f"raise_RuntimeError{esc}({esc}'it_fails{esc}'{esc})")
+Start to execute the commands ["raise_RuntimeError('it_fails')"] for testing purposes.
+Invoking hyd.py with arguments `exec_commands, errorstyle=splittable, \
+raise_RuntimeError('it_fails')` resulted in the following error:__hydpy_newline__it \
+fails__hydpy_newline____hydpy_newline__See the following stack traceback for \
+debugging:__hydpy_newline__ ...__hydpy_newline__
+
+See the documentation on module |xmltools| for an actually successful example using the
+"script function" |run_simulation|.
+"""
+# import...
+# ...from standard-library
+import sys
+
+# ...from hydpy
+from hydpy.exe import commandtools
+
+
+def execute() -> None:
+    """Call |execute_scriptfunction| of module |commandtools| in case |hyd| is the main
+    script.
+
+    >>> from hydpy.exe import hyd
+    >>> from unittest import mock
+    >>> with (
+    ...     mock.patch("hydpy.exe.commandtools.execute_scriptfunction") as fun,
+    ...     mock.patch("sys.exit") as exit_,
+    ...     mock.patch.object(hyd, "__name__", "__not_main__"),
+    ... ):
+    ...     hyd.execute()
+    ...     exit_.called
+    False
+    >>> for return_value in (None, 0, 2):
+    ...     with (
+    ...         mock.patch(
+    ...             "hydpy.exe.commandtools.execute_scriptfunction",
+    ...              return_value=return_value
+    ...         ),
+    ...         mock.patch("sys.exit") as exit_,
+    ...         mock.patch.object(hyd, "__name__", "__main__"),
+    ... ):
+    ...         hyd.execute()
+    ...         exit_.call_args
+    call(False)
+    call(False)
+    call(True)
+    """
+    if __name__ == "__main__":
+        sys.exit(bool(commandtools.execute_scriptfunction()))
+
+
+execute()

hydpy-6.2.dev1.dist-info/LICENSE

@@ -0,0 +1,165 @@
+                   GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+
+  This version of the GNU Lesser General Public License incorporates
+the terms and conditions of version 3 of the GNU General Public
+License, supplemented by the additional permissions listed below.
+
+  0. Additional Definitions.
+
+  As used herein, "this License" refers to version 3 of the GNU Lesser
+General Public License, and the "GNU GPL" refers to version 3 of the GNU
+General Public License.
+
+  "The Library" refers to a covered work governed by this License,
+other than an Application or a Combined Work as defined below.
+
+  An "Application" is any work that makes use of an interface provided
+by the Library, but which is not otherwise based on the Library.
+Defining a subclass of a class defined by the Library is deemed a mode
+of using an interface provided by the Library.
+
+  A "Combined Work" is a work produced by combining or linking an
+Application with the Library.  The particular version of the Library
+with which the Combined Work was made is also called the "Linked
+Version".
+
+  The "Minimal Corresponding Source" for a Combined Work means the
+Corresponding Source for the Combined Work, excluding any source code
+for portions of the Combined Work that, considered in isolation, are
+based on the Application, and not on the Linked Version.
+
+  The "Corresponding Application Code" for a Combined Work means the
+object code and/or source code for the Application, including any data
+and utility programs needed for reproducing the Combined Work from the
+Application, but excluding the System Libraries of the Combined Work.
+
+  1. Exception to Section 3 of the GNU GPL.
+
+  You may convey a covered work under sections 3 and 4 of this License
+without being bound by section 3 of the GNU GPL.
+
+  2. Conveying Modified Versions.
+
+  If you modify a copy of the Library, and, in your modifications, a
+facility refers to a function or data to be supplied by an Application
+that uses the facility (other than as an argument passed when the
+facility is invoked), then you may convey a copy of the modified
+version:
+
+   a) under this License, provided that you make a good faith effort to
+   ensure that, in the event an Application does not supply the
+   function or data, the facility still operates, and performs
+   whatever part of its purpose remains meaningful, or
+
+   b) under the GNU GPL, with none of the additional permissions of
+   this License applicable to that copy.
+
+  3. Object Code Incorporating Material from Library Header Files.
+
+  The object code form of an Application may incorporate material from
+a header file that is part of the Library.  You may convey such object
+code under terms of your choice, provided that, if the incorporated
+material is not limited to numerical parameters, data structure
+layouts and accessors, or small macros, inline functions and templates
+(ten or fewer lines in length), you do both of the following:
+
+   a) Give prominent notice with each copy of the object code that the
+   Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the object code with a copy of the GNU GPL and this license
+   document.
+
+  4. Combined Works.
+
+  You may convey a Combined Work under terms of your choice that,
+taken together, effectively do not restrict modification of the
+portions of the Library contained in the Combined Work and reverse
+engineering for debugging such modifications, if you also do each of
+the following:
+
+   a) Give prominent notice with each copy of the Combined Work that
+   the Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the Combined Work with a copy of the GNU GPL and this license
+   document.
+
+   c) For a Combined Work that displays copyright notices during
+   execution, include the copyright notice for the Library among
+   these notices, as well as a reference directing the user to the
+   copies of the GNU GPL and this license document.
+
+   d) Do one of the following:
+
+       0) Convey the Minimal Corresponding Source under the terms of this
+       License, and the Corresponding Application Code in a form
+       suitable for, and under terms that permit, the user to
+       recombine or relink the Application with a modified version of
+       the Linked Version to produce a modified Combined Work, in the
+       manner specified by section 6 of the GNU GPL for conveying
+       Corresponding Source.
+
+       1) Use a suitable shared library mechanism for linking with the
+       Library.  A suitable mechanism is one that (a) uses at run time
+       a copy of the Library already present on the user's computer
+       system, and (b) will operate properly with a modified version
+       of the Library that is interface-compatible with the Linked
+       Version.
+
+   e) Provide Installation Information, but only if you would otherwise
+   be required to provide such information under section 6 of the
+   GNU GPL, and only to the extent that such information is
+   necessary to install and execute a modified version of the
+   Combined Work produced by recombining or relinking the
+   Application with a modified version of the Linked Version. (If
+   you use option 4d0, the Installation Information must accompany
+   the Minimal Corresponding Source and Corresponding Application
+   Code. If you use option 4d1, you must provide the Installation
+   Information in the manner specified by section 6 of the GNU GPL
+   for conveying Corresponding Source.)
+
+  5. Combined Libraries.
+
+  You may place library facilities that are a work based on the
+Library side by side in a single library together with other library
+facilities that are not Applications and are not covered by this
+License, and convey such a combined library under terms of your
+choice, if you do both of the following:
+
+   a) Accompany the combined library with a copy of the same work based
+   on the Library, uncombined with any other library facilities,
+   conveyed under the terms of this License.
+
+   b) Give prominent notice with the combined library that part of it
+   is a work based on the Library, and explaining where to find the
+   accompanying uncombined form of the same work.
+
+  6. Revised Versions of the GNU Lesser General Public License.
+
+  The Free Software Foundation may publish revised and/or new versions
+of the GNU Lesser General Public License from time to time. Such new
+versions will be similar in spirit to the present version, but may
+differ in detail to address new problems or concerns.
+
+  Each version is given a distinguishing version number. If the
+Library as you received it specifies that a certain numbered version
+of the GNU Lesser General Public License "or any later version"
+applies to it, you have the option of following the terms and
+conditions either of that published version or of any later version
+published by the Free Software Foundation. If the Library as you
+received it does not specify a version number of the GNU Lesser
+General Public License, you may choose any version of the GNU Lesser
+General Public License ever published by the Free Software Foundation.
+
+  If the Library as you received it specifies that a proxy can decide
+whether future versions of the GNU Lesser General Public License shall
+apply, that proxy's public statement of acceptance of any version is
+permanent authorization for you to choose that version for the
+Library.

hydpy-6.2.dev1.dist-info/METADATA

@@ -0,0 +1,163 @@
+Metadata-Version: 2.2
+Name: HydPy
+Version: 6.2.dev1
+Summary: A framework for the development and application of hydrological models.
+Home-page: https://github.com/hydpy-dev/hydpy
+Author: HydPy Developers
+Author-email: c.tyralla@bjoernsen.de
+License: LGPL-3.0
+Keywords: hydrology modelling water balance rainfall runoff
+Classifier: Intended Audience :: Education
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: GNU Lesser General Public License v3 (LGPLv3)
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Topic :: Scientific/Engineering
+Requires-Python: >=3.10
+License-File: LICENSE
+License-File: licenses_hydpy_installer.txt
+Requires-Dist: black
+Requires-Dist: click
+Requires-Dist: cython
+Requires-Dist: strenum; python_version < "3.11"
+Requires-Dist: matplotlib
+Requires-Dist: netcdf4
+Requires-Dist: networkx
+Requires-Dist: numpy
+Requires-Dist: pandas
+Requires-Dist: plotly
+Requires-Dist: scipy
+Requires-Dist: setuptools
+Requires-Dist: typing_extensions
+Requires-Dist: wrapt
+Requires-Dist: xmlschema
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+.. _`online documentation`: https://hydpy-dev.github.io/hydpy/
+.. _Python: http://www.python.org/
+.. _Cython: http://www.cython.org/
+.. _`Ruhr-University Bochum`: http://www.hydrology.ruhr-uni-bochum.de/index.html.en
+.. _`German Federal Institute of Hydrology`: https://www.bafg.de/EN
+.. _`Björnsen Consulting Engineers`: https://www.bjoernsen.de/en/bjoernsen-consulting-engineers
+.. _`GitHub repository`: https://github.com/hydpy-dev/hydpy
+.. _`GNU Lesser General Public License 3`: https://www.gnu.org/licenses/lgpl-3.0.en.html
+.. _`documentation test`: https://docs.python.org/3.6/library/doctest.html
+
+.. figure:: hydpy/docs/figs/HydPy_Logo_Text.png
+   :alt: HydPy logo
+
+.. |PyPi| image:: https://img.shields.io/pypi/v/HydPy
+   :alt: PyPI
+   :target: https://pypi.org/project/HydPy
+.. |Releases| image:: https://img.shields.io/pypi/v/HydPy?label=download
+   :alt: Releases
+   :target: https://github.com/hydpy-dev/hydpy/releases
+.. |Documentation| image:: https://img.shields.io/badge/docs-latest-informational
+   :alt: Documentation
+   :target: https://hydpy-dev.github.io/hydpy/index.html
+.. |Licence| image:: https://img.shields.io/github/license/hydpy-dev/hydpy?color=blue
+   :alt: Licence
+   :target: https://github.com/hydpy-dev/hydpy/blob/master/LICENSE
+
+|PyPi| |Releases| |Documentation| |Licence|
+
+.. |Coverage| image:: https://img.shields.io/badge/Coverage-100%20%25-green
+   :alt: Coverage
+   :target: https://coverage.readthedocs.io
+.. |Black| image:: https://img.shields.io/badge/Black-All%20done%21-green
+   :alt: Black
+   :target: https://github.com/psf/black
+.. |Pylint| image:: https://img.shields.io/badge/Pylint-10.00/10-green
+   :alt: Pylint
+   :target: https://www.pylint.org/
+.. |Mypy| image:: https://img.shields.io/badge/Mypy-work%20in%20progress-orange
+   :alt: Mypy
+   :target: https://mypy.readthedocs.io/en/stable
+
+|Coverage| |Black| |Pylint| |Mypy|
+
+.. |Travis master| image:: https://img.shields.io/travis/com/hydpy-dev/hydpy/master?label=Travis%20master
+   :alt: Travis master
+   :target: https://app.travis-ci.com/github/hydpy-dev/hydpy/branches
+.. |Travis latest| image:: https://img.shields.io/travis/com/hydpy-dev/hydpy?label=latest
+   :alt: Travis latest
+   :target: https://app.travis-ci.com/hydpy-dev/hydpy
+
+|Travis master| |Travis latest|
+
+.. |AppVeyor master| image:: https://img.shields.io/appveyor/build/tyralla/hydpy-hep1s/master?label=AppVeyor%20master
+   :alt: AppVeyor master
+   :target: https://ci.appveyor.com/project/tyralla/hydpy-hep1s/history
+.. |AppVeyor latest| image:: https://img.shields.io/appveyor/build/tyralla/hydpy-hep1s?label=latest
+   :alt: AppVeyor latest
+   :target: https://ci.appveyor.com/project/tyralla/hydpy-hep1s
+
+|AppVeyor master| |AppVeyor latest|
+
+.. |GitHub open issues| image:: https://img.shields.io/github/issues-raw/hydpy-dev/hydpy
+   :alt: GitHub issues
+   :target: https://github.com/hydpy-dev/hydpy/issues?q=is%3Aopen+is%3Aissue
+.. |GitHub closed issues| image:: https://img.shields.io/github/issues-closed-raw/hydpy-dev/hydpy?label=closed
+   :alt: GitHub closed issues
+   :target: https://github.com/hydpy-dev/hydpy/issues?q=is%3Aissue+is%3Aclosed
+
+|GitHub open issues| |GitHub closed issues|
+
+
+*HydPy* is an interactive framework for developing and applying
+different types of hydrological models, originally developed
+at the `Ruhr-University Bochum`_ for specific research purposes.
+Later it was extended on behalf of the `German Federal Institute of
+Hydrology`_ in order to be applicable in practical applications like
+runoff forecasting in large river basins.  Now it is being maintained
+by `Björnsen Consulting Engineers`_.
+
+
+*HydPy* is intended to be a modern open source software, based on the
+programming language `Python`_, commonly used in many scientific fields.
+Through using different well-established `Python`_ libraries and design
+principles, we target high quality and transparency standards. To avoid
+writing model cores in a more native programming language, *HydPy*
+includes a `Cython`_ based mechanism to automatically translate
+Python code to C code and to compile it.
+
+*HydPy* has no graphical user interface (so far). Instead, it is thought
+to be applied by executing Python scripts. These scripts help to increase
+the reproducibility of studies performed with *HydPy* because
+they can be easily shared and repeatedly executed.  This approach facilitates
+discussing possible weaknesses of *HydPy* and its implemented
+models and comparing different methodical approaches (e. g. different
+strategies to calibrate model parameters).  However, if you are not an
+experienced hydrologist with basic programming skills, you may need
+some help to become acquainted with *HydPy*.
+
+We host *HydPy* in a `GitHub repository`_ and everyone
+is allowed to download, modify, and use it.  However, when passing the
+(possibly modified) code to third parties, you have to be aware you
+cannot change the selected `GNU Lesser General Public License 3`_
+to a "less open source" license.  If you, for example, implement a model
+into *HydPy*, you can be sure that all possible further developments of
+your model code are still open source and the mentioned third parties
+are allowed to pass this modified source code to you.
+
+*HydPy* offers many functionalities to make the implemented
+models as transparent and reliable as possible.  For this reason,
+the `online documentation`_ is automatically updated for each new
+*HydPy* version and includes different `documentation test`_ mechanisms
+ensuring that *HydPy* is working as expected and that the complete
+documentation is up-to-date with it.