Saravanan666/pypi-org huggingface dataset:
Package: aiida-pytest
NOTE:Theaiida-pytestpackage is in maintenance mode: bugs will continue to be fixed for the foreseeable future, but no new features will be implemented. Users considering usingaiida-pytestarestronglyencouraged to use the built-in AiiDA fixtures instead.aiida-pytestThis is a helper to enable testing AiiDA plugins withpytest. The main purpose is to create a fixture which sets up a temporary AiiDA database and user, and simplify setting up the computers and calculations.To get started, create atestsfolder where yourpytesttests will be located. Inconftests.py, you need to writefromaiida_pytestimport*This defines theconfigureandconfigure_with_daemonfixtures. To set up computers and codes for the test run, you need aconfig.ymlfile in thetestsfolder (and runpytestfrom there). The following example config file sets uplocalhostand thebands-inspectcode:computers:
  localhost:
    hostname: localhost
    description: localhost
    transport: local
    scheduler: direct
    work_directory: /tmp/test_aiida
    prepend_text: 'unset PYTHONPATH'

codes:
  bands_inspect:
    description: bands_inspect code
    default_plugin: bands_inspect.difference
    remote_computer: localhost
    remote_abspath: /home/a-dogres/.virtualenvs/bands-inspect/bin/bands-inspectNote:aiida-pytestis not compatible with theaiida-xdistplugin, since the fixtures withscope=sessionare then called for each running worker.Defining and running testsTests withaiida-pytestare defined and run exactly like "regular"pytesttests. If a test needs the AiiDA database, it should use theconfigurefixture. If the test also requires the Daemon to run, it should use theconfigure_with_daemonfixture. Note that, since certain AiiDA import statements require the database backend to be set, these imports should be doneinsidethe test function.After the tests have run, the code will wait for you to pressEnterbefore deleting the testing database and repository. This gives you the opportunity to manually inspect the final state. If you want to avoid this step (for example in a CI system), pass the--quiet-wipeflag topy.test.
Package: aiida-python
AiiDA PythonThis package is an AiiDA plugin allowing you to run python code asCalcJobon a remote computer. Usage is easy one has to inherit CalcJobPython class and instead ofprepare_for_submitionmethod one ahs to overloadrun_python. Parser is generated automatically one does not have to write its own.from aiida.plugins import CalculationFactory

CalcJobPython = CalculationFactory("aiida_python.calc")

class ClassThatCannotStartWithTestExample(CalcJobPython):

    @classmethod
    def define(cls, spec):
        super().define(spec)

        spec.input('inputarray', valid_type=ArrayData)
        spec.input('repeats', valid_type=Int)
        spec.output('value', valid_type=Float)

    def run_python(self):
        import numpy as np

        a = self.inputs.inputarray
        repeats = self.inputs.repeats
        a_inv = np.linalg.inv(a)

        for ii in range(repeats):
            a_inv = np.matmul(a_inv, a_inv)
            a_inv = a_inv/sum(a_inv)

        a = np.linalg.inv(a)

        c = float(np.sum(a))
        self.outputs.value = cHere is a test case exampledef test_example(aiida_local_code_factory, clear_database):
    from aiida.plugins import CalculationFactory
    from aiida.engine import run
    import numpy as np

    executable = 'python3'
    entry_point = 'test.calc_example'

    code = aiida_local_code_factory(entry_point=entry_point, executable=executable)
    calculation = CalculationFactory(entry_point)

    np_a = np.array([[1,2,1],[3,4,3],[0,1,1]])
    a = ArrayData()
    a.set_array("only_one", np_a)

    inputs = { 'code': code,
               'inputarray': a,
               'repeats': Int(10)}

    result = run(calculation, **inputs)For more information look at thislink.
