webmo 1.3.2__tar.gz → 1.4.1__tar.gz

{webmo-1.3.2/webmo.egg-info → webmo-1.4.1}/PKG-INFO

@@ -1,9 +1,9 @@
 Metadata-Version: 2.1
 Name: webmo
-Version: 1.3.2
+Version: 1.4.1
 Summary: A Python-based interface to WebMO
 Home-page: https://github.com/jrschmidt2/webmo-python
-Download-URL: https://github.com/jrschmidt2/webmo-python/archive/refs/tags/1.3.2.tar.gz
+Download-URL: https://github.com/jrschmidt2/webmo-python/archive/refs/tags/1.4.1.tar.gz
 Author: J.R. Schmidt
 Author-email: schmidt@webmo.net
 License: MIT
@@ -11,4 +11,5 @@ Keywords: WEBMO,REST,API
 Provides-Extra: spectrum
 Provides-Extra: util
 Provides-Extra: gui
+Provides-Extra: all
 License-File: LICENSE

{webmo-1.3.2 → webmo-1.4.1}/setup.py

@@ -35,6 +35,7 @@ setup(
   extras_require={
       "spectrum": ["numpy"],
       "util": ["PubChemPy"],
-      "gui": ["questionary", "ipywidgets"]
+      "gui": ["questionary", "ipywidgets"],
+      "all": ["numpy", "PubChemPy", "questionary", "ipywidgets"]
   }
 )

{webmo-1.3.2 → webmo-1.4.1}/webmo/__init__.py

@@ -1,2 +1,2 @@
 from .webmo_rest import WebMOREST
-__version__ = "1.3.2"
+__version__ = "1.4.1"

{webmo-1.3.2 → webmo-1.4.1}/webmo/gui.py

@@ -50,6 +50,8 @@ class JupyterGUI(_WebMOGUIBase):
         #fail silently, since this should never happen in Jupyter
         pass #print('ipywidgets not found; disabling support for JupyterGUI')
 
+    import time
+
     def __init__(self, template, query_vars, additional_vars=None):
         """Constructor for JupyterGUI
 
@@ -66,6 +68,7 @@ class JupyterGUI(_WebMOGUIBase):
 
         _WebMOGUIBase.__init__(self, template, query_vars, additional_vars)
         self._widgets = []
+        self._display_time = -1
 
         for var in query_vars:
             if template['variables'][var]['type'] == 'checkbox':
@@ -93,11 +96,20 @@ class JupyterGUI(_WebMOGUIBase):
 
     def display(self):
 
+        self._display_time = self.time.time()
+
         for widget in self._widgets:
             display(widget)
 
     def get_variables(self):
 
+        MIN_INPUT_TIME = 1.0
+        # sanity check to make sure user has had time to input something
+        # fail this call during re-execution of entire notebook at once
+        elapsed_time = self.time.time() - self._display_time
+        if self._display_time == -1 or elapsed_time < MIN_INPUT_TIME:
+            raise RuntimeError('Must provide JupyterGUI input before calling get_variables')
+
         # add in additional user-specified variables
         if (self._additional_vars != None):
             variables = {**self._additional_vars}

{webmo-1.3.2 → webmo-1.4.1}/webmo/spectrum.py

@@ -330,8 +330,10 @@ def voigt_line(center, intensity, width=10, q=0.5, start=0, stop=4000, step=1):
     Returns:
     	(x,y): a tuple of the x and y numpy arrays of the specified line
     """
-    if (not 0 < q < 1):
-        q = 0.5
+    if (q <= 0):
+        return(gauss_line(center, intensity, width, start, stop, step))
+    elif (q >= 1):
+        return(lorentz_line(center,intensity,width,start,stop,step))
 
     x = np.arange(start=start, stop=stop, step=step)
     vfunc = np.vectorize(_arb_voigt(center, intensity, q, width))
@@ -403,7 +405,7 @@ def lorentz_line(center, intensity, width=10, start=0, stop=4000, step=1):
     vfunc = np.vectorize(_arb_lorentz(center, intensity, width))
     return((x,vfunc(x)))
 
