feffdb 0.1__py3-none-any.whl

feffdb/__init__.py

@@ -0,0 +1,7 @@
+from .utils import get_feffdb, is_feffdb, create_feffdb
+from .feffdb import FeffDatabase
+from .feffpath import feffpath, FeffDatFile
+from .version import __version__, version_tuple
+
+__all__ = ['get_feffdb', 'is_feffdb', 'create_feffdb', 'feffpath',
+           'FeffDatabase', 'FeffDatFile', '__version__', 'version_tuple']

feffdb/apps.py

@@ -0,0 +1,77 @@
+from argparse import ArgumentParser
+
+from pathlib import Path
+from tabulate import tabulate
+import xraydb
+from .utils import get_feffdb, create_feffdb
+from .feffdb import FeffDatabase
+
+
+VALID_ELEMS = [el.element for el in xraydb.get_xraydb().get_cache('elements')]
+VALID_ELEMS.extend(['None', 'none', 'All', 'all'])
+
+def feffdb_cli():
+    """
+    feffdb command-line app
+    """
+    dbname_default = get_feffdb().absolute().as_posix()
+    parser = ArgumentParser(description='Feff Database')
+    parser.add_argument('-n', '--name', dest='dbname',
+                       default=None, help=f"database to use [{dbname_default}]" )
+    parser.add_argument('-c', '--create', action='store_true', default=False,
+                            help="create new database")
+    parser.add_argument('--rmin',  default=0,
+                        help='minimum distance (Ang)')
+    parser.add_argument('--rmax',  default=10,
+                        help='maximum distance (Ang)')
+    parser.add_argument('absorber', nargs='?',
+                        help='symbol for absorbing element (use "all" for all absorbers)')
+    parser.add_argument('scatterer', nargs='?',
+                        help='symbol for scattering element')
+
+    args = parser.parse_args()
+
+    dbname = args.dbname or dbname_default
+
+    if Path(dbname).exists() and args.create:
+        print(f"database {dbname} already exists!")
+
+    if not Path(dbname).exists():
+        if args.create:
+            print("will create db ", dbname)
+            create_feffdb(name=dbname)
+            return
+        else:
+            print(f"database {dbname} does not exist, use '-c' to create")
+            return
+
+    feffdb = FeffDatabase(dbname, create_ok=False)
+    npaths = feffdb.list_feffdat()
+    if npaths is None or len(npaths) < 1:
+        print(f"database {dbname} exists but is empty")
+        return
+
+
+
+    absorber = args.absorber
+    if absorber not in VALID_ELEMS:
+        print(f"Unknown absorber: {absorber}, Must be valid atomic symbol or 'All' or 'None'")
+
+    scatterer = args.scatterer
+    if scatterer is not None and scatterer not in VALID_ELEMS:
+        print(f"Unknown scatterer: {scatterer} Must be valid atomic symbol or  empty or 'All' or 'None'")
+
+    out = []
+    if absorber is not None or scatterer is not None:
+        if scatterer in ('All', 'all', 'None', 'none'):
+            scatterer = None
+        if absorber in ('All', 'all', 'None', 'none'):
+            absorber = None
+        rows = feffdb.list_feffdat(absorber=absorber, scatterer=scatterer,
+                                   rmin=float(args.rmin), rmax=float(args.rmax).
+                                   with_geometry=False)
+        out.append(row)
+    if len(out) > 0:
+        print(tabulate(out, headers='keys', tablefmt='psql'))
+    else:
+        parser.print_usage()

feffdb/feffdb.py

