Saravanan666/pypi-org huggingface dataset:
Package: aihubcli
Project Structure for MLflow integrated ML ProjectsThis cli tool generates the following directory structure for quickstart ML projectsinstallaton:pip install aihubcliexample use:aihubcli create myProjectmyProject/
│
├── input/
│   ├── raw/                <-- Raw data here
│   ├── interim/            <-- Any intermediate data, to pause and continue experiments
│   └── processed/          <-- Processed data ready for ML pipeline
│
├── output/
│   ├── models/             <-- Model pickle or model weights stored here
│   ├── artifacts/          <-- Serialized artifacts like LabelEncoder, Vectorizer etc
│   ├── figures /            <-- All plots and visualizations goes here
│   └── results/            <-- If the results needs to be stored for review, save here
│
├── notebooks/              <-- All notebooks and experiments resides here
│   ├── eda_plots.ipynb     <-- ┌───────────────────────────────────────────┐
│   ├── ml_rnn.ipynb        <-- │ free to name notebooks any way you prefer │
│   └── ml_seq2seq.ipynb    <-- └───────────────────────────────────────────┘
│
├── src/                    <-- Final program, with training and prediction pipeline
│   ├── __init__.py         <-- Makes src a Python module                    
│   ├── preprocess.py       <-- code related to preprocessing the data and storing it in input/processed/
│   ├── model.py            <-- model definition here, can be used in train or prediction
│   ├── train.py            <-- all code related to training model goes here
│   ├── hyperopt.py         <-- hyperparameter optimizations related code
│   ├── package.py          <-- packaging the trained model with preprocessing logic for MLflow
│   ├── predict.py          <-- prediction logic, usually loads the model from Mlflow registry and predict
│   └── server.py           <-- any API interface like Flask etc. Create as needed
│
README.md                   <-- Description and instruction about the project
MLProject                   <-- MLflow project file. If you want to use this directory as MLflow project
requirements.txt            <-- python dependencies
config.yml                  <-- configuration key value pairs in yaml format
Package: aiida
AiiDA (www.aiida.net) is a workflow manager for computational science with a strong focus on provenance, performance and extensibility.DeprecatedThis metapackage for AiiDA has been deprecated as of v1.0 and is no longer being maintained.
If you want to install AiiDA, please install theaiida-corepackageinstead.AcknowledgementsAiiDA is aNumFOCUS Affiliated Projectand supported by theMARVEL National Centre of Competence in Research, theMaX European Centre of Excellenceand by a number of other supporting projects, partners and institutions, whose complete list is available on theAiiDA website acknowledgements page.
Package: aiida-abinit
aiida-abinitThis is anAiiDAplugin forABINIT.InstallationTo install from PyPI, simply execute:pip install aiida-abinitTo install from source, execute:git clone https://github.com/sponce24/aiida-abinit
pip install aiida-abinitPseudopotentialsPseudopotentials are installed and managed through theaiida-pseudoplugin.
The easiest way to install pseudopotentials is to install a version of thePseudoDojothrough the CLI ofaiida-pseudo.
To install the default PseudoDojo version, run:aiida-pseudo install pseudo-dojoList the installed pseudopotential families with the commandaiida-pseudo list.AcknowledgementsThis work was supported by the the European Unions Horizon 2020 Research and Innovation Programme,
under theMarie Skłodowska-Curie Grant Agreement SELPH2D No. 839217.LicenseMITContactaiida-abinitis developed and maintained bySamuel Poncé-samuel.pon@gmail.comGuido PetrettoAustin Zadoks-austin.zadoks@epfl.ch
Package: aiida-ase
aiida-aseAiiDA plugin for ASEInstallationFrom PyPIpip install aiida-aseFrom this repository (useful for development):git clone https://github.com/aiidateam/aiida-ase
pip install -e aiida-aseUsageThe main goal of this plugin is to be a wrap around for ASE.To make it easy to setup the calculation generate abuilderas followsAseCalculation = CalculationFactory('ase.ase')
builder = AseCalculation.get_builder()The main parameters for the builder that need to be specified are:Codefrom aiida.orm import load_code
code = load_code('your-code-here@your-computer-here')
builder.code = codeNOTE: If using GPAW, there are two possibilities to set up the calculator
a. Specify the Python executable with specific module loaded for GPAW
b. Specify directly the GPAW executable. In this case a CMDLINE parameter will be needed (see below).Structurebuilder.structure = structurek-points datakpoints = KpointsData()
kpoints.set_kpoints_mesh([2,2,2])  # choose the right mesh here
builder.kpoints = kpointsParametersAn example parameter set for GPAW is shown here in parts. See theexamplesfolder for specific examples for other functionality (will be constantly updated).Define a calculator for aPWcalculation with GPAW. Here thenameof the calculator is set to GPAW,argsis the equivalent of arguments passed into the calculator used in ASE. Note that the@functionfunctionality enables passing arguments to a function inside the calculators. In this example the equivalent ASE command isPW(300). Other arguments such asconvergenceandoccupationscan be added.calculator = {
    'name': 'gpaw',
    'args': {
    'mode': {
        '@function': 'PW',
        'args': {'ecut': 300}
    },
    'convergence': {
        'energy': 1e-9
    },
    'occupations': {
        'name': 'fermi-dirac',
        'width':0.05
    }
}Add here tags that will be written asatoms.get_xyz(), so for example the first item will beatoms.get_temperature().atoms_getters = [
    'temperature',
    ['forces', {'apply_constraint': True}],
    ['masses', {}],
]Some addition utility functions are:pre_lines: list of lines to added to the start of the python filepost_lines: list of lines to added to the end of the python fileextra_imports: list of extra imports as separated strings, for example["numpy", "array"]will lead tofrom numpy import arrayNote about choosing a codeIf using GPAW it is possible to run parallel calculations using/path/to/execut/gpaw python run_gpaw.py. Set up the code through AiiDA by adding in thegpawexecutable. The add thepythontag using the command line optionsettings = {'CMDLINE': ['python']}
builder.settings = orm.Dict(settings)If the code you are interested in is present in this plugin registry it might make more sense to use thathttps://aiidateam.github.io/aiida-registry/DocumentationThe documentation for this package can be found on Read the Docs athttp://aiida-ase.readthedocs.io/en/latest/
Package: aiida-atoms
aiida-atomsAiiDA Plugin for keeping track of structure manipulations of anase.Atomsobjects.
Every operation acted through theAtomsTrackerobject will be recorded on the provenance graph.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_atoms/: The main source code of the plugin packagedocs/: A documentation template ready for publication onRead the Docsexamples/: An example of how to submit a calculation using this plugintests/: Basic regression tests using thepytestframework (submitting a calculation, ...). 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 installLICENSE: 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)FeaturesAutomatic tracking of changes made toase.Atomsobject through its methods, and saving them to the provenance graph.Wrapped other common routines that records provenance for tracking.Provenance graph visualization.Installationpipinstallaiida-atomsUsageDevelopmentgitclonehttps://github.com/zhubonan/aiida-atoms.cdaiida-atoms
pipinstall--upgradepip
pipinstall-e.[pre-commit,testing]# install extra dependenciespre-commitinstall# install pre-commit hookspytest-v# discover and run all testsLicenseMITContactzhubonan@outlook.com
Package: aiida-aurora
aiida-auroraAiiDA plugin for the Aurora project (autonomous robotic battery innovation platform).
A collaboration between EPFL & Empa, within the BIG-MAP Stakeholder Initiative Call 2021-2023.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_aurora/: The main source code of the plugin packagedata/: A newDiffParametersdata class, used as input to theDiffCalculationCalcJobclasscalculations.py: A newDiffCalculationCalcJobclasscli.py: Extensions of theverdi datacommand line interface for theDiffParametersclasshelpers.py: Helpers for setting up an AiiDA code fordiffautomaticallyparsers.py: A newParserfor theDiffCalculationdocs/: A documentation template ready for publication onRead the Docsexamples/: An example of how to submit a calculation using this plugintests/: Basic regression tests using thepytestframework (submitting a calculation, ...). Installpip install -e .[testing]and runpytest..coveragerc: Configuration ofcoverage.pytool reporting which lines of your plugin are covered by tests.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 pluginMANIFEST.in: Configure non-Python files to be included for publication onPyPIREADME.md: This fileInstallationpipinstallaiida-aurora
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: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:verdidataauroralist
verdidataauroraexport<PK>Developmentgitclonehttps://github.com/epfl-theos/aiida-aurora.cdaiida-aurora
pipinstall-e.[pre-commit,testing]# install extra dependenciespre-commitinstall# install pre-commit hookspytest-v# discover and run all testsSee thedeveloper guidefor more information.LicenseMITAcknowledgementsThis project was supported by the Open Research Data Program of the ETH Board.ContactEdan Bainglass (edan.bainglass@psi.ch)Francisco F. Ramirez (ramirezfranciscof@gmail.com)Loris Ercole (loris.ercole@gmail.com)Giovanni Pizzi (giovanni.pizzi@psi.ch)
Package: aiida-bader
AiiDA-BaderAiiDA plugin forBadercharge analysis.InstallationTo install from PyPI, simply execute:pip install aiida-baderor when installing from source:git clone https://github.com/superstar54/aiida-bader
pip install aiida-baderDevelopmentRunning testsTo run the tests, simply clone and install the package locally with the [tests] optional dependencies:gitclonehttps://github.com/superstar54/aiida-bader.cdaiida-bader
pipinstall-e.[tests]# install extra dependencies for testpytest# run testsPre-commitTo contribute to this repository, please enable pre-commit so the code in commits are conform to the standards.
Simply install the repository with thepre-commitextra dependencies:cdaiida-bader
pipinstall-e.[pre-commit]pre-commitinstallLicenseTheaiida-baderplugin package is released under the MIT license.
See theLICENSEfile for more details.AcknowledgementsWe acknowledge support from:theNCCR MARVELfunded by the Swiss National Science Foundation;
Package: aiida-bigdft
aiida-bigdftTranslation layer for AiiDA-PyBigDFTInstallationpipinstallaiida-bigdft
verdiquicksetup# better to set up a new profileverdipluginlistaiida.calculations# should now show your calculation pluginsRequirementsA functioning BigDFT installationA copy ofbigdft.py(Available in later versions of BigDFT, but also in this repository atbigdft/bigdft.py)When setting up the BigDFT code, ensure that the executable is set to thebigdft.pyscript.It is also important to source theinstall/bin/bigdftvars.shscript in your prepend.# aiida code prependsource${BIGDFT_BUILD_DIR}/install/bin/bigdftvars.shWhere BIGDFT_BUILD_DIR is the directory in which BigDFT was built.UsageTo see how calculations can be submitted, see the examples directory:verdidaemonstart# make sure the daemon is runningcdexamples
verdirunexamples/example_01.py# run test calculationverdiprocesslist-a# check record of calculationThe plugin also includes verdi commands to inspect its data types:verdidatabigdftlist
verdidatabigdftexport<PK>WorkChainsThe included workchains use thenamespaceformat, so inputs should be placed under thebigdftnamespace when launching a workchainLicenseMITContactbigdft-developers@lists.launchpad.net
Package: aiida-catmat
aiida-catmatCollection ofAiiDAWorkChains developed inCATMAT projectatUniversity of OxfordandUniversity of Bath.Compatible with:Installation, usage, and available workchainsPlease check thedocumentation.ContactPlease contactPezhman Zarabadi-Poorif you have any questions regarding this package.AcknowledgmentI think the Faraday Institution (FI) CATMAT project (EP/S003053/1, FIRG016) for financial support. I'd also thank
Dr. Benjamin Morgan, Dr. Alex Squires, and Hollie Richards for their inputs during the developemnt.
Package: aiida-codtools
aiida-codtoolsThis is the official AiiDA plugin forcod-tools.Compatibility matrixThe following table shows which versions ofaiida-codtoolsare compatible with which versions of AiiDA and Python.PluginAiiDAPythonv3.0.0 < v4.0.0v2.2.0 < v3.0.0v2.1.0 < v2.2.0v2.0.0 < v2.1.0v1.0.0 < v2.0.0InstallationTo install from PyPi, simply execute:pip install aiida-codtoolsor when installing from source:git clone https://github.com/aiidateam/aiida-codtools
pip install aiida-codtoolsGet startedIn order to useaiida-codtools, after installing the package,aiida-coreneeds to be setup and configured.
For instructions please follow the documentation ofaiida-core.The package provides a command line scriptaiida-codtoolsthat comes with some useful commands, such as launching calculation or imports CIF files.
Call the command with the--helpflag to display its usage:Usage: aiida-codtools [OPTIONS] COMMAND [ARGS]...

  CLI for the `aiida-codtools` plugin.