-def construct_spectrum(points, intensities, lineshape="gauss", width=10, start=0, stop=4000, step=1):
+def construct_spectrum(points, intensities, lineshape="gauss", frac_loren=0.5, width=10, start=0, stop=4000, step=1):
     """Construct an entire spectrum plot of data
 
     This function returns a pair of numpy arrays that make a spectrum; an x axis
@@ -415,6 +417,7 @@ def construct_spectrum(points, intensities, lineshape="gauss", width=10, start=0
     	intensities([float]): a list of corresponding peak intensities - the order must
     			      match `points`
     	lineshape(string,optional): the desired lineshape. The options are "gauss", "lorentz", and "voigt"
+        frac_loren(float,optional): the fraction lorentzian of the voigt lineshape, if specified
     	width(float,optional): the full width half max of each peak
     	start(float,optional): the starting point of the returned array
     	stop(float,optional): the ending point of the returned array
@@ -428,7 +431,7 @@ def construct_spectrum(points, intensities, lineshape="gauss", width=10, start=0
     linefuncs = {
         "gauss": gauss_line,
         "lorentz": lorentz_line,
-        "voigt": voigt_line
+        "voigt": lambda x, y, **kwargs: voigt_line(x,y,q=frac_loren, **kwargs)
     }
     if (lineshape not in linefuncs.keys()):
         linefunc = gauss_line

webmo-1.4.1/webmo/util.py

@@ -0,0 +1,287 @@
+import numpy as np
+
+def xyz_from_name(name):
+    """Obtains an XYZ-formatted geometry for the molecule name via PubChem lookup.
+
+    Arguments:
+        name(str): The name of the molecule.
+
+    Returns:
+        A string containing the molecule's XYZ-formatted geometry.
+    """
+    import pubchempy as pcp
+
+    results = pcp.get_compounds(name, 'name', record_type='3d')
+    if (len(results) == 0):
+        raise ValueError("Specified molecule could not be found in PubChem")
+
+    record = results[0]
+    geom = ""
+    for atom in record.atoms:
+        element = atom.element
+        x = float(atom.x)
+        y = float(atom.y)
+        z = float(atom.z)
+        geom += f"{element}\t{x:f}\t{y:f}\t{z:f}\n"
+        
+    return geom
+
+def get_energy(results, include_units=False):
+    """Returns the molecular energy from the job results. This should correspond to the ground state energy
+    at molecule at the requested level of theory.
+
+    Requires WebMO 25 or higher.
+
+    Arguments:
+        dict(results): A dictionary of job results, obtained from get_job_results.
+        bool(include_units): Whether to include the units with the returned energy (e.g. 1.5 vs. "1.5 Hartree")
+
+    Returns:
+        The molecular energy.
+    """
+    properties = results['properties']
+
+    if not 'method_energy_name' in properties.keys():
+        raise RuntimeError('Cannot locate "method_energy_name" in results')
+    method_energy_name = properties['method_energy_name'].lower().replace(' ', '_') + '_energy'
+
+    found = False
+    #also check related key names, since Gaussian prepends some things occasionally
+    for key in [method_energy_name, 'r' + method_energy_name, 'u' + method_energy_name, 'ro' + method_energy_name]:
+        if key in properties:
+            energy = properties[key]['value']
+            units = properties[key]['units']
+            found = True
+
+    if not found:
+        raise RuntimeError('Could not locate "' + method_energy_name + '" in results')
+
+    if include_units:
+        energy = f"{energy} {units}"
+
+    return energy
+
+def get_energies(results, include_units=False):
+    """Returns a dictionary of available energies from the job results.
+
+    Arguments:
+        dict(results): A dictionary of job results, obtained from get_job_results.
+        bool(include_units): Whether to include the units with the returned energy (e.g. 1.5 vs. "1.5 Hartree")
+
+    Returns:
+        A dictionary of available energies.
+    """
+    properties = results['properties']
+    energies = {}
+
+    for key in properties.keys():
+        index = key.find('_energy')
+
+        if key.endswith('_energy'):
+            index = key.find('_energy')
+            energy_type = key[:index]
+
+            if include_units:
+                energies[energy_type] = f"{properties[key]['value']} {properties[key]['units']}"
+            else:
+                energies[energy_type] = properties[key]['value']
+
+    return energies
+
+def get_geometry(results):
+    """Returns the XYZ-formatted final geometry from the job results.
+
+    Arguments:
+        dict(results): A dictionary of job results, obtained from get_job_results.
+
+    Returns:
+        The XYZ-formatted final geometry as a string.
+    """
+
+
+    geom = ""
+    index = 0
+    for element in results['symbols']:
+
+        x = results['geometry'][index]
+        y = results['geometry'][index + 1]
+        z = results['geometry'][index + 2]
+
+        geom += f"{element}\t{x:f}\t{y:f}\t{z:f}\n"
+        index += 3
+
+    return geom
+
+def get_stoichiometry(results):
+    """Returns the stoichiometry from the job results.
+
+    Arguments:
+        dict(results): A dictionary of job results, obtained from get_job_results.
+
+    Returns:
+        The stoichiometry as a string.
+    """
+
+    properties = results['properties']
+    return properties['stoichiometry']
+
+def get_dipole_moment(results):
+    """Returns the dipole moment from the job results.
+
+    Arguments:
+        dict(results): A dictionary of job results, obtained from get_job_results.
+
+    Returns:
+        The magnitude of the dipole moment.
+    """
+
+    from math import sqrt
+
+    properties = results['properties']
+    dipole = properties['dipole_moment']
+    mag = sqrt(dipole[0]**2 + dipole[1]**2 + dipole[2]**2)
+
+    return mag
+
+def get_property(results, property_name):
+    """Returns an arbitrary calculated property from the job results.
+
+    Arguments:
+        dict(results): A dictionary of job results, obtained from get_job_results.
+        str(property_name): The name of the desired property
+
+    Returns:
+        The value of the calculated property (scalar or dictionary).
+    """
+
+    properties = results['properties']
+    return properties[property_name]
+
+
+def get_bond_length(results, index1, index2):
+    """Returns the specified bond length between two atoms from the job results OR an xyz-formatted string.
+
+    Arguments:
+        dict(results): A dictionary of job results obtained from get_job_results OR an xyz-formatted string.
+        index1(int): The one-based index of the first atom of the bonded pair
+        index2(int): The one-based index of the second atom of the bonded pair
+
+    Returns:
+        The calculated bond length.
+    """
+
+    if not isinstance(results, dict):
+        geom = _xyz_to_array(results)
+    else:
+        geom = results['geometry']
+
+    #convert to 0 index
+    index1 -= 1
+    index2 -= 1
+
+    atom1 = np.array(geom[index1*3:index1*3 + 3])
+    atom2 = np.array(geom[index2*3:index2*3 + 3])
+
+    return np.linalg.norm(atom1 - atom2)
+
+def get_bond_angle(results, index1, index2, index3):
+    """Returns the specified bond angle between three atoms from the job results OR an xyz-formatted string.
+
+    Arguments:
+        dict(results): A dictionary of job results obtained from get_job_results OR an xyz-formatted string.
+        index1(int): The one-based index of the first atom
+        index2(int): The one-based index of the second atom
+        index3(int): The one-based index of the third atom
+
+    Returns:
+        The calculated bond angle.
+    """
+
+    if not isinstance(results, dict):
+        geom = _xyz_to_array(results)
+    else:
+        geom = results['geometry']
+
+    #convert to 0 index
+    index1 -= 1
+    index2 -= 1
+    index3 -= 1
+
+    atom1 = np.array(geom[index1*3:index1*3 + 3])
+    atom2 = np.array(geom[index2*3:index2*3 + 3])
+    atom3 = np.array(geom[index3*3:index3*3 + 3])
+
+    vec1 = atom1 - atom2
+    vec2 = atom3 - atom2
+
+    vec1 /= np.linalg.norm(vec1)
+    vec2 /= np.linalg.norm(vec2)
+
+    return np.arccos(np.dot(vec1,vec2))*180./np.pi
+
+def get_dihedral_angle(results, index1, index2, index3, index4):
+    """Returns the specified dihedral angle between four atoms from the job results OR an xyz-formatted string.
+
+    Arguments:
+        dict(results): A dictionary of job results obtained from get_job_results OR an xyz-formatted string.
+        index1(int): The one-based index of the first atom
+        index2(int): The one-based index of the second atom
+        index3(int): The one-based index of the third atom
+        index4(int): The one-based index of the fourth atom
+
+    Returns:
+        The calculated dihedral angle.
+    """
+
+    if not isinstance(results, dict):
+        geom = _xyz_to_array(results)
+    else:
+        geom = results['geometry']
+
+    #convert to 0 index
+    index1 -= 1
+    index2 -= 1
+    index3 -= 1
+    index4 -= 1
+
+    atom1 = np.array(geom[index1*3:index1*3 + 3])
+    atom2 = np.array(geom[index2*3:index2*3 + 3])
+    atom3 = np.array(geom[index3*3:index3*3 + 3])
+    atom4 = np.array(geom[index4*3:index4*3 + 3])
+
+    b1 = atom1 - atom2
+    b2 = atom2 - atom3
+    b3 = atom3 - atom4
+
+    b1 /= np.linalg.norm(b1)
+    b2 /= np.linalg.norm(b2)
+    b3 /= np.linalg.norm(b3)
+
+    n1 = np.cross(b1, b2)
+    n2 = np.cross(b2, b3)
+    m = np.cross(n1, b2)
+
+    x = np.dot(n1, n2)
+    y = np.dot(m, n2)
+
+    return np.arctan2(y, x)*180./np.pi
+
+def _xyz_to_array(xyz):
+    xyz = xyz.strip()
+
+    try:
+        #throw exception if NOT a number, indicating that our XYZ file has no header
+        tokens = xyz.split()
+        int(tokens[0])
+        #this XYZ formatted string is proper, containing a header that must be removed
+        xyz = xyz.split("\n",2)[2]
+    except ValueError:
+        pass
+
+    #process the actual geometry of the XYZ file, converting into an array
+    geom = xyz.split()
+    #remove the element names, leaving only an array of positions
+    del geom[0::4]
+
+    #convert to an array of floats and return
+    return np.array(geom,dtype=float)

{webmo-1.3.2 → webmo-1.4.1}/webmo/webmo_rest.py

@@ -16,7 +16,7 @@ class WebMOREST:
     creation/destruction.
     """
     