@@ -0,0 +1,318 @@
+#!/bin/env python
+'''
+This script creates an SQLite3 database for Feff Data
+'''
+import json
+import lzma
+from pathlib import Path
+from pyshortcuts import hash_password, check_password_rules
+from xraydb import atomic_number, atomic_symbol
+
+
+from .simpledb import SimpleDB
+from .utils import (get_feffdb, create_feffdb,
+                    parse_cif, parse_feffinp, parse_feffdat)
+
+def compress(val):
+    return lzma.compress(val.encode('utf-8'))
+
+def decompress(val):
+    return lzma.decompress(val).decode('utf-8')
+
+class FeffDatabase(SimpleDB):
+    def __init__(self, dbname=None, create_ok=False, read_only=False):
+        if dbname is not None:
+           dbpath = Path(dbname)
+        else:
+            try:
+                dbpath = get_feffdb()
+            except ValueError:
+                dbpath = None
+
+        if (dbpath is None or not dbpath.exists()) and create_ok:
+            create_feffdb(dbname=dbname)
+
+        self.dbname = dbpath.absolute().as_posix()
+        SimpleDB.__init__(self, dbname=self.dbname, server='sqlite',
+                          read_only=read_only)
+
+    def __repr__(self):
+        return f"FeffDatabase('{self.dbname}')"
+
+
+    def __addrow(self, table, data):
+        """add row to tablle, or return existing row with data"""
+        # first look if this already exists
+        row = self.get_rows(table, where=data,
+                            limit_one=True, none_if_empty=True)
+
+        if row is None:
+            self.insert(table, **data)
+            row = self.get_rows(table, where=data,
+                                limit_one=True, none_if_empty=True)
+        if row is None:
+            return None
+        return row.id
+
+
+    def add_cif_file(self, cif_file):
+        """add a CIF file to the database"""
+        try:
+            out = parse_cif(cif_file)
+        except ValueError:
+            print(f"error parsing {cif_file}")
+            return None
+
+        text = compress(out.pop('text'))
+        fname = out.pop('filename')
+        dbargs = {k:v for k, v in out.items()}
+        dbargs['ciftext'] = text
+        if dbargs['source_db'] is None and fname is not None:
+            dbargs['source_db'] = fname
+
+        this_id = self.__addrow('cif', dbargs)
+        if this_id is None:
+            raise ValueError(f'could not add CIF: {cif_file}')
+        return this_id
+
+
+    def add_feffinp(self, feff_inp, cif_file=None):
+        """add a Feff input file to the database"""
+        cif_id = 0
+        if cif_file is not None:
+            cif_id = self.add_cif_file(cif_file)
+
+        try:
+            finp = parse_feffinp(feff_inp)
+        except ValueError:
+            raise ValueError(f'error parsing feffinp : {feff_inp}')
+
+        text = compress(finp.pop('text'))
+        finp.pop('filename')
+        dbargs = {k:v for k, v in finp.items()}
+        dbargs['inptext'] = text
+        dbargs['cif_id'] = cif_id
+
+        this_id = self.__addrow('feffinp', dbargs)
+        if this_id is None:
+            raise ValueError(f'could not add feffinp : {feff_inp}')
+        return this_id
+
+    def add_feffdat(self, feffdat, feff_inp, cif_file=None,
+                    label=None, description=None,
+                    avoid_duplicates=True, rtoler=0.015):
+        """add a Feff.dat file to the database"""
+
+        finp_id = self.add_feffinp(feff_inp, cif_file=cif_file)
+
+        try:
+            dat = parse_feffdat(feffdat)
+        except ValueError:
+            raise ValueError(f'error parsing feff.dat file: {feffdat}')
+
+        text = compress(dat.pop('text'))
+        fname = dat.pop('filename')
+
+        if avoid_duplicates:
+            nearby = self.list_feffdat(absorber=dat['absorber'],
+                                       scatterer=dat['scatterer'],
+                                       edge=dat['edge'],
+                                       rmin=float(dat['reff'])-rtoler,
+                                       rmax=float(dat['reff'])+rtoler)
+            if len(nearby) > 0:
+                print("Avoiding Duplicate entries:")
+                s = nearby[0]
+                print('This: ', dat['absorber'],  dat['scatterer'],    dat['edge'],  dat['reff'])
+                print(s['id'], s['label'], s['absorber'], s['scatterer'], s['edge'], s['reff'])
+                return
+
+        if description is None:
+            # default description is filenamae and a few parent folders
+            words = Path(fname).parts
+            n = min(len(words), 2)
+            description = Path(*words[-n:]).as_posix()
+        if label is None:
+            # default label combines absorber, scatterer, reff
+            words = [atomic_symbol(dat['absorber']),
+                     atomic_symbol(dat['scatterer']),
+                     str(round(100*dat['reff']))]
+            label = ''.join(words)
+
+
+        if label is not None:
+            # check fie repeated rows
+            rows = self.get_rows('feffdat', where={'label': label},
+                                 none_if_empty=True)
+            if rows is not None:
+                words = [atomic_symbol(dat['absorber']),
+                         atomic_symbol(dat['scatterer']),
+                         str(round(100*dat['reff'])), '_', dat['edge']]
+                label = ''.join(words)
+                rows = self.get_rows('feffdat', where={'label': label},
+                                 none_if_empty=True)
+
+                if rows is not None:
+                    olabel, i = label, 0
+                    while rows is not None:
+                        i += 1
+                        label = f'{olabel}_{i}'
+                        rows = self.get_rows('feffdat', where={'label': label},
+                                             none_if_empty=True)
+
+
+        dbargs = {k:v for k, v in dat.items()}
+        dbargs['feffdat'] = text
+        dbargs['feffinp_id'] = finp_id
+        dbargs['label'] = label
+        dbargs['description'] = description
+
+        this_id = self.__addrow('feffdat', dbargs)
+        if this_id is None:
+            raise ValueError(f'could not add feff data: {feffdat}')
+        return this_id
+
+    def get_feffdat(self, feffid):
+        """get text of feff.dat, either by table 'id' or
+        or by 'label' in feffdat table
+        """
+        try:
+            where = {'id': int(feffid)}
+        except ValueError:
+            where = {'label': feffid}
+
+        row = self.get_rows('feffdat', where=where,
+                            limit_one=True, none_if_empty=True)
+        if row is not None:
+            return decompress(row.feffdat)
+
+    def get_feffinp(self, feffinp_id):
+        "get text of feff.inp by id in feffinp table"
+        row = self.get_rows('feffinp', where={'id': feffinp_id},
+                            limit_one=True, none_if_empty=True)
+        if row is not None:
+            return decompress(row.inptext)
+
+    def get_feffinp_for_feffdat(self, feffdat_id):
+        "get text of feff.inp for a Feff.dat file"
+        row = self.get_rows('feffdat', where={'id': feffdat_id},
+                            limit_one=True, none_if_empty=True)
+        if row is not None:
+            trow = self.get_rows('feffinp', where={'id': row.feffinp_id},
+                                 limit_one=True, none_if_empty=True)
+            if trow is not None:
+                return decompress(trow.inptext)
+
+    def get_cifinp_for_feffinp(self, feffinp_id):
+        "get text of CIF for a feff.inp file"
+        row = self.get_rows('feffinp', where={'id': feffinp_id},
+                            limit_one=True, none_if_empty=True)
+        if row is not None:
+            trow = self.get_rows('cif', where={'id': row.cif_id},
+                                 limit_one=True, none_if_empty=True)
+            if trow is not None:
+                return decompress(trow.ciftext)
+
+    def list_feffdat(self, absorber=None, scatterer=None, edge=None,
+                     rmin=0., rmax=20.0, with_geometry=True):
+        """get a list of feff.dat files matching on one or more criteria:
+
+        Arguments
+        ------------
+        absorber   (None or str) symbol for absorber [None for all]
+        scatterer  (None or str) symbol for scatterer [None for all]
+        edge       (None or str) string for absorption edge [None for all]
+        rmin       float  minimum R value  [0.0]
+        rmax       float  maximum R value  [20.0]
+        with_geometry bool  whether to include 'geometry'  [True]
+        Returns
+        --------
+        list of path dictionaries
+        """
+        wargs = {}
+        if absorber is not None:
+            if isinstance(absorber, str):
+                absorber = atomic_number(absorber.title())
+            wargs['absorber'] = absorber
+        if scatterer is not None:
+            if isinstance(scatterer, str):
+                scatterer = atomic_number(scatterer.title())
+            wargs['scatterer'] = scatterer
+        if edge is not None:
+            wargs['edge'] = edge.title()
+
+        rows = self.get_rows('feffdat', where=wargs, limit_one=False)
+        out = []
+        for row in rows:
+            if row.reff > rmin and row.reff < rmax:
+                formula = '?'
+                finp = self.get_rows('feffinp', where={'id': row.feffinp_id},
+                                     limit_one=True, none_if_empty=True)
+                if finp is not None and finp.cif_id > 0:
+                    cif = self.get_rows('cif', where={'id': finp.cif_id},
+                                     limit_one=True, none_if_empty=True)
+                    if cif is not None:
+                        formula  = cif.formula
+                        compound = cif.compound.lower()
+
+                rowdat = {'id': row.id,
+                          'label': row.label,
+                          'absorber': atomic_symbol(row.absorber),
+                          'scatterer': atomic_symbol(row.scatterer),
+                          'edge': row.edge,
+                          'reff': row.reff,
+                          'degen': row.degen,
+                          'formula': formula,
+                          'compound': compound,
+                          'description': row.description}
+                if with_geometry:
+                    rowdat['geometry'] = json.loads(row.geometry)
+                out.append(rowdat)
+        return out
+
+
+    def add_person(self, email, name=None, password=''):
+        """add a person (email, optional name) to feffdat table:
+         used for ratings and to identify added feff.dat files
+        """
+        dbargs = {'email': email}
+        row = self.get_rows('person', where=dbargs,
+                            limit_one=True, none_if_empty=True)
+        if row is not None:
+            if name is not None and name != row.name:
+                self.update('person', where=dbargs, name=name)
+            else:
+                print(f"warning person {email} already exisis")
+        else:
+            if name is not None:
+                dbargs['name'] = name
+            if password is None:
+                password = ''
+            if len(password) > 1:
+                password_ok = check_password_rules(password)
+                if not password_ok:
+                    raise ValueError('Password is invalid')
+                dbargs['password'] = hash_password(password)
+
+            self.__addrow('person', dbargs)
+
+    def get_person(self, email):
+        """get person by email"""
+        return self.get_rows('person', where={'email': email},
+                            limit_one=True, none_if_empty=True)
+
+    def check_person_password(self, email, password):
+        """check validity of a person's password"""
+        # if len(person
+
+    def get_feffdat_ratings(self, feffdat_id=None, email=None):
+        """get all ratings for feff.dat file either by feffdat_id or by email
+        """
+        args = {}
+        if feffdat_id is not None:
+            args['feffdat_id'] = feffdat_id
+        if email is not None:
+            person_row = self.get_person(email)
+            if person_row is not None:
+                args['person_row'] = person_row.id
+
+        return self.get_rows('feffdat_ratings', where=args)