Options:
  -p, --profile PROFILE  Execute the command for this profile instead of the default profile.
  -h, --help             Show this message and exit.

Commands:
  calculation  Commands to launch and interact with calculations.
  data         Commands to import, create and inspect data nodes.
  workflow     Commands to launch and interact with workflows.Each sub command can have multiple other sub commands.
To enable tab completion, add the following line to your shell activation script:eval "$(_AIIDA_CODTOOLS_COMPLETE=source aiida-codtools)"To import 10 random CIF files from the COD database, for example, you can do the following:verdi group create cod_cif_raw
aiida-codtools data cif import -d cod -G cod_cif_raw -M 10After you have configured a computer and a code, you can also easily launch acod-toolscalculation through AiiDA:aiida-codtools calculation launch cod-tools -X cif-filter -N 10Herecif-filteris the label of the code that you have configured and10is the pk of aCifDatanode.
These will most likely be different for your database, so change them accordingly.DocumentationThe documentation for this package can be found onreadthedocs.AcknowledgementsThis work is supported in part by theswissuniversities P-5 project "Materials Cloud".
Package: aiida-common-workflows
AiiDA common workflows (ACWF) package:aiida-common-workflows(Image © Giovanni Pizzi, 2021)The AiiDA common workflows (ACWF) project provides computational workflows, implemented inAiiDA, to compute various material properties using any of the quantum engines that implement it.
The distinguishing feature is that the interfaces of the AiiDA common workflows are uniform, independent of the quantum engine that is used underneath to perform the material property simulations.
These common interfaces make it trivial to switch from quantum engine.
In addition to the common interface, the workflows provide input generators that automatically define the required inputs for a given task and desired computational precision.
For more information, please refer to theonline documentation.How to citeIf you use the workflow of this package, please cite the paper in which the work is presented:S. P. Huber et al., npj Comput. Mater. 7, 136 (2021); doi:10.1038/s41524-021-00594-6In addition, if you run the common workflows, please also cite:The AiiDA engine that manages the simulations and stores the provenance:Main AiiDA paper:S.P. Huber et al., Scientific Data 7, 300 (2020)AiiDA engine:M. Uhrin et al., Comp. Mat. Sci. 187 (2021)the quantum engine(s) that you will use. We provide below a table of references for your convenience.EngineDOIs or URLs to be citedABINIT10.1016/j.cpc.2016.04.00310.1016/j.cpc.2019.10704210.1063/1.5144261BigDFT10.1063/5.0004792CASTEP10.1524/zkri.220.5.567.65075CP2K10.1002/wcms.115910.1063/5.0007045FLEURhttps://www.flapw.deGaussiansee instructions hereGPAW10.1103/PhysRevB.71.03510910.1088/0953-8984/22/25/253202NWChem10.1063/5.0004997ORCA10.1002/wcms.8110.1002/wcms.1327Quantum ESPRESSO10.1088/0953-8984/21/39/39550210.1088/1361-648x/aa8f79SIESTA10.1063/5.000507710.1088/0953-8984/14/11/302VASP10.1103/physrevb.54.1116910.1103/physrevb.59.1758WIEN2k10.1063/1.5143061
Package: aiida_conda_scheduler
aiida_conda_schedulerAiiDA scheduler plugins that allow forconda run.Currently, as of aiida-corev2.0.1, it is impossible to set up aComputer+Codewhich can run, for example:condarun--namemyenvmpirun-np4pw.x-iinput.insince, (a) a code can only specify aremote_abs_pathand (b) only a computer can specify thempirun_command.This is really the only way to run a code which is not in the Condabaseenvironment, sinceconda activate myenv(which could perhaps be added toprepend_text) fails when run in a script.These scheduler plugins subclass the built-in scheduler subclasses, and overrides the_get_run_linemethod and:Raises aNotImplementedErroriflen(codes_info) != 1orcodes_run_mode != CodeRunMode.SERIAL(i.e. only one code is supported).Loads the code fromcodes_info[0].code_uuidand retrieves its descriptionUses this description to determine the environment name, by findingenv=myenvAppendsconda run --name myenvto the run line.Installationpipinstallaiida_conda_scheduler
reentryscan# aiida v1.x onlyThen the plugins should show in:verdipluginlistaiida.schedulersDevelopmentUsepipxto install thetoxandpre-commitcommand tools.gitclonehttps://github.com/chrisjsewell/aiida-conda-scheduler.cdaiida-conda-scheduler
pre-commitrun--all
toxFor aiida-core v1, use e.g.tox-epy38-v1LicenseMITContactchrisj_sewell@hotmail.com
Package: aiida-core
AiiDA (www.aiida.net) is a workflow manager for computational science with a strong focus on provenance, performance and extensibility.Latest releaseGetting helpBuild statusBenchmarksActivityCommunityFeaturesWorkflows:Write complex, auto-documenting workflows in
python, linked to arbitrary executables on local and remote
computers. The event-based workflow engine supports tens of
thousands of processes per hour with full checkpointing.Data provenance:Automatically track inputs, outputs & metadata
of all calculations in a provenance graph for full
reproducibility. Perform fast queries on graphs containing
millions of nodes.HPC interface:Move your calculations to a different computer
by changing one line of code. AiiDA is compatible with schedulers
likeSLURM,PBS
Pro,torque,SGEorLSFout of the box.Plugin interface:Extend AiiDA withpluginsfor new simulation codes (input generation & parsing), data types, schedulers, transport modes and more.Open Science:Export subsets of your provenance graph and share them with peers or make them available online for everyone
on theMaterials Cloud.Open source:AiiDA is released under theMIT open source licenseInstallationPlease see AiiDA'sdocumentation.How to contributeThe AiiDA team appreciates help from a wide range of different backgrounds.
Small improvements of the documentation or minor bug fixes are always welcome.Please see theContributor wikion how to get started.Frequently Asked QuestionsIf you are experiencing problems with your AiiDA installation, please refer to theFAQ page of the documentation.
For any other questions, discussion and requests for support, please visit theDiscourse server.How to citeIf you use AiiDA in your research, please consider citing the following publications:S. P. Huberet al.,AiiDA 1.0, a scalable computational infrastructure for automated reproducible workflows and data provenance, Scientific Data7, 300 (2020); DOI:10.1038/s41597-020-00638-4M. Uhrinet al.,Workflows in AiiDA: Engineering a high-throughput, event-based engine for robust and modular computational workflows, Computational Materials Science187, 110086 (2021); DOI:10.1016/j.commatsci.2020.110086If the ADES concepts are referenced, please also cite:Giovanni Pizzi, Andrea Cepellotti, Riccardo Sabatini, Nicola Marzari,and Boris Kozinsky,AiiDA: automated interactive infrastructure and database for computational science, Computational Materials Science111, 218-230 (2016); DOI:10.1016/j.commatsci.2015.09.013LicenseAiiDA is distributed under the MIT open source license (seeLICENSE.txt).
For a list of other open source components included in AiiDA, seeopen_source_licenses.txt.AcknowledgementsAiiDA is aNumFOCUS Affiliated Projectand supported by theMARVEL National Centre of Competence in Research, theMaX European Centre of Excellenceand by a number of other supporting projects, partners and institutions, whose complete list is available on theAiiDA website acknowledgements page.
Package: aiida-core-bot
AiiDAAutomated Interactive Infrastructure and Database for Computational
ScienceAiiDA is a sophisticated framework designed from scratch to be a
flexible and scalable infrastructure for computational science. Being
able to store the full data provenance of each simulation, and based on
a tailored database solution built for efficient data mining
implementations, AiiDA gives the user the ability to interact seamlessly
with any number of HPC machines and codes thanks to its flexible plugin
interface, together with a powerful workflow engine for the automation
of simulations.The official homepage is athttp://www.aiida.netThe code is hosted on GitHub athttps://github.com/aiidateam/aiida_coreThe documentation is hosted on Read The Docs at:stable versiondevelop versionWhich branch should you use?Users: the stable version of the code is in themaster
branchDevelopers: the procedure to contribute through pull-requests
can be found in thewikiHow to cite AiiDAIf you use AiiDA in your research, please consider citing the following
work:Giovanni Pizzi, Andrea Cepellotti, Riccardo Sabatini, Nicola Marzari,
and Boris Kozinsky,AiiDA: automated interactive infrastructure and
database for computational science, Comp. Mat. Sci 111, 218-230
(2016);http://dx.doi.org/10.1016/j.commatsci.2015.09.013;http://www.aiida.net.LicenseThe terms of the AiiDA license can be found in the LICENSE.txt file.AcknowledgementsThis work is supported by theMARVEL National Centre for Competency in
Researchfunded by theSwiss National
Science Foundation, as well as by theMaX
European Centre of Excellencefunded by
the Horizon 2020 EINFRA-5 program, Grant No. 676598.