put the type hints in the wrong spot for sphinx

Author: ajs99778

atoms.py

@@ -75,20 +75,20 @@ def get(cls, a1, a2):
 class Atom:
     """
     Attributes:
-        
-        * element         str
-        * coords          np.array(float)
-        * flag            bool            true if frozen, false if relaxed
-        * name            str             form of \d+(\.\d+)*
-        * tags            set
-        * charge          float
-        * connected       set(Atom)
-        * constraint      set(Atom)       for determining constrained bonds
-        * _rank
-        * _radii          float           for calculating if bonded
-        * _connectivity   int             max connections without hypervalence
-        * _saturation     int             max connections without hypervalence or charges
-        
+
+    * element         str
+    * coords          np.array(float)
+    * flag            bool            true if frozen, false if relaxed
+    * name            str             form of \d+(\.\d+)*
+    * tags            set
+    * charge          float
+    * connected       set(Atom)
+    * constraint      set(Atom)       for determining constrained bonds
+    * _rank
+    * _radii          float           for calculating if bonded
+    * _connectivity   int             max connections without hypervalence
+    * _saturation     int             max connections without hypervalence or charges
+
     """
 
     LOG = None
@@ -99,13 +99,13 @@ def __init__(
         self, element="", coords=None, flag=False, name="", tags=None, charge=None, mass=None
     ):
         """
-        :param element str: element symbol
-        :param coords np.ndarray: position
-        :param flag: whether atom is frozen
-        :param name str: name of atom
-        :param tags list: misc. data
-        :param charge float: partial charge of atom
-        :param mass float: mass of atom
+        :param str element: element symbol
+        :param np.ndarray coords: position
+        :param bool flag: whether atom is frozen
+        :param str name: atom name
+        :param list tags: misc. data
+        :param float charge: partial charge of atom
+        :param float mass: mass of atom
         """
 
         super().__setattr__("_hashed", False)
@@ -316,12 +316,12 @@ def get_invariant(self):
         """
         gets initial invariant, which is formulated using:
         
-        # number of non-hydrogen connections (\d{1}): nconn
-        # sum of bond order of non-hydrogen bonds * 10 (\d{2}): nB
-        # atomic number (\d{3}): z
-        # sign of charge (\d{1}) (not used)
-        # absolute charge (\d{1}) (not used)
-        # number of attached hydrogens (\d{1}): nH
+        #. number of non-hydrogen connections (\d{1}): nconn
+        #. sum of bond order of non-hydrogen bonds * 10 (\d{2}): nB
+        #. atomic number (\d{3}): z
+        #. sign of charge (\d{1}) (not used)
+        #. absolute charge (\d{1}) (not used)
+        #. number of attached hydrogens (\d{1}): nH
         """
         heavy = set([x for x in self.connected if x.element != "H"])
         # number of non-hydrogen connections:
@@ -1009,9 +1009,9 @@ def new_shape(old_shape, new_connectivity, bond_change):
         returns the name of the expected vsepr geometry when the number of bonds
         changes by +/- 1
 
