atomate.utils package — atomate 0.9.2 documentation

# atomate.utils package

## Subpackages

- atomate.utils.tests package
  - Submodules
  - atomate.utils.tests.test_loaders module
  - atomate.utils.tests.test_utils module
  - Module contents

## Submodules

## atomate.utils.database module

class `atomate.utils.database.` `CalcDb`(host, port, database, collection, user, password, **kwargs)

  Bases: `object`

  `__init__`(host, port, database, collection, user, password, **kwargs)

    Initialize self. See help(type(self)) for accurate signature.

  abstract `build_indexes`(indexes=None, background=True)

    Build the indexes.

    Args:

      indexes (list): list of single field indexes to be built. background (bool): Run in the background or not.

  classmethod `from_db_file`(db_file, admin=True)

    Create MMDB from database file. File requires host, port, database, collection, and optionally admin_user/readonly_user and admin_password/readonly_password

    Args:

      db_file (str): path to the file containing the credentials admin (bool): whether to use the admin user

    Returns:

      MMDb object

  `insert`(d, update_duplicates=True)

    Insert the task document ot the database collection.

    Args:

      d (dict): task document update_duplicates (bool): whether to update the duplicates

  abstract `reset`()

## atomate.utils.fileio module

class `atomate.utils.fileio.` `FileClient`(filesystem=None, private_key='~/.ssh/id_rsa')

  Bases: `object`

  A client for performing many file operations while being agnostic of whether those operations are happening locally or via SSH

  `__init__`(filesystem=None, private_key='~/.ssh/id_rsa')
    Args:
      filesystem (str): remote filesystem, e.g. username@remote_host.

        If None, use local

      private_key (str): path to the private key file (for remote

        connections only). Note: passwordless ssh login must be setup

  `abspath`(path)

    return the absolute path

    Args:

      path (str): path to get absolute string of

  `copy`(src, dest)

    Copy from source to destination.

    Args:

      src (str): source full path dest (str): destination file full path

  static `exists`(sftp, path)

    os.path.exists() for paramiko’s SCP object

    Args:

      sftp (SFTPClient): path (str): path to check existence of

  static `get_ssh_connection`(username, host, private_key)

    Connect to the remote host via paramiko using the private key. If the host key is not present it will be added automatically.

    Args:

      username (str): host (str):

      private_key (str): path to private key file

    Returns:

      SSHClient

  `glob`(path)

    return the glob

    Args:

      path (str): path to glob

  `listdir`(ldir)

    Get the directory listing from either the local or remote filesystem.

    Args:

      ldir (str): full path to the directory

    Returns:

      iterator of filenames

## atomate.utils.testing module

class `atomate.utils.testing.` `AtomateTest`(methodName='runTest')

  Bases: `unittest.case.TestCase`

  `get_task_collection`(coll_name=None)

    Returns pymongo collection

  `get_task_database`()

    Returns pymongo db connection.

  `setUp`(lpad=True)

    Create scratch directory(removes the old one if there is one) and change to it. Also initialize launchpad.

  `tearDown`()

    Remove the scratch directory and teardown the test db.

## atomate.utils.utils module

`atomate.utils.utils.` `env_chk`(val, fw_spec, strict=True, default=None)

  env_chk() is a way to set different values for a property depending on the worker machine. For example, you might have slightly different executable names or scratch directories on different machines.

  env_chk() works using the principles of the FWorker env in FireWorks.

  This helper method translates string “val” that looks like this: “>>ENV_KEY<<” to the contents of: fw_spec[“_fw_env”][ENV_KEY]

  Otherwise, the string “val” is interpreted literally and passed-through as is.

  The fw_spec[“_fw_env”] is in turn set by the FWorker. For more details, see: https://materialsproject.github.io/fireworks/worker_tutorial.html

  Since the fw_env can be set differently for each FireWorker, one can use this method to translate a single “val” into multiple possibilities, thus achieving different behavior on different machines.

  Args:

    val: any value, with “>><<” notation reserved for special env lookup values fw_spec: (dict) fw_spec where one can find the _fw_env keys strict (bool): if True, errors if env format (>><<) specified but cannot be found in fw_spec default: if val is None or env cannot be found in non-strict mode,

    > return default

`atomate.utils.utils.` `get_a_unique_id`()

`atomate.utils.utils.` `get_database`(config_file=None, settings=None, admin=False, **kwargs)