Package: aiida-QECpWorkChain
aiida-QECpWorkChainCar-Parrinello Work Chain. This code was used to perform the simulation work of thisPhD thesisUsagesetup your aiida postgresql database, rabbitmq, and AiiDA. This can be done followingthe official documentationinstall the package viapip install .setup aiida-quantumespresso by configuring the remote computers and the remote code (cp.xandpw.x) as described inthe official documentation. Load the pseudopotential in the databaseas a starting point you can have a look at the example inexamples/example1.py, and change it according to your need. In particular you will need to modify the remote computer configuration and the pseudopotential family, and of course the starting configuration.
Package: aiida-qeq
aiida-qeqAiiDA plugin for computing electronic charges on atoms using equilibration-type models (QEq, EQEq, ...).Templated using theAiiDA plugin cutter.Installationgitclonehttps://github.com/ltalirz/aiida-qeq.cdaiida-qeq
pipinstall-e.# also installs aiida, if missing (but not postgres)#pip install -e .[pre-commit,testing] # install extras for more featuresverdiquicksetup# better to set up a new profileverdicalculationplugins# should now show your calclulation pluginsUsageHere goes a complete example of how to submit a test calculation using this plugin.A quick demo of how to submit a calculation:verdidaemonstart# make sure the daemon is runningcdexamples
verdirunsubmit_qeq.py# submit qeq test calculationverdirunsubmit_eqeq.py# submit eqeq test calculationverdicalculationlist-a# check status of calculationTestsThe following will discover and run all unit test:pipinstall-e.[testing]pythonmanage.pyLicenseMITContactleopold.talirz@gmail.com
Package: aiida-qp2
aiida-qp2AiiDA plugin forQuantum Package 2.0(QP2).This plugin is the modified output of theAiiDA plugin cutter,
intended to help developers get started with their AiiDA plugins.Repository contentsqp2/: The main source code of the plugin packagecalculations.py: A newQP2CalculationCalcJobclassparsers.py: A newParserfor theQP2Calculationdocs/: A documentation template. TheReadTheDocs documentationis built and deployed on thegh-pagesbranch.examples/: Examples of how to submit a calculation using this pluginLICENSE: License for your pluginMANIFEST.in: Configure non-Python files to be included for publication onPyPIREADME.md: This filesetup.json: Plugin metadata for registration onPyPIand theAiiDA plugin registry(including entry points)setup.py: Installation script for pip /PyPI.pre-commit-config.yaml: Configuration ofpre-commit hooksthat sanitize coding style and check for syntax errors. Enable viapip install -e .[pre-commit] && pre-commit install.github/:Github Actionsconfigurationci.yml: runs tests and builds documentation at every new commitpublish-on-pypi.yml: automatically deploy git tags to PyPIFeaturesInitialize a wave function file (EZFIO) based onStructureDatainstance andqp_create_ezfiodictionary.
This step can optionally useBasisSetand/orPseudopotentialnodes produced by theaiida-gaussian-datatypesplugin.Run calculations (e.g. HF, CIPSI) in a given order according to theqp_commandslist. Some pre- or post-processing (e.g.shellscripting) is also possible by providing a list of commands inqp_prependorqp_appendkeys of theparametersDict, respectively.Export TREXIO file from the QP-native EZFIO format.Installationpipinstallaiida-qp2
verdiquicksetup# better to set up a new profileverdipluginlistaiida.calculations# should now show your calclulation pluginsUsageSeeDemo-aiida-qp.mdand.pyfiles in theexamples/directory.For instance, theexample_trexio_from_xyz.pyis the 3-step workflow using the plugin.verdidaemonstart# make sure the daemon is runningcdexamples
pythonexample_trexio_from_xyz.py# prepare and submit the calculationverdiprocesslist-a# check record of calculationCreate the EZFIO wave function file from thehcn.xyzfile using a given basis set.Run SCF calculation using the previously created wave function and parse the output file looking for the Hartree-Fock energy.Export TREXIO wave function file by converting EZFIO format usingTREXIO_TEXTback end.Developmentgitclonehttps://github.com/TREX-CoE/aiida-qp2.cdaiida-qp2
pipinstall-e.[pre-commit]# install extra dependenciespre-commitinstall# install pre-commit hooksLicenseMITContactposenitskiy@irsamc.ups-tlse.frscemama@irsamc.ups-tlse.fr
Package: aiida-raspa
PluginAiiDAPython2.0.01.2.0AiiDA RASPAAiiDAplugin forRASPA2.Designed to work with with RASPA 2.0.37 or later.
Latest tests run for RASPA 2.0.47.DocumentationThe documentation for this package can be found onRead the Docs.InstallationIf you usepip, you can install it as:pip install aiida-raspaIf you want to install the plugin in an editable mode, run:git clone https://github.com/lsmo-epfl/aiida-raspa
cd aiida-raspa
pip install -e .  # Also installs aiida, if missing (but not postgres/rabbitmq).ExamplesSeeexamplesfolder for complete examples of setting up a calculation or a work chain.Simple calculationcdexamples/simple_calculations
verdirunexample_base.py<code_label>--submit# Submit example calculation.verdiprocesslist-a-p1# Check status of calculation.Work chaincdexamples/workchains
verdirunexample_base_restart_timeout.py<code_label># Submit test calculation.verdiprocesslist-a-p1# Check status of the work chain.LicenseMITAcknowledgementsThis work is supported by:theMARVEL National Centre for Competency in Researchfunded by theSwiss National Science Foundation;theMaX European Centre of Excellencefunded by the Horizon 2020 EINFRA-5 program, Grant No. 676598;theswissuniversities P-5 project "Materials Cloud".
Package: aiida-seigrowth
aiida-seigrowthA plugin to Python3.8 to model SEI growthRepository contents.github/:Github Actionsconfigurationci.yml: runs tests, checks test coverage and builds documentation at every new commitpublish-on-pypi.yml: automatically deploy git tags to PyPI - just generate aPyPI API tokenfor your PyPI account and add it to thepypi_tokensecret of your github repositoryaiida_seigrowth/: The main source code of the plugin packagecalculations.py: A newPbeSeiCalculationCalcJobclassdocs/: A documentation template ready for publication onRead the Docsexamples/: An example of how to submit a calculation using this plugin.gitignore: Telling git which files to ignore.pre-commit-config.yaml: Configuration ofpre-commit hooksthat sanitize coding style and check for syntax errors. Enable viapip install -e .[pre-commit] && pre-commit install.readthedocs.yml: Configuration of documentation build forRead the DocsLICENSE: License for your pluginREADME.md: This fileconftest.py: Configuration of fixtures forpytestpyproject.toml: Python package metadata for registration onPyPIand theAiiDA plugin registry(including entry points)InstallationBefore proceeding with the installation make sure that you have the right version of Pybamm installed correctly using the developer versionDownload the External Code folder and include the python script pb.py by modifying the script code.yml accordingly:Include the code by usingverdi code setup --config code.ymlProceed to install the pluginpipinstallaiida-seigrowth==0.0.4