-        :param old_shape str: vsepr geometry name
-        :param new_connectivity int: connectivity (see Atom._connectivity)
-        :param bond_change int: +1 or -1, indicating that the number of bonds is changing by 1
+        :param str old_shape: vsepr geometry name
+        :param int new_connectivity: connectivity (see Atom._connectivity)
+        :param int bond_change: +1 or -1, indicating that the number of bonds is changing by 1
         
         """
         if old_shape == "point":

geometry.py

@@ -19,10 +19,10 @@
 * PSI4_COMMENT: list(str)
 * PSI4_MOLECULE: dict(str:list(str)) e.g. {'symmetry': ['c1']}
 * PSI4_COORDINATES: dict() with keys:
-    'coords' - array of coordinates with one item for each atom
-    'variables' - list of name (str), value (float), is_angstrom (bool) tuples
-    this is ignored if using a SAPTMethod with a low-spin combination
-    of monomers
+  'coords' - array of coordinates with one item for each atom
+  'variables' - list of name (str), value (float), is_angstrom (bool) tuples
+  this is ignored if using a SAPTMethod with a low-spin combination
+  of monomers
 * PSI4_JOB: dict(optimize/frequencies/etc: list(str $METHOD replaced w/ method))
 * PSI4_OPTKING: dict(setting_name: [value])
 
@@ -53,7 +53,7 @@
 
 * XTB_CONTROL_BLOCKS: dict - stuff in xcontrol file
 * XTB_COMMAND_LINE: dict(str:list) - command line stuff, values should be 
-    emtpy lists if the command line flag (key) has no arguments
+  emtpy lists if the command line flag (key) has no arguments
 
 :CREST:
 

theory/__init__.py

@@ -36,15 +36,16 @@ class Basis:
     * elements      - same as initialization keyword
     * aux_type      - same as initialization keyword
     * elements      - list of element symbols for elements this basis applies to
-        updated with Basis.refresh_elements
-        Basis.refresh_elements is called when writing an input file
+      updated with Basis.refresh_elements
+      
+      Basis.refresh_elements is called when writing an input file
     * ele_selection - list of finders used to determine which elements this basis applies to
     * not_anys      - list of finders used to determine which elements this basis does not apply to
     * ONIOM-only attributes:
     * oniom_layer   - same as initialization keyword
     * atom_selection - list of finders used to determine which atoms this basis applies to
     * atoms         - list of atoms this basis applies to
-        updated with Bases.refresh_atoms
+      updated with Bases.refresh_atoms
     * default_notany_atoms - finder for atoms that are not in the given layer
     """
 
@@ -54,23 +55,23 @@ class Basis:
 
     def __init__(self, name, elements=None, aux_type=None, user_defined=False, oniom_layer=None, atoms=None):
         """
-        :param name str: basis set base name (e.g. 6-31G)
-        :param elements list(str): list of element symbols or finders to determine the basis set applies to
+        :param str name: basis set base name (e.g. 6-31G)
+        :param list(str) elements: list of element symbols or finders to determine the basis set applies to
             elements may also be 'tm' or 'all' to indicate any transition metal and
             all elements, respectively
             elements may start with '!' to exclude that element from the basis
             for example, elements='!H' will apply to default elements, minus H
-        :param aux_type str|None:
+        :param str|None aux_type:
             
             * ORCA: one of BasisSet.ORCA_AUX
             * Psi4: one of BasisSet.PSI4_AUX
-        :param user_defined str|bool: path to file containing basis info from basissetexchange.org
+        :param str|bool user_defined: path to file containing basis info from basissetexchange.org
             or similar
             False for builtin basis sets
 
         ONIOM-only:
         
-        :param oniom_layer str|None: must be 'H', 'M', or 'L' if not None
+        :param str|None oniom_layer: must be 'H', 'M', or 'L' if not None
         :param atoms: list of finders or 'tm' to determine what atoms the basis set applies to
         """
         self.name = name
@@ -266,8 +267,8 @@ def sanity_check_basis(name, program):
         checks the basis set name against a list of basis sets
         that are built-in to the specified program
         
-        :param name str: keyword of basis set (e.g. def2SVP)
-        :param program str: program name (gaussian, psi4, etc.)
+        :param str name: keyword of basis set (e.g. def2SVP)
+        :param str program: program name (gaussian, psi4, etc.)
         """
         import os.path
         from difflib import SequenceMatcher as seqmatch
@@ -1262,7 +1263,7 @@ def get_orca_basis_info(self):
 
     def get_psi4_basis_info(self, sapt=False):
         """
-        :param sapt bool: use df_basis_sapt instead of df_basis_scf for jk basis
+        :param bool sapt: use df_basis_sapt instead of df_basis_scf for jk basis
         
         :returns: dict for get_psi4_header
         """

theory/basis.py

@@ -19,7 +19,7 @@ class IntegrationGrid:
 
     def __init__(self, name):
         """
-        :param name str: Gaussian keyword (e.g. SuperFineGrid),
+        :param str name: Gaussian keyword (e.g. SuperFineGrid),
             ORCA keyword (e.g. Grid7),
             or "(radial, angular)"
         

theory/grid.py