`atomate.utils.utils.` `get_fws_and_tasks`(workflow, fw_name_constraint=None, task_name_constraint=None)

  Helper method: given a workflow, returns back the fw_ids and task_ids that match name constraints. Used in developing multiple powerups.

  Args:

    workflow (Workflow): Workflow fw_name_constraint (str): a constraint on the FW name task_name_constraint (str): a constraint on the task name

  Returns:

    a list of tuples of the form (fw_id, task_id) of the RunVasp-type tasks

`atomate.utils.utils.` `get_logger`(name, level=10, log_format='%(asctime)s %(levelname)s %(name)s %(message)s', stream=<_io.TextIOWrapper name='<stdout>' mode='w' encoding='UTF-8'>)

`atomate.utils.utils.` `get_meta_from_structure`(structure)

`atomate.utils.utils.` `get_mongolike`(d, key)

  Retrieve a dict value using dot-notation like “a.b.c” from dict {“a”:{“b”:{“c”: 3}}} Args:

  > d (dict): the dictionary to search key (str): the key we want to retrieve with dot notation, e.g., “a.b.c”

  Returns:

    value from desired dict (whatever is stored at the desired key)

`atomate.utils.utils.` `get_uri`(dir_name)

  Returns the URI path for a directory. This allows files hosted on different file servers to have distinct locations. Args:

  > dir_name:

  >   A directory name.

  Returns:

    Full URI path, e.g., fileserver.host.com:/full/path/of/dir_name.

`atomate.utils.utils.` `get_wf_from_spec_dict`(structure, wfspec, common_param_updates=None)

  Load a WF from a structure and a spec dict. This allows simple custom workflows to be constructed quickly via a YAML file.

  Args:

    structure (Structure): An input structure object. wfspec (dict): A dict specifying workflow. A sample of the dict in

    > YAML format for the usual MP workflow is given as follows:

    > ``` fireworks: - fw: atomate.vasp.fireworks.core.OptimizeFW - fw: atomate.vasp.fireworks.core.StaticFW

    > > params:

    > >   parents: 0

    > - fw: atomate.vasp.fireworks.core.NonSCFUniformFW params:

    >   > parents: 1

    > - fw: atomate.vasp.fireworks.core.NonSCFLineFW params:

    >   > parents: 1

    > common_params:

    >   db_file: db.json $vasp_cmd: $HOME/opt/vasp

    > name: bandstructure metadata:

    > > tag: testing_workflow

    > ```

    > The fireworks key is a list of Fireworks; it is expected that all such Fireworks have “structure” as the first argument and other optional arguments following that. Each Firework is specified via “fw”: <explicit path>.

    > You can pass arguments into the constructor using the special keyword params, which is a dict. Any param starting with a $ will be expanded using environment variables.If multiple fireworks share the same params, you can use common_params to specify a common set of arguments that are passed to all fireworks. Local params take precedent over global params.

    > Another special keyword is parents, which provides the indices of the parents of that particular Firework in the list. This allows you to link the Fireworks into a logical workflow.

    > Finally, name is used to set the Workflow name (structure formula + name) which can be helpful in record keeping.

    common_param_updates (dict): A dict specifying any user-specified updates to common_params

  Returns:

    Workflow

`atomate.utils.utils.` `load_class`(modulepath, classname)

  Load and return the class from the given module.

  Args:

    modulepath (str): dotted path to the module. eg: “pymatgen.io.vasp.sets” classname (str): name of the class to be loaded.

  Returns:

    class

`atomate.utils.utils.` `recursive_get_result`(d, result)

  Function that gets designated keys or values of d (i. e. those that start with “d>>” or “a>>”) from the corresponding entry in result_dict, similar to FireWorks recursive_deserialize.

  Note that the plain “>>” notation will get a key from the result.as_dict() object and may use MongoDB dot notation, while “a>>” will get an attribute of the object.

  Examples:

  Getting a dict key from a VaspRun instance:

    recursive_get_result({“stress”:”>>output.ionic_steps.-1.stress”}, vasprun) –> {“stress”:[[0.2, 0, 0], [0, 0.3, 0], [0, 0, 0.3]]}

  Getting an attribute from a vasprun:

    recursive_get_result({“epsilon”:”a>>epsilon_static”, vasprun} –> {“epsilon”:-3.4}

`atomate.utils.utils.` `recursive_update`(d, u)

  Recursive updates d with values from u Args:

  > d (dict): dict to update u (dict): updates to propogate

## Module contents