-    def __init__(self, base_url, username, password=""):
+    def __init__(self, base_url, username, password="", expiration=24):
         """Constructor for WebMOREST
         
         This constructor generates a WebMOREST object and also generates and stores a newly
@@ -26,6 +26,7 @@ class WebMOREST:
             base_url(str): The base URL (ending in rest.cgi) of the WeBMO rest endpoint
             username(str): The WebMO username
             password(str, optional): The WebMO password; if omitted, this is supplied interactively
+            expiration(int, optional): The expiration time (in hours) of the REST session token
             
         Returns:
             object: The newly constructed WebMO object
@@ -36,7 +37,7 @@ class WebMOREST:
         if not password:
             password=getpass(prompt="Enter WebMO password for user %s:" % username)
         #obtain a REST token using the specified credentials
-        login={'username' : username, 'password' : password} #WebMO login information, used to retrieve a REST access token
+        login={'username' : username, 'password' : password, 'expiration' : expiration}
         r = requests.post(base_url + '/sessions', data=login)
         r.raise_for_status() #raise an exception if there is a problem with the request
         
@@ -315,7 +316,7 @@ class WebMOREST:
         r = requests.delete(self._base_url + "/jobs/%d" % job_number, params=self._auth)
         r.raise_for_status()
         
-    def import_job(self, job_name, filename, engine):
+    def import_job(self, job_name, output_filename, engine):
         """Imports an existing output file into WebMO
         
         This call imports an existing computational output file, parsing the output and creating a newly