verdiquicksetup# better to set up a new profileverdipluginlistaiida.calculations# should now show your calclulation pluginsUsageHere goes a complete example of how to submit a test calculation using this plugin.A quick demo of how to submit a calculation:Activate the pybamm environment$ source /absoulte/path/to/PyBaMM/.tox/dev/bin/activateProceed to launch the exampleverdidaemonstart# make sure the daemon is runningcdexamples
./example_01.py# run test calculationverdiprocesslist-a# check record of calculationLicenseMITContactluca.banetta@polito.it
Package: aiida-siesta
A plugin to interface theSiesta DFT codeto theAiiDA system.Documentation can be found in:http://aiida-siesta-plugin.readthedocs.ioIf you use this package in your research, please consider citing J. Chem. Phys.152, 204108 (2020)
(https://doi.org/10.1063/5.0005077) and the relevantaiida-corepapers.AcknowledgementsThis work is supported by theMaX
European Centre of Excellencefunded by
the Horizon 2020 INFRAEDI-2018-1 program, Grant No. 824143, by theINTERSECT(Interoperable material-to-device simulation box for
disruptive electronics) project, funded by Horizon 2020 under grant
agreement No 814487, and by the Spanish MINECO (projects
FIS2012-37549-C05-05 and FIS2015-64886-C5-4-P).
We thank the AiiDA team, who are also supported by theMARVEL National Centre for Competency in Researchfunded by theSwiss National Science Foundation
Package: aiida-spirit
aiida-spiritAiiDA plugin for thespirit codeInstallationpipinstallaiida-spirit# install aiida-spirit from pypiverdiquicksetup# better to set up a new profileverdipluginlistaiida.calculations# should now show your calclulation pluginsUsageHere goes a complete example of how to submit a test calculation using this plugin.A quick demo of how to submit a calculation (the spirit python API needs to be installed for this to work:pip install spirit):verdidaemonstart# make sure the daemon is runningcdexamples
./example_LLG.py# run test calculationverdiprocesslist-a# check record of calculationDevelopmentgitclonehttps://github.com/JuDFTteam/aiida-spirit.cdaiida-spirit
pipinstall-e.[pre-commit,testing]# install extra dependenciespre-commitinstall# install pre-commit hookspytest-v# discover and run all testsNote thatpytest -vwill create a test database and profile which requires to find thepg_ctlcommand.
Ifpg_ctlis not found you need to nake sure that postgres is installed and then add the localtion ofpg_ctlto thePATH:# add postgres path for pg_ctl to PATH
# this is an example for Postgres 9.6 installed on a mac
PATH="/Applications/Postgres.app/Contents/Versions/9.6/bin/:$PATH"
export PATHCitationIf you use AiiDA-Spirit please cite the method paperP. Rüßmann, J. Ribas Sobreviela, M. Sallermann, M. Hoffmann, F. Rhiem, and S. Blügel,The AiiDA-Spirit Plugin for Automated Spin-Dynamics Simulations and Multi-Scale Modeling Based on First-Principles Calculations, Front. Mater.9, 825043 (2022).doi: 10.3389/fmats.2022.825043,and the latest code releaseP. Rüßmann, J. Ribas Sobreviela, M. Sallermann, M. Hoffmann, F. Rhiem, and S. Blügel. JuDFTteam/aiida-spirit. Zenodo.doi: 10.5281/zenodo.8070770.LicenseThe AiiDA-Spirit code is under theMIT license.Contactp.ruessmann@fz-juelich.de
Package: aiida-ssh2win
aiida-ssh2winA transport plugin allowing AiiDA to run calculations on Windows machines.This plugin is the default output of theAiiDA plugin cutter,
intended to help developers get started with their AiiDA plugins.Repository contents.github/:Github Actionsconfigurationci.yml: runs tests, checks test coverage and builds documentation at every new commitpublish-on-pypi.yml: automatically deploy git tags to PyPI - just generate aPyPI API tokenfor your PyPI account and add it to thepypi_tokensecret of your github repositoryaiida_ssh2win/: The main source code of the plugin packagetransport.py: ContainsSshToWindowsTransport- a concrete implementation of AiiDA'sTransportinterfacedocs/: A documentation template ready for publication onRead the Docstests/: Unit testing using thepytestframework. Installpip install -e .[testing]and runpytest..gitignore: Telling git which files to ignore.pre-commit-config.yaml: Configuration ofpre-commit hooksthat sanitize coding style and check for syntax errors. Enable viapip install -e .[pre-commit] && pre-commit install.readthedocs.yml: Configuration of documentation build forRead the DocsLICENSE: License for your pluginREADME.md: This fileconftest.py: Configuration of fixtures forpytestpyproject.toml: Python package metadata for registration onPyPIand theAiiDA plugin registry(including entry points)Installationpipinstallaiida-ssh2win
verdiquicksetup# better to set up a new profileverdipluginlistaiida.transports# should now show the `ssh2win` pluginsUsageLicenseMITContactedan.bainglass@gmail.com
Package: aiida-sshonly
aiida-sshonlyAiiDA plugin adding a sshonly transport option, using only SSH to transfer files, avoiding SFTP, in case it's blocked or non functional on a remote systemFeaturesProvides a new 'sshonly' transport option when configuring a computer in AiiDA.
Uses SSH and shell commands to emulate SFTP commands used in AiiDA.Known limitation : only works with text files as of 0.1.0Installationpipinstallaiida-sshonly
reentryscan
verdipluginlistaiida.transports# should now show your calclulation pluginsUsageHere goes a complete example of how to submit a test calculation using this plugin.A quick demo of how to submit a calculation:verdidaemonstart# make sure the daemon is runningcdexamples
./example_01.py# run test calculationverdiprocesslist-a# check record of calculationThe plugin also includes verdi commands to inspect its data types:verdidatasshonlylist
verdidatasshonlyexport<PK>Developmentgitclonehttps://github.com/adegomme/aiida-sshonly.cdaiida-sshonly
pipinstall-e.[pre-commit,testing]# install extra dependenciespre-commitinstall# install pre-commit hookspytest-v# discover and run all testsSee thedeveloper guidefor more information.LicenseMIT
Package: aiida-sssp-workflow
SSSP workflowFor maintainersTo create a new release, clone the repository, install development dependencies withpip install '.[dev]', and then executebumpver update.
This will:Create a tagged release with bumped version and push it to the repository.Trigger a GitHub actions workflow that creates a GitHub release.Additional notes:Use the--dryoption to preview the release change.The release tag (e.g. a/b/rc) is determined from the last release.
Use the--tagoption to switch the release tag.Logger levelThe aiida-core logger level is recommened to set toREPORTas default.
In workflow, process related messages are pop to daemon logger in REPORT level.
If process finished with none-zero exit_code, log a waring message.
While for debug purpose, the INFO level is for showing the parameters infomations when processes are launched.Issues of versionv3.0.1:nowf not turned on for saving inode purpose, fixed in next versionthe dual value of NC/SL is 8 for precision measure and bands for norm-conserving pseudopotentials, better to be 4. fixed in next versionthe dual value for high dual elements is 8 for non-NC pseudopotentials, better to be 16. fixed in next versionLicenseMITContact📧 email:jusong.yu@psi.ch
Package: aiida-statefile-schedulers
aiida-statefile-schedulersSimple statefile-driven task schedulers: Currently AiiDA relies mostly on full fledged task schedulers to run jobs
in complex workflows. Running such workflows with the direct scheduler often means that many processes run together
even whenrunningthe workflow directly (e.g. not submitting to the daemon), overloading a single node.This scheduler does not run any jobs. Instead, it createsstate filesof the form$jobid.QUEUEDin the directory${AIIDA_STATE_DIR}(an environment variable you have to set in your.profile/.bash_profileof the target machine),
waiting for some script to pick the jobs up and run them.Thisrunner scriptshould create a file$jobid.DONEwhen done. As intermediate steps it can also create a file$jobid.RUNNINGto
signal AiiDA that it picked up a job. The initial state file contains lines of the formkey=valuewith the following keys:cwd: the working directory for this jobcmd: the command to run there (usually viabash -e ...)The state files can also be renamed instead of created. A sample runner can be found inscripts/.FeaturesInstallationpipinstallaiida-statefile-scheduler
verdiquicksetup# better to set up a new profileverdipluginlistaiida.schedulers# should now show your calculation pluginsDevelopmentgitclonehttps://github.com/dev-zero/aiida-statefile-schedulers.cdaiida-statefile-schedulers
pipinstall-e.[pre-commit,testing]# install extra dependenciespre-commitinstall# install pre-commit hookspytest-v# discover and run all testsSee thedeveloper guidefor more information.LicenseMITContacttm@dev-zero.ch
Package: aiida-submission-controller
AiiDA submission controllerSome classes to help managing large number of submissions, while controlling the maximum number of submissions running at any given time.This project is still in early phase and the API might change.It includes an abstract base class that implements the main logic, a very simple example of an implementation
to compute a 12x12 addition table (inexamples/add_in_batches.py), and a main script to run it (and get results and show them).To use it, you are supposed to launch the script (e.g. in ascreenterminal) with something like this:cdexampleswhiletrue;doverdirunadd_in_batches.py;sleep5;donewhere you can adapt the sleep time.
Typically, for real simulations, you might want something in the
range of 5-10 minutes, or anyway so that at every new run you have at least some new processes to submit,
but still less that the maximum number of available slots, to try to keep the 'queue' quite filled at any
given time.There is also a second subclass that, rather than just creating new submissions from some extras, will use (input) nodes in another group as a reference for which calculations to run (e.g.: a group of crystal structures, representing the inputs to a set of workflows).
Package: aiida-testing-dev
aiida-testingA pytest plugin to simplify testing of AiiDA plugins. This package implements two ways of running an AiiDA calculation in tests:mock_code: Implements a caching layer at the level of the executable called by an AiiDA calculation. This tests the input generation and output parsing, which is useful when testing calculation and parser plugins.export_cache: Implements an automatic export / import of the AiiDA database, to enable AiiDA - level caching in tests. This circumvents the input generation / output parsing, making it suitable for testing higher-level workflows.For more information, see thedocumentation.
Package: aiida_upgrade
aiida-upgradeIn Development!A tool to aide upgrades of plugins to new aiida-core versionsUsageTo use the command line tool, it is recommended to install viapipx:$pipxinstallaiida-upgradeOnce installed, you can simply runaiida-upgradeon anyPATH, which can be a single file or a directory:$aiida-upgrade--helpUsage: aiida-upgrade [OPTIONS] PATHThe command line interface of aiida-upgrade.Options:--help  Show this message and exit.In casePATHis a directory,aiida-upgradewill recursively update all.pyfiles inside that directory.Supported migrationsCurrently,aiida-upgradeperforms the following code refactoring:Look for deprecatedaiida-coreentry points loaded by plugin factories and add thecore.prefix, seethe corresponding section in the plugin migration guide.Similarly, find and correct full deprecated entry point strings e.g.'aiida.data:structure'.Removedictandlistkeywords from theDictandListnode constructors, respectively.
SeePR #5165 onaiida-core, which removed the requirement of using these keywords.Migration steps that are not (yet) supported are:Adding thecore.prefix in shell scripts.Update'name'to'label'when querying for aComputerwith theQueryBuilder.Small changes in the API ofTransportandSchedulerplugins.Removal of thePluginTestCaseclass.If you find any problems with the current refactoring, or any migration steps that are missing, please let us know by opening an issue.