@@ -526,8 +526,8 @@ class ImplicitSolvent:
 
     def __init__(self, solvent_model, solvent):
         """
-        :param solvent_model str: implicit solvent model (e.g. PCM)
-        :param solvent str: solvent name (e.g. water)
+        :param str solvent_model: implicit solvent model (e.g. PCM)
+        :param str solvent: solvent name (e.g. water)
         """
         self.solvent_model = solvent_model
         self.solvent = solvent

theory/implicit_solvent.py

@@ -29,18 +29,23 @@ def job_from_string(name, **kwargs):
     """
     get a job name given a simple name
     
-    :param name str:
+    :param str name:
     
         * "opt" or "conf" with ".ts", ".transition_state", ".change", and ".con" extensions
+
             * .ts and .transition_state indicate a transition state optimization
             * .con indicates a constrained optimization - "constraints" should
-                be in kwargs and the value should be a dictionary conformable with 
-                the keyword of OptimizationJob
+              be in kwargs and the value should be a dictionary conformable with 
+              the keyword of OptimizationJob
+        
         * "freq" with ".num" extensions
+        
             * .num indicates a numerical frequnecy, as does kwargs["numerical"] = True
-                kwargs can also have a "temperature" key
+              kwargs can also have a "temperature" key
+        
         * "sp" or "energy" or "single-point"
         * "force" or "gradient" with a ".num" extension
+        
             * .num indicates a numerical frequnecy, as does kwargs["numerical"] = True
 
     :returns: job types for the given string
@@ -149,11 +154,11 @@ def resolve_error(error, theory, exec_type, geometry=None):
         raises NotImplementedError if this job type has no fix for
         the error code
         
-        :param error str: error code (e.g. SCF_CONV; see fileIO ERROR)
-        :param theory Theory: Theory instance used when the error happened
-        :param exec_type str: software program (i.e. gaussian, orca, etc.)
+        :param str error: error code (e.g. SCF_CONV; see fileIO ERROR)
+        :param Theory theory: Theory instance used when the error happened
+        :param str exec_type: software program (i.e. gaussian, orca, etc.)
         
-        :param geometry Geometry: (optional) structure might be adjusted slightly if
+        :param Geometry geometry: (optional) structure might be adjusted slightly if
             there are close contacts
         """
 
@@ -247,37 +252,34 @@ def __init__(
         geometry=None,
     ):
         """
-        :param transition_state bool: request a transition state optimization
-        :param constraints dict: keys are
+        :param bool transition_state: request a transition state optimization
+        :param dict constraints: keys are
         
             **available for ORCA, Gaussian, and Psi4**
             
             * 'atoms' - atom identifiers/finders - atoms to constrain
-            * 'bonds' - list(atom idenifiers/finders) - distances to constrain
-                each atom identifier in the list should result in exactly 2 atoms
-            * 'angles' - list(atom idenifiers/finders) - 1-3 angles to constrain
-                each atom identifier should result in exactly 3 atoms
-            * 'torsions' - list(atom identifiers/finders) - constrained dihedral angles
-                each atom identifier should result in exactly 4 atoms
+            * 'bonds' - list(atom idenifiers/finders) - distances to constrain each atom identifier
+              in the list should result in exactly 2 atoms
+            * 'angles' - list(atom idenifiers/finders) - 1-3 angles to constrain each atom identifier
+              should result in exactly 3 atoms
+            * 'torsions' - list(atom identifiers/finders) - constrained dihedral angles each atom
+              identifier should result in exactly 4 atoms
             
             
             **available for Gaussian and Psi4**
             
-            * 'x' - list(atom identifiers/finders) - constrain the x coordinate of
-                these atoms.
-                Similarly, 'y' and 'z' are also accepted.
+            * 'x' - list(atom identifiers/finders) - constrain the x coordinate of these atoms. Similarly, 'y' and 'z' are also accepted.
             * 'xgroup' - list(tuple(list(atom idenifiers), x_val, hold)) -
-                constrain the x coordinate of these atoms to be the same
+              constrain the x coordinate of these atoms to be the same
                 
                 * x_val - set x-coordinate to this value
-                * hold - hold this value constant during the optimization
-                    if 'hold' is omitted, the value will not be held
-                    constant during the optimization
+                * hold - hold this value constant during the optimization if 'hold' is omitted,
+                  the value will not be held constant during the optimization
                 
-                e.g. 'xgroup':[("1-6", 0, False), ("13-24", 3.25, False)]
+                  e.g. 'xgroup':[("1-6", 0, False), ("13-24", 3.25, False)]
                 
-                this will keep atoms 1-6 and 13-24 in parallel planes, while also
-                allowing those planes to move
+                  this will keep atoms 1-6 and 13-24 in parallel planes, while also
+                  allowing those planes to move
             
             * 'ygroup' and 'zgroup' are also available, with analagous options
     
@@ -286,7 +288,7 @@ def __init__(
             for Gaussian, 'bonds', 'angles', and 'torsions' constraints cannot be mixed
             with 'x', 'y', 'z', 'xgroup', 'ygroup', or 'zgroup' constraints
         
-        :param geometry Geometry: will be set when using an AaronTools FileWriter"""
+        :param Geometry geometry: will be set when using an AaronTools FileWriter"""
         super().__init__()
 
         self.transition_state = transition_state
@@ -1265,18 +1267,17 @@ def __init__(
         geometry=None,
     ):
         """
