{
    "info": {
        "author": "M. N. Gjerding",
        "author_email": "mogje@fysik.dtu.dk",
        "bugtrack_url": null,
        "classifiers": [
            "Development Status :: 4 - Beta",
            "Environment :: Console",
            "Intended Audience :: Developers",
            "License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)",
            "Operating System :: Unix",
            "Programming Language :: Python :: 3.6",
            "Programming Language :: Python :: 3.7",
            "Programming Language :: Python :: 3 :: Only"
        ],
        "description": "Warning: This project is under active development but you are welcome to try it out.\n\nAtomic Simulation Recipes\n=========================\nRecipes for Atomic Scale Materials Research.\n\nCollection of python recipes for common (and not so common)\ntasks perfomed in atomic scale materials research. These tasks include\nrelaxation of structures, calculating ground states, calculating band\nstructures, calculating dielectric functions and so on.\n\n\nInstallation\n------------\nTo install ASR first clone the code and pip-install the code\n```console\n$ cd ~ && git clone https://gitlab.com/mortengjerding/asr.git\n$ python3 -m pip install -e ~/asr\n```\n\nASE has to be installed manually since we need the newest version:\n```console\n$ python3 -m pip install git+https://gitlab.com/ase/ase.git\n```\n\nAlso if you don't already have GPAW installed you can get it with\n```console\n$ python3 -m pip install git+https://gitlab.com/gpaw/gpaw.git\n```\n\nInstall a database of reference energies to calculate HOF and convex hull. Here \nwe use a database of one- and component-structures from OQMD\n```\n$ cd ~ && wget https://cmr.fysik.dtu.dk/_downloads/oqmd12.db\n$ echo 'export ASR_REFERENCES=~/oqmd12.db' >> ~/.bashrc\n```\n\nWe do relaxations with the D3 van-der-Waals contribution. To install the van \nder Waals functional DFTD3 do\n```console\n$ mkdir ~/DFTD3 && cd ~/DFTD3\n$ wget http://chemie.uni-bonn.de/pctc/mulliken-center/software/dft-d3/dftd3.tgz\n$ tar -zxf dftd3.tgz\n$ make\n$ echo 'export ASE_DFTD3_COMMAND=$HOME/DFTD3/dftd3' >> ~/.bashrc\n$ source ~/.bashrc\n```\n\nTo make Bader analysis we use another program. Download the executable for Bader \nanalysis and put in path (this is for Linux, find the appropriate executable):\n```console\n$ cd ~ && mkdir baderext && cd baderext\n$ wget http://theory.cm.utexas.edu/henkelman/code/bader/download/bader_lnx_64.tar.gz\n$ tar -zxf bader_lnx_64.tar.gz\n$ echo  'export PATH=~/baderext:$PATH' >> ~/.bashrc\n```\n\nAdditionally, you might also want\n* myqueue\n\nif you want to run jobs on a computer-cluster.\n\nFinally, test the package with\n```console\n$ asr test\n```\n\nHow to use\n----------\nASR comes with some built in functions. To see these simply write\n```console\n$ asr\nUsage: asr [OPTIONS] COMMAND [ARGS]...\n\nOptions:\n  -h, --help  Show this message and exit.\n\nCommands:\n  help      See help for recipe.\n  list      Show a list of all recipes.\n  run       Run recipe or ASE command.\n  status    Show the status of the current folder for all ASR recipes.\n  test      Run test of recipes.\n  workflow  Helper function to make workflows for MyQueue.\n```\n\nLet's put these functions into use by calculating some properties of \nSilicon. To get an overview of the possible recipes we can use the `list`\ncommand to list the known recipes:\n```console\n$ asr list\nRecipe                Description\n------                -----------\ncollect               Collect data in ase database.\nstructureinfo         Get quick information about structure based...\nbrowser               Open results in web browser.\nrelax                 Relax atomic positions and unit cell.\nsetup.decorate        Decorate structure with different atoms.\nsetup.params          Make a new params file.\nsetup.unpackdatabase  Set up folders with atomic structures based...\nsetup.magnetize       Set up magnetic moments of atomic structure.\ngs                    Calculate ground state density.\ndos                   Calculate DOS.\npolarizability        Calculate linear response polarizability or...\nconvex_hull\nphonons               Calculate Phonons.\nanisotropy\nbader                 Calculate bader charges.\nborncharges           Calculate Born charges.\nbandstructure         Calculate electronic band structure.\npush                  Push structure along some phonon mode and...\n```\n\nLet's say we want to relax a structure. We can search for `relax` and only get a\nsubset of this list:\n```console\n$ asr list relax\nRecipe                Description\n------                -----------\nrelax                 Relax atomic positions and unit cell.\nsetup.unpackdatabase  Set up folders with atomic structures based...\nsetup.magnetize       Set up magnetic moments of atomic structure.\npush                  Push structure along some phonon mode and...\n```\n\nfrom which is clear that we will probably want to use the `relax` recipe. To see\nmore details about this recipe we can use the `help` function:\n```console\n$ asr help relax\nUsage: asr run relax [OPTIONS]\n\n  Relax atomic positions and unit cell.\n\n  By default, this recipe takes the atomic structure in 'unrelaxed.json' and\n  relaxes the structure including the DFTD3 van der Waals correction. The\n  relaxed structure is saved to `structure.json` which can be processed by\n  other recipes.\n\nOptions:\n  --skip-deps / --run-deps  Skip execution of dependencies?  [default: False]\n  --ecut INTEGER            Energy cutoff in electronic structure calculation\n                            [default: 800]\n  --kptdensity FLOAT        Kpoint density  [default: 6.0]\n  -U, --plusu               Do +U calculation  [default: False]\n  --xc TEXT                 XC-functional  [default: PBE]\n  --d3 / --nod3             Relax with vdW D3  [default: True]\n  --width FLOAT             Fermi-Dirac smearing temperature  [default: 0.05]\n  --help                    Show this message and exit.\n```\n\nSo to relax a structure, we start by creating\na new folder and put an `unrelaxed.json` file into the directory containing\nthe atomic structure of Silicon.\n```console\n$ mkdir ~/silicon && cd ~/silicon\n$ ase build -x diamond Si unrelaxed.json\n```\nWe can relax the structure by using the `asr run` command.\n```console\n$ asr run relax\n```\n\nTo see what happened we can use the `status` command\n```console\n$ asr status\nasr.relax           Done -> ['results_relax.json']\nasr.gs              Todo\nasr.dos             Todo\n...\n```\nwhich shows that we have run the relax recipe and that the results have been \nstored to the `results_relax.json` file. In the process of looking for\ninteresting recipes we also found the `structureinfo` recipe which computes\nsome information about the atomic structure of the materials. Let's run that:\n```console\n$ asr run structureinfo\n```\n\nASR lets us save all data to a database by running the `collect` recipe. The \ndatabase is saved to a file `database.db`. This database is an ASE database and\ncan be browsed using the `ase db` module:\n```console\n$ asr run collect\n$ ase db database.db\nid|age|user |formula|calculator| energy| fmax|pbc|volume|charge|  mass| smax\n 1| 7s|mogje|Si2    |dftd3     |-10.738|0.000|TTT|41.204| 0.000|56.170|0.001\nRows: 1\n```\nWe can also browse this database by using the `browser` recipe which starts a\nlocal server and lets you browse the database interactively:\n```console\n$ asr run browser\n```\n\nThe ASR run command\n-------------------\nAs you have just seen, the `run` command is used to execute run the recipes of ASR.\nIn most cases the run command is identical to executing the recipes as modules, ie.,\n`asr run relax` is equivalent to `python -m asr.relax`. However, another usecase \nencountered frequently enough is to want to run a recipe in multiple directories.\n\nThe asr run command enables this with the following syntax:\n```console\n$ asr run relax in folder1/ folder1/\n```\nwhich makes it easy to run commands in multiple folders. If you want to provide\narguments for the recipe (the relax recipe in this example) you can use\n```console\n$ asr run relax --ecut 100 in folder1/ folder1/\n```\nThe last option that the run commands provides is to execute other python modules\nlike `ase`. For example, suppose you have a lot of folders with a `structure.traj`\nthat you want to convert to `structure.json`. This can be done with the ase command\n`ase convert structure.traj structure.json`. `run` can run this script in\nmany folders for you with\n```console\n$ asr run command ase convert structure.traj structure.json in materials/*/\n```\nwhere the `command` `asr run command` is used to tell ASR that the command you\nwish to run is not a recipe.\n\n\nThe setup recipes\n-----------------\nASR also includes some special `setup` recipes. These recipes are meant to give\nthe user some easy tools to setup atomic structures. Here we provide some explanations\nof their usage.\n\n* The `setup.magnetize` recipe is useful if you don't know the magnetic configuration\n  of the material you are currently investigation. It sets up non-magnetic (nm), magnetic (fm)\n  and anti-ferro magnetic (afm, only for exactly two magnetic atoms in the unit cell) \n  configurations of the inital magnetic moments of the structure in new subfolders `nm/` `fm/`\n  and `afm`, respectively. For another example of using the magnetize recipe see the \n  \"Advanced Example: Make a screening study\" section. For more information see \n  `asr help setup.magnetize`\n* The `setup.decorate` recipe is useful if you want to create new atomic that are similar\n  to an existing atomic structure. The decorate recipe contains a table describing the\n  likelyhood of two atoms to be substituted. By default the decorate recipe creates a\n  new ASE database with the decorated atomic structure (including itself). For more \n  information see `asr help setup.decorate`.\n* The `setup.unpackdatabase` recipe is useful if you have a database of materials that you wish\n  to conduct some calculations on. By default, running `asr run setup.unpackdatabase` creates a new\n  folder `tree/` in the current directory with all mateirals distributed according to the \n  following folder structure `tree/{stoi}/{spg}/{formula:metal}-{stoi}-{spg}-{wyck}-{uid}` \n  where `stoi` is the stoichiometry, `spg` is the space group number, `wyck` are the alphabetically\n  sorted unique Wyckoff positions of the materials, `formula:metal` is the chemical formula \n  sorted after metal atoms first and `uid` is a unique identifier to avoid collisions between\n  materials that would otherwise end up in the same folder. For another example of using the \n  unpackdatabase recipe see the \"Advanced Example: Make a screening study\" section. For more\n  information see `asr help setup.unpackdatabase`.\n* The `setup.params` recipe is useful as it makes a `params.json` file containing the default\n  parameters of all recipes. This makes it possible to modify the input parameters used by each\n  recipe. See the \"Change default settings in scripts\" section for more information on \n  how this works.\n* The `setup.scanparams` recipe is useful if you want to conduct a convergence study\n  of a given recipe. As argument it takes a number of different values for the input arguments\n  to a recipe and generates a series of folders that contain a `params.json` file with a specific\n  combination of those parameters. When you are done with you calculations you can collect\n  the data in the folders and plot them in the browser.\n\nChange default settings in scripts\n----------------------------------\nAll material folders can contain a `params.json`-file. This file can\nchanged to overwrite default settings in scripts. For example:\n\n```javascript\n{\n    \"asr.gs\": {\"gpw\": \"otherfile.gpw\",\n               \"ecut\": 800},\n    \"asr.relax\": {\"states\": [\"nm\", ]}\n}\n```\n\nIn this way all default parameters exposed through the CLI of a recipe\ncan be corrected.\n\nSubmit a recipe to a computer-cluster\n-------------------------------------\nIt is also recommended to use these recipes together with the `myqueue`\njob managing package. We assume that you have installed the `myqueue`-package\nand are familiar with its usage. If you are not, then take a look at its excellent\ndocumentation. To submit a job that relaxes a structure simply do\n\n```console\n$ mq submit asr.relax@24:10h\n```\n\nAdvanced Example: Make a screening study\n----------------------------------------\nA screening study what we call a simultaneous automatic study of many materials. ASR\nhas a set of tools to make such studies easy to handle. Suppose we have an ASE\ndatabase that contain many atomic structures. In this case we take OQMD12 database\nthat contain all unary and binary compounds on the convex hull.\n\nThe first thing we do is to get the database:\n```console\n$ mkdir ~/oqmd12 && cd ~/oqmd12\n$ wget https://cmr.fysik.dtu.dk/_downloads/oqmd12.db\n```\nWe then use the `unpackdatabase` function of ASR to unpack the database into a\ndirectory tree\n```console\n$ asr run setup.unpackdatabase oqmd12.db -s u=False --run\n```\n(we have made the selection `u=False` since we are not interested in the DFT+U values).\nThis function produces a new folder `~oqmd12/tree/` where you can find the tree. \nTo see the contents of the tree it is recommended to use the linux command `tree`\n```console\n$ tree tree/\n```\nYou will see that the unpacking of the database has produced many `unrelaxed.json`\nfiles that contain the unrelaxed atomic structures. Because we don't know the\nmagnetic structure of the materials we also want to sample different magnetic structOBures.\nThis can be done with the `magnetize` function of asr\n```console\n$ asr run setup.magnetize in */*/*/*/\n```\nWe use the `run` function because that gives us the option to deal with many folders\nat once. You are now ready to run a\nworkflow on the entire tree. ASR has a `workflow` function that let's us build\nworkflows based on the recipes in ASR. This function is meant as an help to\nstart on new recipes. Familiarize yourself with the function by\nrunning `asr workflow -h`. The help shows that it is possible to create a\nworkflow by\n```console\n$ asr workflow -t asr.relax,asr.bandstructure,asr.convex_hull --doforstable asr.bandstructure > workflow.py\n$ cat worflow.py\nfrom myqueue.task import task\n\n\ndef is_stable():\n    # Example of function that looks at the heat of formation\n    # and returns True if the material is stable\n    from asr.utils import read_json\n    from pathlib import Path\n    fname = 'results_convex_hull.json'\n    if not Path(fname).is_file():\n        return False\n\n    data = read_json(fname)\n    if data['hform'] < 0.05:\n        return True\n    return False\n\n\ndef create_tasks():\n    tasks = []\n    tasks += [task('asr.relax@8:xeon8:10h')]\n    tasks += [task('asr.structureinfo@1:10m')]\n    tasks += [task('asr.gs@8:10h', deps='asr.structureinfo')]\n    tasks += [task('asr.gaps@1:10m', deps='asr.structureinfo,asr.gs')]\n    tasks += [task('asr.convex_hull@1:10m', deps='asr.structureinfo,asr.gs')]\n    if is_stable():\n        tasks += [task('asr.bandstructure@1:10m', deps='asr.structureinfo,asr.gaps,asr.gs')]\n\n    return tasks\n```\n\nThis workflow relaxes the structures and if the `convex_hull` recipe calculates\nlow heat of formation the workflow will make sure that the bandstructure is\ncalculated. We now ask `myqueue` what jobs it wants to run.\n```console\n$ mq workflow -z workflow.py tree/*/*/*/*/\n```\nTo submit the jobs simply remove the `-z`, and run the command again.\n\nFor complex workflows, like the one above where we have to check the stability of\nmaterials which has to wait until the `convex_hull` recipe has finished, the \n`mq workflow` function should have to be run periodically to check for new tasks.\nIn this case it is smart to set up a crontab to do the work for you. \nTo do this write\n```console\n$ crontab -e\n```\nchoose your editor and put the line \n`*/5 * * * * . ~/.bashrc; cd ~/oqmd12; mq kick; mq workflow workflow.py tree/*/*/*/*/`\ninto the file. This will restart any timeout jobs and run the workflow command \nto see if any new tasks should be spawned with a 5 minute interval. \n\nRecommended Procedures\n=======================\nThe tools of ASR can be combined to perform complicated tasks with little\neffort. Below you will find the recommended procedures to perform common\ntasks within the ASR framework.\n\n\nMake a convergence study\n------------------------\nWhen you have created a new recipe it is highly likely that you would have to\nmake a convergence study of the parameters in your such that you have proof that\nyour choice of parameters are converged. The tools of ASR makes it easier to\nconduct such convergence studies. ASR has a built-in database with materials\nthat could be relevant to investigate in your convergence tests. These materials\ncan be retrieved using the `setup.materials` recipe. See\n`asr help setup.materials` for more information. For example, to convergence\ncheck the parameters of `asr.relax` you can do the following.\n\n```console\n$ mkdir convergence-test && cd convergence-test\n$ asr run setup.materials\n$ asr run setup.unpackdatabase materials.json --tree-structure materials/{formula:metal} --run\n$ cd materials/\n$ asr run setup.scanparams asr.relax:ecut 600 700 800 asr.relax:kptdensity 4 5 6 in */\n$ mq submit asr.relax@24:10h */*/\n```\n\nWhen the calculations are done you can collect all results into a database and\ninspect them:\n```console\n$ cd convergence-test\n$ asr run collect */*/\n$ asr run browser\n```\n\n\nDeveloping new recipes\n======================\nIn the following you will find the necessary information needed to implement new\nrecipes into the ASR framework. The first section gives an ultra short\ndescription of how to implement new recipes, and the following sections go\ninto more detail.\n\nGuide to making new recipes\n---------------------------\n\n- Start by copying the template [template_recipe.py](asr/utils/something.py) \n  into your asr/asr/ directory. The filename of this file is important since\n  this is the name that is used when executing the script. We assume that you\n  script is called `something.py`.\n- Implement your main functionality into the `main` function. This is the \n  function that is called when executing the script directly. Please save your\n  results into a .json file if possible. In the template we save the results to\n  `something.json`.\n- Implement the `collect_data` function which ASR uses to collect the data (in\n  this case it collects the data in `something.json`). It is important that this\n  function returns a dict of key-value pairs `kvp` alongside their\n  `key-descriptions` and any data you want to save in the collected database.\n- Now implement the `webpanel` function which tells ASR how to present the data\n  on the website. This function returns a `panel` and a `things` list. The panel\n  is simply a tuple of the title that goes into the panel title and a list of\n  columns and their contents. This should be clear from studying the example.\n- Finally, implement the additional metadata keys `group` (see below for \n  possible groups), `creates` which tells ASR what files are created and\n  `dependencies` which should be a list of ASR recipes (e. g. ['asr.gs']).\n\nWhen you have implemented your first draft of your recipe make sure to test it.\nSee the section below for more information.\n\nThe ASRCommand decorator\n------------------------\nAs you will have seen in the template recipe [template_recipe.py](asr/utils/something.py)\nall main functions in ASR are decorated using a special `command` decorator that ASR \nprovides. In practice, the `command` decorator basically instantiates a new class\n`ASRCommand()` which essentially is a `click.Command` with extra attributes.\n\nWhen wrapping a command in this decorator the function will automatically:\n\n* Make sure that the returned results of the function\n  are safely stored to a file named `results_RECIPENAME.json`, where `RECIPENAME` is the\n  filename of the recipe like `relax`, `gs` or `borncharges`. This means that you should\n  make sure to return your results using the `return results` statement in python.\n* The results file with additionally also contain the version number of ASR, ASE and GPAW.\n  This is nice since they will be stored together with the actual results.\n* Update the command defaults based on the `params.json` file in the current directory.\n* Execute any missing dependencies if they haven't been run yet.\n  Additionally, the `ASRCommand` will also add a `skip-deps` flag argument if you for some\n  reason don't care about running the dependencies.\n* Store to the the results file in the data key of ASR under the key\n  `data['results_RECIPENAME']`.\n\nThe `command` decorator also support the `known_exceptions` keyword.\nThis keyword is a dictionary of errors (in python lingo: an exception) and some\nmultiplication factors that the parameters should be updated with if the programs\nfails with that excact error. For example, take a look at how this is used in the\n`relax` recipe below:\n```python\nknown_exceptions = {KohnShamConvergenceError: {'kptdensity': 1.5,\n                                               'width': 0.5}}\n@command('asr.relax',\n\t     known_exceptions=known_exceptions)\n```\nIn other words, if the relax recipe encounters a `KohnShamConvergenceError` it execute\nthe recipe again with a 50% larger kpoint density and half the Fermi temperature smearing.\n\nFor some `recipes` it is necessary to use the exact some parameters that some other recipes\nused. This is specifically true for the ground state recipe which need to use the same \nkpoint density and Fermi Temperature as the relax recipe. The command decorator supports \nthe `overwrite_params` keyword which lets you load in other default parameters. In practice,\nthe ground state recipe reads parameters from the `gs_params.json` file (if it exists) which\nis produced by the relax recipe. Below you can see how this works for the ground state recipe:\n\n```python\n# Get some parameters from structure.json\ndefaults = {}\nif Path('gs_params.json').exists():\n    from asr.utils import read_json\n    dct = read_json('gs_params.json')\n    if 'ecut' in dct.get('mode', {}):\n        defaults['ecut'] = dct['mode']['ecut']\n\n    if 'density' in dct.get('kpts', {}):\n        defaults['kptdensity'] = dct['kpts']['density']\n\n\n@command('asr.gs', defaults)\n```\n\n\nSetting a different calculator\n==============================\nThe default DFT calculator of ASR is `GPAW`, however, at the moment some recipes\nsupport using the EMT calculator of ASE, specifically the `relax` and the `gs` recipes.\nThis is mostly meant for testing, however in the future, we might want to support other\ncalculators. To change change the calculator simply add the keyword `_calculator: EMT`\nin you `params.json` file:\n```javascript\n{\n    \"_calculator\": \"EMT\"\n}\n```\nWe use the `_calculator` keyword as opposed to `calculator` because this functionality \nis not meant to be used for anything else than testing at the moment.\n\n\nTesting\n-------\nTests can be run using\n```\nasr test\n```\nWhen you make a new recipe ASR will automatically generate a test thats tests\nits dependencies and itself to make sure that all dependencies have been\nincluded. These automatically generated tests are generated from\n[test_template.py](asr/tests/template.py).\n\nTo execute a single test use \n```\nasr test -k my_test.py\n```\nIf you want more extended testing of your recipe you will have to implement them\nmanually. Your test should be placed in the `asr/asr/tests/`-folder and prefixed\nwith `test_` which is how ASR locates the tests.\n\n\nSpecial recipe metadata keywords\n--------------------------------\nA recipe contains some specific functionality implemented in separate functions:\n[template_recipe.py](asr/utils/something.py). Below you will find a description\nof each special keyword in the recipe.\n\n- `main()` Implement the main functionality of the script. This is where the heavy\n  duty stuff goes.\n- `collect_data()` tells another recipe (`asr.collect`) how pick up data and put\n  it into a database.\n- `webpanel()` tells ASR how to present the data on a webpage.\n- `group` See \"Types of recipes\" section below.\n- `creates` is a list of filenames created by `main()`. The files in this list \n  should be the files that contain the essential data that would be needed\n  later.\n- `resources` is a `myqueue` specific keyword which is a string in the specific\n  format `ncores:timelimit` e. g. `1:10m`. These are the resources that myqueue\n  uses when submitting the jobs to your cluster. This can also be a `callable`\n  in the future but this functionality is not currently well tested.\n- `diskspace` is a `myqueue` specific keyword which is a number in arbitrary \n  units that can be\n  parsed by myqueue to make sure that not too many diskspace intensive jobs are\n  running simultaneously.\n- `restart` is a `myqueue` specific keyword which is an integer that tells\n  myqueue whether it makes sense to restart the job if it timeout or had a\n  memory error and how many times it makes sense to try. If it doesn't make\n  sense then set this number to 0.\n\nTypes of recipes\n----------------\nThe recipes are divided into the following groups:\n\n- Property recipes: Recipes that calculate a property for a given atomic structure.\n  The scripts should use the file in the current folder called `structure.json`.\n  These scripts should only assume the existence of files in the same folder.\n  Example recipes: `asr.gs`, `asr.bandstructure`, `asr.structureinfo`.\n\n- Structure recipes: These are recipes that can produce a new atomic structure in\n  this folder.\n  Example: `asr.relax` takes the atomic structure in `unrelaxed.json`\n  in the current folder and produces a relaxed structure in `structure.json` \n  that the property recipes can use.\n\n- Setup recipes: These recipes are located in the asr.setup folder and the \n  purpose of these recipes is to set up new atomic structures in new folders.\n  Example: `asr.setup.magnetize`, `asr.push`, `asr.setup.unpackdatabase` all\n  takes some sort of input and produces folders with new atomic structures that \n  can be relaxed.\n\n\n\n\n",
        "description_content_type": "text/markdown",
        "docs_url": "https://pythonhosted.org/asr/",
        "download_url": "",
        "downloads": {
            "last_day": -1,
            "last_month": -1,
            "last_week": -1
        },
        "home_page": "https://gitlab.com/mortengjerding/asr",
        "keywords": "",
        "license": "",
        "maintainer": "",
        "maintainer_email": "",
        "name": "asr",
        "package_url": "https://pypi.org/project/asr/",
        "platform": "",
        "project_url": "https://pypi.org/project/asr/",
        "project_urls": {
            "Homepage": "https://gitlab.com/mortengjerding/asr"
        },
        "release_url": "https://pypi.org/project/asr/19.8.20/",
        "requires_dist": [
            "Click",
            "matplotlib",
            "spglib",
            "plotly"
        ],
        "requires_python": "",
        "summary": "Atomic Simulation Recipes",
        "version": "19.8.20"
    },
    "last_serial": 5798480,
    "releases": {
        "19.8.20": [
            {
                "comment_text": "",
                "digests": {
                    "md5": "d55a75e7f8726f435ad8322307efdd07",
                    "sha256": "1ed9c655508784566a9243830a9681d4c2e2259dd01868b1bc80617922f72814"
                },
                "downloads": -1,
                "filename": "asr-19.8.20-py3-none-any.whl",
                "has_sig": false,
                "md5_digest": "d55a75e7f8726f435ad8322307efdd07",
                "packagetype": "bdist_wheel",
                "python_version": "py3",
                "requires_python": null,
                "size": 90290,
                "upload_time": "2019-09-07T18:09:05",
                "url": "https://files.pythonhosted.org/packages/a7/85/39dd739a591511b13e87ecab6680f81936ebb0fb63021bfe109ce2fc3390/asr-19.8.20-py3-none-any.whl"
            },
            {
                "comment_text": "",
                "digests": {
                    "md5": "eaf14d454d7c475682c41244a2d1f60b",
                    "sha256": "7d826020b3f69c3dc3be07f6f25733d77d6e9eafdf1abf5bfb371d2260d28d62"
                },
                "downloads": -1,
                "filename": "asr-19.8.20.tar.gz",
                "has_sig": false,
                "md5_digest": "eaf14d454d7c475682c41244a2d1f60b",
                "packagetype": "sdist",
                "python_version": "source",
                "requires_python": null,
                "size": 83642,
                "upload_time": "2019-09-07T18:09:08",
                "url": "https://files.pythonhosted.org/packages/c4/05/97d2d087fe4bc374f48e067af8f7da41a25bac9fe45a26bf309acdb8f102/asr-19.8.20.tar.gz"
            }
        ]
    },
    "urls": [
        {
            "comment_text": "",
            "digests": {
                "md5": "d55a75e7f8726f435ad8322307efdd07",
                "sha256": "1ed9c655508784566a9243830a9681d4c2e2259dd01868b1bc80617922f72814"
            },
            "downloads": -1,
            "filename": "asr-19.8.20-py3-none-any.whl",
            "has_sig": false,
            "md5_digest": "d55a75e7f8726f435ad8322307efdd07",
            "packagetype": "bdist_wheel",
            "python_version": "py3",
            "requires_python": null,
            "size": 90290,
            "upload_time": "2019-09-07T18:09:05",
            "url": "https://files.pythonhosted.org/packages/a7/85/39dd739a591511b13e87ecab6680f81936ebb0fb63021bfe109ce2fc3390/asr-19.8.20-py3-none-any.whl"
        },
        {
            "comment_text": "",
            "digests": {
                "md5": "eaf14d454d7c475682c41244a2d1f60b",
                "sha256": "7d826020b3f69c3dc3be07f6f25733d77d6e9eafdf1abf5bfb371d2260d28d62"
            },
            "downloads": -1,
            "filename": "asr-19.8.20.tar.gz",
            "has_sig": false,
            "md5_digest": "eaf14d454d7c475682c41244a2d1f60b",
            "packagetype": "sdist",
            "python_version": "source",
            "requires_python": null,
            "size": 83642,
            "upload_time": "2019-09-07T18:09:08",
            "url": "https://files.pythonhosted.org/packages/c4/05/97d2d087fe4bc374f48e067af8f7da41a25bac9fe45a26bf309acdb8f102/asr-19.8.20.tar.gz"
        }
    ]
}