@@ -323,7 +324,7 @@ class WebMOREST:
         
         Arguments:
             job_name(str): The name of the new WebMO job
-            filename(str): The filename (full path) of an existing output file to import
+            output_filename(str): The filename (full path) of an existing output file to import
             engine(str): The name of the computational engine
             
         Returns:
@@ -332,12 +333,12 @@ class WebMOREST:
         
         params = self._auth.copy()
         params.update({'jobName' : job_name, 'engine' : engine})
-        output_file = {'outputFile' : ('output.log', open(filename, 'rb'), 'text/plain')}
+        output_file = {'outputFile' : ('output.log', open(output_filename, 'rb'), 'text/plain')}
         r = requests.post(self._base_url + '/jobs', data=params, files=output_file)
         r.raise_for_status()
         return r.json()["jobNumber"]
         
-    def submit_job(self, job_name, input_file_contents, engine, queue=None, nodes=1, ppn=1, **kwargs):
+    def submit_job(self, job_name, input_contents, engine, queue=None, nodes=1, ppn=1, **kwargs):
         """Submits and executes a new WebMO job
         
         This call submits and executes a new job to a computational engine, generating a new WebMO job,
@@ -345,7 +346,7 @@ class WebMOREST:
         
         Arguments:
             job_name(str): The name of the new WebMO job
-            input_file_contents(str): The contents of a valid input file to submit to a computational engine
+            input_contents(str): The valid input for submission to the computational engine as its input file
             engine(str): The name of the computational engine
             queue(str, optional): The name of the queue in which to submit the job_name (required for external queues)
             nodes(int, optional): The number of nodes to use; defaults to 1
@@ -358,7 +359,7 @@ class WebMOREST:
         """
         
         params = self._auth.copy()