-        :param constraints dict:
+        :param dict constraints:
+            
             valid keys are:
             
             * 'atoms' - atom identifiers/finders - atoms to constrain
-            * 'bonds' - list(atom idenifiers/finders) - distances to constrain
-                each atom identifier in the list should result in exactly 2 atoms
-            * 'angles' - list(atom idenifiers/finders) - 1-3 angles to constrain
-                each atom identifier should result in exactly 3 atoms
+            * 'bonds' - list(atom idenifiers/finders) - distances to constrain each atom identifier in the list should result in exactly 2 atoms
+            * 'angles' - list(atom idenifiers/finders) - 1-3 angles to constrain each atom identifier should result in exactly 3 atoms
             * 'torsions' - list(atom identifiers/finders) - constrained dihedral angles
                 each atom identifier should result in exactly 4 atoms            
         
-        :param geometry Geometry: will be set when using an AaronTools FileWriter
+        :param Geometry geometry: will be set when using an AaronTools FileWriter
         """
         self.constraints = constraints
         self.geometry = geometry

theory/job_types.py

@@ -31,18 +31,19 @@
 class Method:
     """functional object
     used to ensure the proper keyword is used
+    
     e.g.
     using Functional('PBE0') will use PBE1PBE in a gaussian input file"""
 
     LOG = None
 
     def __init__(self, name, is_semiempirical=False, is_oniom=False, oniom_layer=None, is_mm=False):
         """
-        name: str, functional name
-        is_semiempirical: bool, basis set is not required
-        is_oniom: bool, oniom_layer must be in kwargs, is_mm must be in kwargs
-        oniom_layer: str, oniom layer method describes, must be "H", "M", or "L"
-        is_mm: bool, basis set is not required
+        :param str name: functional name
+        :param bool is_semiempirical: basis set is not required
+        :param bool is_oniom: oniom_layer must be in kwargs, is_mm must be in kwargs
+        :param str oniom_layer: oniom layer method describes, must be "H", "M", or "L"
+        :param bool is_mm: basis set is not required
         """
         self.name = name
         self.is_semiempirical = is_semiempirical
@@ -73,8 +74,9 @@ def __eq__(self, other):
     def sanity_check_method(name, program):
         """
         check to see if method is available in the specified program
-        name - str, name of method
-        program, str, gaussian, orca, psi4, or qchem
+        
+        :param str name: name of method
+        :param str program: program name (gaussian, orca, psi4, or qchem)
         """
         import os.path
         from difflib import SequenceMatcher as seqmatch
@@ -267,8 +269,10 @@ class SAPTMethod(Method):
     """
     method used to differentiate between regular methods and sapt
     methods because the molecule will need to be split into monomers
+    
     if using a sapt method, the geometry given to Theory or Geometry.write
-    should have a 'components' attribute with each monomer being a coordinate
+    should have a 'components' attribute with each monomer being a component
+    
     the charge and multiplicity given to Theory should be a list, with the first
     item in each list being the overall charge/multiplicity and the subsequent items
     being the charge/multiplicity of the monomers (components)