pyALF 2.6.post16__tar.gz → 2.6.post35__tar.gz

pyalf-2.6.post35/PKG-INFO

@@ -0,0 +1,143 @@
+Metadata-Version: 2.4
+Name: pyALF
+Version: 2.6.post35
+Summary: Python interface for ALF, plus scripts and Jupyter notebooks.
+Author-email: ALF Collaboration <alf@physik.uni-wuerzburg.de>, Jonas Schwab <jonas.schwab@uni-wuerzburg.de>
+License-Expression: GPL-2.0-or-later
+Project-URL: Documentation, https://alf.physik.uni-wuerzburg.de/pyalf-doc/
+Project-URL: Repository, https://github.com/ALF-QMC/pyALF
+Project-URL: Issues, https://github.com/ALF-QMC/pyALF/issues
+Project-URL: ALF Homepage, https://alf.physik.uni-wuerzburg.de/
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: f90nml
+Requires-Dist: h5py
+Requires-Dist: ipympl
+Requires-Dist: ipywidgets
+Requires-Dist: matplotlib
+Requires-Dist: numba
+Requires-Dist: numpy
+Requires-Dist: pandas
+Requires-Dist: scipy
+Provides-Extra: gui
+Requires-Dist: tkinter; extra == "gui"
+Provides-Extra: doc
+Requires-Dist: sphinxcontrib-svg2pdfconverter; extra == "doc"
+Requires-Dist: jupyter-book<2.0; extra == "doc"
+Requires-Dist: numpydoc; extra == "doc"
+Requires-Dist: sphinx-argparse; extra == "doc"
+Dynamic: license-file
+
+[![Documentation](https://img.shields.io/badge/-Documentation-blue)](https://gitpages.physik.uni-wuerzburg.de/ALF/pyALF)
+[<img src="https://img.shields.io/badge/Supported%20By-UNITARY%20FUND-brightgreen.svg?style=for-the-badge" alt="drawing" width="170"/>](https://unitary.fund)
+
+## pyALF
+
+A Python package building on top of [ALF](https://github.com/ALF-QMC/ALF), meant to simplify the different steps of working with ALF, including:
+
+* Obtaining and compiling the ALF source code
+* Preparing and running simulations
+* Postprocessing and displaying the data obtained during the simulation
+
+It introduces:
+
+* The Python module `py_alf`, exposing all the package's utility to Python.
+* A set of command line tools in the folder, that make it easy to leverage pyALF from a Unix shell.
+  They are automatically exposed to the shell when pyALF is installed via pip.
+  Their source code can be found in [py_alf/cli](py_alf/cli) and documentation
+  [here](https://gitpages.physik.uni-wuerzburg.de/ALF/pyALF/source/reference/cli.html).
+* Jupyter notebooks in the folder [Notebooks](Notebooks), serving as an easy introduction to QMC and ALF.
+* Python Scripts in the folder [Scripts](Scripts) that can be run to reproduce benchmark results for established models.
+
+The **documentation** can be found [here](https://gitpages.physik.uni-wuerzburg.de/ALF/pyALF).
+
+## Installation
+
+---
+**⚠️ NOTE** In previous versions of pyALF, the installation instructions asked the users to set the environment variable `PYTHONPATH`.
+This conflicts with the newer pip package, therefore you should remove definitions of this environment variable related to pyALF.
+
+---
+
+pyALF can be installed via the Python package installer [pip](https://pip.pypa.io/en/stable/).
+
+```bash
+pip install pyALF
+```
+
+For running ALF, you will additionaly need the [ALF prerequsites](https://github.com/ALF-QMC/ALF#prerequisites).
+
+Alternatively, one could use [this Docker image](https://hub.docker.com/r/alfcollaboration/jupyter-pyalf-full), which has ALF, pyALF and a Jupyter server pre-installed.
+
+### Development installation
+
+If you want to develop pyALF, you can clone the repository and install it in
+[development mode](https://setuptools.pypa.io/en/latest/userguide/development_mode.html),
+which allows you to edit the files while using them like an installed package.
+For this, it is highly recommended to use a dedicated Python environment using e.g.
+[Python venv](https://packaging.python.org/en/latest/guides/installing-using-pip-and-virtual-environments/)
+or a
+[conda environment](https://conda.io/projects/conda/en/latest/user-guide/tasks/manage-environments.html).
+The following example shows how to install pyALF in development mode using venv.
+
+```bash
+git clone https://github.com/ALF-QMC/pyALF.git
+cd pyALF
+python -m venv .venv
+source .venv/bin/activate
+
+pip install --editable .
+```
+
+## Usage
+
+There are multiple ways to use pyALF, which roughly breaks down into three approaches:
+* Using Jupyter notebooks
+* Using the command line interface
+* Use the module `py_alf` in custom scripts
+
+### Jupyter notebooks
+
+A convenient way to use pyALF is through Jupyter notebooks. They [are run](https://jupyter.readthedocs.io/en/latest/running.html) through a Jupyter server started, e.g., from the command line:
+
+```bash
+jupyter-lab
+```
+
+or
+
+```bash
+jupyter-notebook
+```
+
+which opens the "notebook dashboard" in your default browser, from where one can open the sample notebooks in [Notebooks/](Notebooks) and create new notebooks.
+
+### Command line interface
+
+pyALF also delivers a set of command line scripts, to be use from a UNIX shell. For a full list of command line scripts see [here](https://gitpages.physik.uni-wuerzburg.de/ALF/pyALF/source/reference/cli.html).
+
+Try, e.g.
+
+```bash
+alf_run -h
+```
+
+The source code for the scripts can be found in the folder [py_alf/cli/](py_alf/cli).
+
+
+### Use module `py_alf` in custom scripts
+
+Finally, one can also use the module module `py_alf` in custom Python scripts, which is analogous to the usage in Jupyter notebooks minus some interactivity.
+
+## License
+
+The various works that make up the ALF project are placed under licenses that put
+a strong emphasis on the attribution of the original authors and the sharing of the contained knowledge.
+To that end we have placed the ALF source code under the GPL version 3 license (see license.GPL and license.additional)
+and took the liberty as per GPLv3 section 7 to include additional terms that deal with the attribution
+of the original authors(see license.additional).
+The Documentation of the ALF project by the ALF contributors is licensed under a Creative Commons Attribution-ShareAlike 4.0 International License (see Documentation/license.CCBYSA)
+We mention that we link against parts of lapack which licensed under a BSD license(see license.BSD).

{pyalf-2.6.post16 → pyalf-2.6.post35}/README.md

@@ -3,7 +3,7 @@
 
 ## pyALF
 
-A Python package building on top of [ALF](https://git.physik.uni-wuerzburg.de/ALF/ALF), meant to simplify the different steps of working with ALF, including:
+A Python package building on top of [ALF](https://github.com/ALF-QMC/ALF), meant to simplify the different steps of working with ALF, including:
 
 * Obtaining and compiling the ALF source code
 * Preparing and running simulations
@@ -35,7 +35,7 @@ pyALF can be installed via the Python package installer [pip](https://pip.pypa.i
 pip install pyALF
 ```
 
-For running ALF, you will additionaly need the [ALF prerequsites](https://git.physik.uni-wuerzburg.de/ALF/ALF#prerequisites).
+For running ALF, you will additionaly need the [ALF prerequsites](https://github.com/ALF-QMC/ALF#prerequisites).
 
 Alternatively, one could use [this Docker image](https://hub.docker.com/r/alfcollaboration/jupyter-pyalf-full), which has ALF, pyALF and a Jupyter server pre-installed.
 
@@ -51,7 +51,7 @@ or a
 The following example shows how to install pyALF in development mode using venv.
 
 ```bash
-git clone https://git.physik.uni-wuerzburg.de/ALF/pyALF.git
+git clone https://github.com/ALF-QMC/pyALF.git
 cd pyALF
 python -m venv .venv
 source .venv/bin/activate

pyalf-2.6.post35/pyALF.egg-info/PKG-INFO

@@ -0,0 +1,143 @@
+Metadata-Version: 2.4
+Name: pyALF
+Version: 2.6.post35
+Summary: Python interface for ALF, plus scripts and Jupyter notebooks.
+Author-email: ALF Collaboration <alf@physik.uni-wuerzburg.de>, Jonas Schwab <jonas.schwab@uni-wuerzburg.de>
+License-Expression: GPL-2.0-or-later
+Project-URL: Documentation, https://alf.physik.uni-wuerzburg.de/pyalf-doc/
+Project-URL: Repository, https://github.com/ALF-QMC/pyALF
+Project-URL: Issues, https://github.com/ALF-QMC/pyALF/issues
+Project-URL: ALF Homepage, https://alf.physik.uni-wuerzburg.de/
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: f90nml
+Requires-Dist: h5py
+Requires-Dist: ipympl
+Requires-Dist: ipywidgets
+Requires-Dist: matplotlib
+Requires-Dist: numba
+Requires-Dist: numpy
+Requires-Dist: pandas
+Requires-Dist: scipy
+Provides-Extra: gui
+Requires-Dist: tkinter; extra == "gui"
+Provides-Extra: doc
+Requires-Dist: sphinxcontrib-svg2pdfconverter; extra == "doc"
+Requires-Dist: jupyter-book<2.0; extra == "doc"
+Requires-Dist: numpydoc; extra == "doc"
+Requires-Dist: sphinx-argparse; extra == "doc"
+Dynamic: license-file
+
+[![Documentation](https://img.shields.io/badge/-Documentation-blue)](https://gitpages.physik.uni-wuerzburg.de/ALF/pyALF)
+[<img src="https://img.shields.io/badge/Supported%20By-UNITARY%20FUND-brightgreen.svg?style=for-the-badge" alt="drawing" width="170"/>](https://unitary.fund)
+
+## pyALF
+
+A Python package building on top of [ALF](https://github.com/ALF-QMC/ALF), meant to simplify the different steps of working with ALF, including:
+
+* Obtaining and compiling the ALF source code
+* Preparing and running simulations
+* Postprocessing and displaying the data obtained during the simulation
+
+It introduces:
+
+* The Python module `py_alf`, exposing all the package's utility to Python.
+* A set of command line tools in the folder, that make it easy to leverage pyALF from a Unix shell.
+  They are automatically exposed to the shell when pyALF is installed via pip.
+  Their source code can be found in [py_alf/cli](py_alf/cli) and documentation
+  [here](https://gitpages.physik.uni-wuerzburg.de/ALF/pyALF/source/reference/cli.html).
+* Jupyter notebooks in the folder [Notebooks](Notebooks), serving as an easy introduction to QMC and ALF.
+* Python Scripts in the folder [Scripts](Scripts) that can be run to reproduce benchmark results for established models.
+
+The **documentation** can be found [here](https://gitpages.physik.uni-wuerzburg.de/ALF/pyALF).
+
+## Installation
+
+---
+**⚠️ NOTE** In previous versions of pyALF, the installation instructions asked the users to set the environment variable `PYTHONPATH`.
+This conflicts with the newer pip package, therefore you should remove definitions of this environment variable related to pyALF.
+
+---
+
+pyALF can be installed via the Python package installer [pip](https://pip.pypa.io/en/stable/).
+
+```bash
+pip install pyALF
+```
+
+For running ALF, you will additionaly need the [ALF prerequsites](https://github.com/ALF-QMC/ALF#prerequisites).
+
+Alternatively, one could use [this Docker image](https://hub.docker.com/r/alfcollaboration/jupyter-pyalf-full), which has ALF, pyALF and a Jupyter server pre-installed.
+
+### Development installation
+
+If you want to develop pyALF, you can clone the repository and install it in
+[development mode](https://setuptools.pypa.io/en/latest/userguide/development_mode.html),
+which allows you to edit the files while using them like an installed package.
+For this, it is highly recommended to use a dedicated Python environment using e.g.
+[Python venv](https://packaging.python.org/en/latest/guides/installing-using-pip-and-virtual-environments/)
+or a
+[conda environment](https://conda.io/projects/conda/en/latest/user-guide/tasks/manage-environments.html).
+The following example shows how to install pyALF in development mode using venv.
+
+```bash
+git clone https://github.com/ALF-QMC/pyALF.git
+cd pyALF
+python -m venv .venv
+source .venv/bin/activate
+
+pip install --editable .
+```
+
+## Usage
+
+There are multiple ways to use pyALF, which roughly breaks down into three approaches:
+* Using Jupyter notebooks
+* Using the command line interface
+* Use the module `py_alf` in custom scripts
+
+### Jupyter notebooks
+
+A convenient way to use pyALF is through Jupyter notebooks. They [are run](https://jupyter.readthedocs.io/en/latest/running.html) through a Jupyter server started, e.g., from the command line:
+
+```bash
+jupyter-lab
+```
+
+or
+
+```bash
+jupyter-notebook
+```
+
+which opens the "notebook dashboard" in your default browser, from where one can open the sample notebooks in [Notebooks/](Notebooks) and create new notebooks.
+
+### Command line interface
+
+pyALF also delivers a set of command line scripts, to be use from a UNIX shell. For a full list of command line scripts see [here](https://gitpages.physik.uni-wuerzburg.de/ALF/pyALF/source/reference/cli.html).
+
+Try, e.g.
+
+```bash
+alf_run -h
+```
+
+The source code for the scripts can be found in the folder [py_alf/cli/](py_alf/cli).
+
+
+### Use module `py_alf` in custom scripts
+
+Finally, one can also use the module module `py_alf` in custom Python scripts, which is analogous to the usage in Jupyter notebooks minus some interactivity.
+
+## License
+
+The various works that make up the ALF project are placed under licenses that put
+a strong emphasis on the attribution of the original authors and the sharing of the contained knowledge.
+To that end we have placed the ALF source code under the GPL version 3 license (see license.GPL and license.additional)
+and took the liberty as per GPLv3 section 7 to include additional terms that deal with the attribution
+of the original authors(see license.additional).
+The Documentation of the ALF project by the ALF contributors is licensed under a Creative Commons Attribution-ShareAlike 4.0 International License (see Documentation/license.CCBYSA)
+We mention that we link against parts of lapack which licensed under a BSD license(see license.BSD).

{pyalf-2.6.post16 → pyalf-2.6.post35}/py_alf/alf_source.py

@@ -40,13 +40,13 @@ class ALF_source:
         to './ALF'.
     branch : str, optional
         If specified, this will be checked out by git.
-    url : str, default='https://git.physik.uni-wuerzburg.de/ALF/ALF.git'
+    url : str, default='https://github.com/ALF-QMC/ALF.git'
         Address from where to clone ALF if alf_dir does not exist.
 
     """
 
     def __init__(self, alf_dir=None, branch=None,
-                 url='https://git.physik.uni-wuerzburg.de/ALF/ALF.git'):
+                 url='https://github.com/ALF-QMC/ALF.git'):
         if alf_dir is None:
             alf_dir = os.getenv('ALF_DIR', './ALF')
         self.alf_dir = os.path.abspath(os.path.expanduser(alf_dir))

{pyalf-2.6.post16 → pyalf-2.6.post35}/py_alf/check_common.py

@@ -39,7 +39,7 @@ def _get_bins(directory, names, custom_obs):
 
             dtype, shape = custom_obs_get_dtype_shape(obs_spec, bins_raw)
             del dtype
-            size = np.prod(shape)
+            size = 1 if not shape else np.prod(shape)
             bins = np.empty((N_bins, size))
 
             for i in range(N_bins):

{pyalf-2.6.post16 → pyalf-2.6.post35}/py_alf/cli/minimal_ALF_run.py

@@ -15,7 +15,7 @@ from py_alf import ALF_source, Simulation
 
 def _main():
     # Create an instance of ALF_source, downloading the ALF source code from
-    # https://git.physik.uni-wuerzburg.de/ALF/ALF, if ALF diretory does not exist.
+    # https://github.com/ALF-QMC/ALF, if ALF diretory does not exist.
     # Gets ALF diretory from environment variable $ALF_DIR, or defaults to "./ALF",
     # if not present.
     alf_src = ALF_source()

{pyalf-2.6.post16 → pyalf-2.6.post35}/py_alf/simulation.py

@@ -6,6 +6,8 @@ __author__ = "Jonas Schwab"
 __copyright__ = "Copyright 2020-2022, The ALF Project"
 __license__ = "GPL"
 
+import hashlib
+import json
 import os
 import re
 import shutil
@@ -44,11 +46,18 @@ class Simulation:
     ham_name : str
         Name of the Hamiltonian.
     sim_dict : dict or list of dicts
-        Dictionary specfying parameters owerwriting defaults.
+        Dictionary specifying parameters overwriting defaults.
         Can be a list of dictionaries to enable parallel tempering.
     sim_dir : path-like object, optional
         Directory in which the Monte Carlo will be run.
         If not specified, sim_dir is generated from sim_dict.
+    sim_dir_hash : bool, default=False
+        Whether to use a hash of the parameters for the directory name.
+        This is an experimental feature to get shorter directory names
+        that take into account all simulation parameters except for
+        Nbin and CPU_MAX. It is not fully supported and may lead to
+        issues with reproducibility if parameters are changed without
+        changing the directory name. Use with caution.
     sim_root : path-like object, default="ALF_data"
         Directory to prepend to sim_dir.
     mpi : bool, default=False
@@ -90,10 +99,18 @@ class Simulation:
         self.alf_src = alf_src
         self.ham_name = ham_name
         self.sim_dict = sim_dict
+        sim_root = kwargs.pop("sim_root", "ALF_data")
+        sim_dir_hash = kwargs.pop("sim_dir_hash", False)
+        explicit_sim_dir = kwargs.pop("sim_dir", None)
+        if explicit_sim_dir is not None:
+            # Explicitly provided sim_dir takes precedence over hash-based naming
+            dir_component = explicit_sim_dir
+        elif sim_dir_hash:
+            dir_component = directory_name_hash(alf_src, ham_name, sim_dict)
+        else:
+            dir_component = directory_name(alf_src, ham_name, sim_dict)
         self.sim_dir = os.path.abspath(os.path.expanduser(os.path.join(
-            kwargs.pop("sim_root", "ALF_data"),
-            kwargs.pop("sim_dir",
-                       directory_name(alf_src, ham_name, sim_dict)))))
+            sim_root, dir_component)))
         self.mpi = kwargs.pop("mpi", False)
         self.parallel_params = kwargs.pop("parallel_params", False)
         self.n_mpi = kwargs.pop("n_mpi", 2)
@@ -408,6 +425,47 @@ def directory_name(alf_src, ham_name, sim_dict):
     return dirname[:-1]
 
 
+def get_hashable_parameters(parameters):
+    """Build a deterministic, JSON-serializable subset of parameters for hashing.
+
+    This helper removes non-essential or run-dependent fields (such as post-
+    processing namespaces and certain QMC controls) and keeps only the raw
+    parameter values. The returned nested dictionary is intended to be
+    serialized (for example with ``json.dumps``) and then hashed; this
+    function itself does not perform any serialization or hashing.
+    """
+    # Use only the parameter values for hashing.
+    parameters_hashable = {}
+    for namespace in parameters:
+        if namespace in ['VAR_errors', 'VAR_Max_Stoch']:
+            # Exclude postprocessing parameters from hash.
+            continue
+        parameters_hashable[namespace] = {}
+        for var in parameters[namespace]:
+            if namespace == 'VAR_QMC' and var in ['Nbin', 'CPU_MAX']:
+                # Exclude Nbin and CPU_MAX from hash.
+                continue
+            parameters_hashable[namespace][var] = parameters[namespace][var]['value']
+    return parameters_hashable
+
+
+def directory_name_hash(alf_src, ham_name, sim_dict):
+    """Return name of directory for simulations, given a set of simulation
+    parameters. The name is a hash of the parameters, so that it is short
+    and does not contain any special characters."""
+    if isinstance(sim_dict, list):
+        # For tempering / parallel parameters, incorporate all parameter sets
+        to_hash = [
+            get_hashable_parameters(
+                set_param(alf_src, ham_name, sim_dict_single))
+            for sim_dict_single in sim_dict
+        ]
+    else:
+        to_hash = get_hashable_parameters(set_param(alf_src, ham_name, sim_dict))
+    dump = json.dumps(to_hash, sort_keys=True, separators=(",", ":"))
+    return hashlib.sha1(dump.encode("utf-8")).hexdigest()[:15]
+
+
 def _update_var(params, var, value):
     """Try to update value of parameter called var in params."""
     for name in params:
@@ -466,7 +524,7 @@ def getenv(config, alf_dir='.'):
 def compile_alf(alf_dir=None,
                 branch=None,
                 config='GNU noMPI',
-                url='https://git.physik.uni-wuerzburg.de/ALF/ALF.git',
+                url='https://github.com/ALF-QMC/ALF.git',
                 verbosity=0
                 ):
     """Compile ALF. Clone a new repository if alf_dir does not exist.
@@ -482,7 +540,7 @@ def compile_alf(alf_dir=None,
         If specified, this will be checked out by git.
     config : str, default='GNU noMPI'
         Arguments for `configure.sh`.
-    url : str, default='https://git.physik.uni-wuerzburg.de/ALF/ALF.git'
+    url : str, default='https://github.com/ALF-QMC/ALF.git'
         Address from where to clone ALF if alf_dir not exists.
     verbosity : int, default=0
         0: Don't echo make reciepes.

{pyalf-2.6.post16 → pyalf-2.6.post35}/pyproject.toml

@@ -17,12 +17,12 @@ authors = [
   { name="Jonas Schwab", email="jonas.schwab@uni-wuerzburg.de" },
 ]
 description = "Python interface for ALF, plus scripts and Jupyter notebooks."
-license = {file = "LICENSE"}
+license = "GPL-2.0-or-later"
+license-files = ['LICENSE']
 readme = "README.md"
 requires-python = ">=3.7"
 classifiers = [
     "Programming Language :: Python :: 3",
-    "License :: OSI Approved :: GNU General Public License v2 or later (GPLv2+)",
     "Operating System :: OS Independent",
 ]
 dependencies = [
@@ -50,9 +50,9 @@ doc = [
 include = ["py_alf", "py_alf.cli"]
 
 [project.urls]
-Documentation = "https://gitpages.physik.uni-wuerzburg.de/ALF/pyALF"
-Repository = "https://git.physik.uni-wuerzburg.de/ALF/pyALF"
-Issues = "https://git.physik.uni-wuerzburg.de/ALF/pyALF/-/issues"
+Documentation = "https://alf.physik.uni-wuerzburg.de/pyalf-doc/"
+Repository = "https://github.com/ALF-QMC/pyALF"
+Issues = "https://github.com/ALF-QMC/pyALF/issues"
 "ALF Homepage" = "https://alf.physik.uni-wuerzburg.de/"
 
 [project.scripts]