-        params.update({'jobName' : job_name, 'engine' : engine, 'inputFile': input_file_contents,
+        params.update({'jobName' : job_name, 'engine' : engine, 'inputFile': input_contents,
             'queue': queue, 'nodes': nodes, 'ppn': ppn, **kwargs})
         r = requests.post(self._base_url + '/jobs', data=params)
         r.raise_for_status()
@@ -415,7 +416,7 @@ class WebMOREST:
     # Engines resource
     #
     def get_engines(self, target_user=""):
-        """Fetches a list of job templates available to the current user or specified target user
+        """Fetches a list of computational engines available to the current user or specified target user
 
         This call returns a JSON-formatted list of available engines and associated queues.
 
@@ -620,22 +621,10 @@ class WebMOREST:
     #
     # Helper functions
     #
-    def wait_for_job(self, job_number, poll_frequency=5):
-        """Waits for completion of the specified WebMO job
+    def wait_for_job(self, *job_numbers, poll_frequency=5):
+        """Waits for completion of the specified WebMO jobs(s)
         
-        This call blocks until the specified WebMO job has finished executing (successfully or not)
-        
-        Arguments:
-            job_number(int): The job number to wait for
-            poll_frequency(int, optional): The frequency at which to check the job status (default is 5s)
-        """
-        
-        self.wait_for_jobs([job_number], poll_frequency)
-    
-    def wait_for_jobs(self, job_numbers, poll_frequency=5):
-        """Waits for completion of the specified list of WebMO jobs
-        
-        This call blocks until the specified WebMO jobs have all finished executing (successfully or not)
+        This call blocks until the specified WebMO job(s) have all finished executing (successfully or not)
         
         Arguments:
             job_numbers(list): A list of job numbers which will be waited upon

{webmo-1.3.2 → webmo-1.4.1/webmo.egg-info}/PKG-INFO

@@ -1,9 +1,9 @@
 Metadata-Version: 2.1
 Name: webmo
-Version: 1.3.2
+Version: 1.4.1
 Summary: A Python-based interface to WebMO
 Home-page: https://github.com/jrschmidt2/webmo-python
-Download-URL: https://github.com/jrschmidt2/webmo-python/archive/refs/tags/1.3.2.tar.gz
+Download-URL: https://github.com/jrschmidt2/webmo-python/archive/refs/tags/1.4.1.tar.gz
 Author: J.R. Schmidt
 Author-email: schmidt@webmo.net
 License: MIT
@@ -11,4 +11,5 @@ Keywords: WEBMO,REST,API
 Provides-Extra: spectrum
 Provides-Extra: util
 Provides-Extra: gui
+Provides-Extra: all
 License-File: LICENSE

{webmo-1.3.2 → webmo-1.4.1}/webmo.egg-info/requires.txt

@@ -1,6 +1,12 @@
 requests
 websockets
 
+[all]
+numpy
+PubChemPy
+questionary
+ipywidgets
+
 [gui]
 questionary
 ipywidgets

webmo-1.3.2/webmo/util.py

@@ -1,25 +0,0 @@
-def xyz_from_name(name):
-    """Obtains an XYZ-formatted geometry for the molecule name via PubChem lookup.
-
-    Arguments:
-        name(str): The name of the molecule.
-
-    Returns:
-        A string containing the molecule's XYZ-formatted geometry.
-    """
-    import pubchempy as pcp
-
-    results = pcp.get_compounds(name, 'name', record_type='3d')
-    if (len(results) == 0):
-        raise ValueError("Specified molecule could not be found in PubChem")
-
-    record = results[0]
-    geom = ""
-    for atom in record.atoms:
-        element = atom.element
-        x = float(atom.x)
-        y = float(atom.y)
-        z = float(atom.z)
-        geom += f"{element}\t{x:f}\t{y:f}\t{z:f}\n"
-        
-    return geom