feffdb 0.1__py3-none-any.whl

feffdb/utils.py

@@ -0,0 +1,359 @@
+#!/usr/bin/env python
+"""
+very simple interface to CIF file for Feff DB
+"""
+import json
+import os
+import shutil
+import sqlite3
+import re
+from io import IOBase
+from charset_normalizer import from_bytes
+from pathlib import Path
+from platformdirs import user_data_dir
+from warnings import warn
+from xraydb import XrayDB, atomic_mass, atomic_symbol
+from xraydb.chemparser import chemparse
+
+from pymatgen.io.cif import CifParser
+
+from .schema import feffdb_schema, VERSIONS
+
+FEFFDB_NAME  = 'feffdat.db'
+FEFFDB_ENV   = 'FEFFDAT_DB'
+LARCHDIR_ENV = 'LARCHDIR '
+LARCHDIR_DEF = '.larch'
+
+
+def is_feffdb(db: str|sqlite3.Connection) -> bool:
+    """test if database file or open connection is a valid Feffdata DB
+
+    a valid FEFFDB file has tables 'feffdat', 'feffinp', 'cif', 'element', and 'info'
+    """
+
+    feffdb_tables = ("element", "info", "feffdat", "feffinp", "cif")
+    if isinstance(db, sqlite3.Connection):
+        dbconn = db
+    else:
+        try:
+            dbconn  = sqlite3.connect(db)
+        except Exception:
+            return False
+
+    cursor = dbconn.cursor()
+    cursor.execute("select name from sqlite_master where type='table';")
+    tables = [row[0] for row in cursor.fetchall()]
+    return all([tab in tables for tab in feffdb_tables])
+
+
+def get_feffdb(dbname:str|None=None) -> Path:
+    """return Path to FEFF DB file
+
+    1. if the passed dbname is a valid FeffDB, that will be used.
+    2. if the Environmental Variable FEFFDAT_DB is set (and is a valid FeffDB),
+       that will be used.
+    4. Use `platformsdir.user_data_dir()` to find a `feffdb` folder.
+       if `feffdat.db` exists there, use that.
+    5. Try to create `platformsdir.user_data_dir('feffdb')` and copy
+       the feffdat.db there, and use that if it suceeeds.
+
+    Finally, if no valid FEFF DB can be found a ValueError will be raised.
+    """
+    if dbname is None:
+        dbname = os.environ.get(FEFFDB_ENV, None)
+    if is_feffdb(dbname):
+        return Path(dbname)
+
+    parent = Path(user_data_dir('feffdb'))
+    parent.mkdir(mode=0o755, exist_ok=True)
+    dbpath = parent / FEFFDB_NAME
+    if is_feffdb(dbpath):
+        return dbpath
+
+    else:
+        here = Path(__file__).parent / FEFFDB_NAME
+        try:
+            shutil.copy(here, dbpath)
+            if is_feffdb(dbpath):
+                return dbpath
+        except Exception:
+            warn(f'could not install {FEFFDB_NAME} to {parent}')
+
+    raise ValueError("cannot find a valid Feff Database")
+
+
+def create_feffdb(dbname=None):
+    """create FeffData.DB"""
+    if dbname is None:
+        dbpath = get_feffdb()
+    else:
+        dbpath = Path(dbname)
+        if dbpath.exists():
+            raise IOError(f"file {dbname} already exists")
+        dbpath.parent.mkdir(parents=True, mode=0o755, exist_ok=True)
+
+    conn = sqlite3.connect(dbpath)
+    c = conn.cursor()
+    for t in feffdb_schema.split(';'):
+        c.execute(t)
+
+    for version_dat in VERSIONS:
+        c.execute('insert into version values (?, ?, ?, ?)', version_dat)
+
+    xdb = XrayDB()
+    eltab = xdb.tables['elements']
+    q = []
+    for row in xdb.query(eltab).all():
+        c.execute('insert into element values (?, ?, ?, ?)',
+                 (row.atomic_number, row.element, row.name, row.molar_mass))
+    conn.commit()
+
+
+def read_textfile(filename):
+    """read text from a file as string
+
+    Argument
+    --------
+    filename  (str or file): name of file to read or file-like object
+
+    Returns
+    -------
+    text of file as string.
+
+    Notes
+    ------
+    1. the encoding is detected with charset_normalizer.from_bytes
+       which is then used to decode bytes read from file.
+    2. line endings are normalized to be '\n'.
+    """
+
+    text = ''
+    def decode(bytedata):
+        return str(from_bytes(bytedata).best())
+
+    if isinstance(filename, IOBase):
+        text = filename.read()
+        if filename.mode == 'rb':
+            text = decode(text)
+    else:
+        with open(Path(filename), 'rb') as fh:
+            text = decode(fh.read())
+    return text.replace('\r\n', '\n').replace('\r', '\n')
+
+
+def get_filename_and_text(fname):
+    if isinstance(fname, Path):
+        fname = fname.absolute().resolve().as_posix()
+        text = read_textfile(fname)
+    elif isinstance(fname, str) and len(fname) < 255:
+        fname = Path(fname).absolute().resolve().as_posix()
+        text = read_textfile(fname)
+    else:
+        text = fname
+        fname = '<unknown>'
+    return fname, text
+
+def parse_cif(ciffile):
+    ciffile, ciftext = get_filename_and_text(ciffile)
+
+    try:
+        cif = CifParser.from_str(ciftext, occupancy_tolerance=10, site_tolerance=0.005)
+    except Exception:
+        raise ValueError(f'invalid CIF {ciffile}')
+
+    cifkey = list(cif._cif.data.keys())[0]
+    dat = cif._cif.data[cifkey].data
+
+    formula = None
+    for formname in ('_chemical_formula_sum', '_chemical_formula_moiety'):
+        if formname in dat:
+            try:
+                parsed_formula = chemparse(dat[formname])
+                formula = dat[formname].replace(' ', '')
+            except:
+                print("Could not parse ", dat[formname])
+
+    if formula is None and '_atom_site_type_symbol' in dat:
+        comps = {}
+        complist = dat['_atom_site_type_symbol']
+        for c in complist:
+            if c not in comps:
+                nx = complist.count(c)
+                comps[c] = '%s%d' % (c, nx) if nx != 1 else c
+        formula = ''.join(comps.values())
+
+    if formula is None:
+        raise ValueError(f'Cannot read chemical formula from CIF {ciffile}')
+
+    # compound
+    compound = '<missing>'
+    for compname in ('_chemical_compound_source',
+                     '_chemical_name_systematic',
+                     '_chemical_name_common',
+                     '_chemical_name_mineral'):
+        if compname in dat:
+            compound = dat[compname]
+
+    # get spacegroup and symmetry
+    sgroup_name = dat.get('_symmetry_space_group_name_H-M', None)
+    if sgroup_name is None:
+        for key, val in dat.items():
+            if 'space_group' in key and 'H-M' in key:
+                sgroup_name = val
+
+    source_db = ''
+    source_id = -1
+    amcsd_id = dat.get('_database_code_amcsd', None)
+    if amcsd_id is not None:
+        source_db = 'amcsd'
+        source_id = amcsd_id
+
+    return {'text': ciftext, 'filename': ciffile,
+            'formula': formula, 'compound': compound,
+            'space_group': sgroup_name,
+            'source_db': source_db, 'source_id': source_id}
+
+
+def parse_feffinp(feffinp):
+    """parse feff.inp just enough for FeffDB"""
+
+    feffinp, text = get_filename_and_text(feffinp)
+
+    edge = ''
+    absorber = 0
+    ipots = []
+    natoms = 0
+    mode = None
+    for line in text.split('\n'):
+        line = line.strip()
+        if line.startswith('*') or line.startswith('#'):
+            continue
+
+        if line.lower().startswith('edge'):
+            words = line.split(' ')
+            edge = words[1].upper()
+        elif line.lower().startswith('potent'):
+            mode = 'pot'
+        elif line.lower().startswith('atoms'):
+            mode = 'atoms'
+        elif line.lower().startswith('end'):
+            mode = None
+        elif mode == 'pot':
+            if line.startswith('0'):
+                words = line.strip().split()
+                absorber = int(words[1])
+            elif len(line) > 6:
+                words = line.strip().split()
+                ipots.append(int(words[1]))
+        elif mode == 'atoms':
+            try:
+                words = line.strip().split()
+                w = [float(x) for x in words[:4]]
+                natoms += 1
+            except (ValueError, TypeError):
+                pass
+
+    return {'text': text, 'filename': feffinp, 'absorber': absorber,
+            'edge': edge, 'scatterers': json.dumps(ipots), 'natoms': natoms}
+
+
+def parse_feffdat(feffdatfile):
+    """parse feffdat just enough for FeffDB"""
+    feffdatfile, fefftext = get_filename_and_text(feffdatfile)
+
+    mode = 'header'
+    potentials, geom, data = [], [],[]
+    version, pcounter, iline = '', 0, 0
+    reff = 0.0
+    lines = fefftext.split('\n')
+
+    if 'feff' not in lines[0].lower()[:]:
+        raise ValueError(f'Not a valid feff.dat file: {feffdatfile}')
+
+    for line in lines:
+        iline += 1
+        line = line[:-1].strip()
+        if line.startswith('#'):
+            line = line[1:].strip()
+
+        if iline == 1:
+            title = line[:64].strip()
+            version = line[64:].strip()
+            continue
+        if line.startswith('k') and 'mag[feff]' in line:
+            mode = 'arrays'
+            break
+        elif '----' in line[2:10]:
+            mode = 'path'
+            continue
+        #
+        if (mode == 'header' and
+            (re.match(r'^Abs\b', line) or re.match(r'^Pot\s+\d+\b', line)) and
+            re.search(r'\bZ\s*=', line)):
+            words = line.replace('=', ' ').split()
+            ipot, z, rmt, rnm = (0, 0, 0, 0)
+            words.pop(0)
+            if re.match(r'^Pot\s+\d+\b', line):
+                ipot = int(words.pop(0))
+            iz = int(words[1])
+            rmt = float(words[3])
+            rnm = float(words[5])
+            if re.match(r'^Abs\b', line):
+                edge = words[6]
+            potentials.append((ipot, iz, rmt, rnm))
+        elif mode == 'header' and re.match(r'^Gam_ch\s*=', line):
+            pass
+        elif mode == 'header' and re.match(r'^Mu\s*=', line):
+            pass
+        elif mode == 'path':
+            pcounter += 1
+            if pcounter == 1:
+                w = [float(x) for x in line.split()[:5]]
+                nleg = int(w.pop(0))
+                degen, reff, rnorman, e_edge = w
+            elif pcounter > 2:
+                words = line.split()
+                xyz = [float(x) for x in words[:3]]
+                ipot = int(words[3])
+                iz   = int(words[4])
+                if len(words) > 5:
+                    lab = words[5]
+                else:
+                    lab = atomic_symbol(iz)
+                amass = atomic_mass(iz)
+                this_geom = [lab, iz, ipot, amass] + xyz
+                if len(geom) == 0:
+                    absorber = lab
+                geom.append(tuple(this_geom))
+        elif mode == 'arrays':
+            break
+
+    if len(geom) < 2:
+        raise ValueError(f'could not read Path from feff.dat file: {feffdatfile}')
+
+    absorber = geom[0][1]
+    scatterer = geom[1][1]
+
+    return {'text': fefftext, 'filename': feffdatfile,
+            'absorber': absorber, 'scatterer': scatterer,
+            'reff': reff,  'degen': degen, 'nleg': nleg,
+            'edge': edge, 'geometry': json.dumps(geom)}
+
+
+
+if __name__ == '__main__':
+    print("CIF")
+    out = parse_cif('../fayalite.cif')
+    print(out.keys())
+    print(len(out['text']))
+    for key, val in out.items():
+        if key != 'text':
+            print(key, val)
+
+    print("FEFF:")
+    out = parse_feffdat('../feff0001.dat')
+    print(out.keys())
+    print(len(out['text']))
+    for key, val in out.items():
+        if key != 'text':
+            print(key, val)

feffdb/version.py

@@ -0,0 +1,24 @@
+# file generated by vcs-versioning
+# don't change, don't track in version control
+from __future__ import annotations
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+version: str
+__version__: str
+__version_tuple__: tuple[int | str, ...]
+version_tuple: tuple[int | str, ...]
+commit_id: str | None
+__commit_id__: str | None
+
+__version__ = version = '0.1'
+__version_tuple__ = version_tuple = (0, 1)
+
+__commit_id__ = commit_id = 'ga71d582ee'

feffdb-0.1.dist-info/METADATA

@@ -0,0 +1,62 @@
+Metadata-Version: 2.4
+Name: feffdb
+Version: 0.1
+Summary: Sqlite Database for Feff.dat files, especially for 1st shell EXAFS
+Author-email: Matthew Newville <matt.newville@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/xraypy/feffdb
+Project-URL: Documentation, https://xraypy.github.io/feffdb
+Project-URL: Tracker, https://github.com/xraypy/feffdb/issues
+Keywords: Feff,EXAFS
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Scientific/Engineering :: Visualization
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3.15
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: xraydb
+Requires-Dist: numpy>=2.2
+Requires-Dist: scipy
+Requires-Dist: charset_normalizer
+Requires-Dist: sqlalchemy>=2
+Requires-Dist: pymatgen>=2025.6.14
+Requires-Dist: pyshortcuts>=1.9.8
+Requires-Dist: tabulate
+Provides-Extra: dev
+Requires-Dist: build; extra == "dev"
+Requires-Dist: twine; extra == "dev"
+Provides-Extra: doc
+Requires-Dist: sphinx; extra == "doc"
+Requires-Dist: sphinx-copybutton; extra == "doc"
+Requires-Dist: sphinx-design; extra == "doc"
+Requires-Dist: sphinxcontrib-video; extra == "doc"
+Requires-Dist: jupyter_sphinx; extra == "doc"
+Requires-Dist: nbsphinx; extra == "doc"
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Requires-Dist: pytest-cov; extra == "test"
+Requires-Dist: coverage; extra == "test"
+Provides-Extra: all
+Requires-Dist: feffdb[dev,doc,test]; extra == "all"
+Dynamic: license-file
+
+# FeffDB
+
+Feff DB is an SQLite3 database and Python library for the results of
+Feff EXAFS calculations, and some support code to read and work with
+this database and the data it contains.  The initial motivation is to
+provide "first-shell EXAFS" calculations for many common ligands or
+atom pairs, so that these can be browsed and re-used without having to
+setup and run Feff for many common cases.

feffdb-0.1.dist-info/RECORD

@@ -0,0 +1,15 @@
+feffdb/__init__.py,sha256=07HjHdlM1FIAMz9OjA4DsIe_AuL9c-TEcPKyRchtY7I,323
+feffdb/apps.py,sha256=cLhJUVudaqxilYRBe7YeIrpqwjcZKi4rmu3gx7s_d_g,2817
+feffdb/feffdat.db,sha256=5dYiqC3Le7esrMFW_hRYyYACChPPQL0UHlJvWDsDYbs,1662976
+feffdb/feffdb.py,sha256=de_NEqCFPcvHoRPCl2_NTySjoyFJIBXwmwABbR1bdsU,12087
+feffdb/feffpath.py,sha256=oIR8ZBqX6JF5UaPiwYZ4kwezy63I0kBvj5w9Ra3XmLw,19040
+feffdb/schema.py,sha256=oDAlV_uDTWKU6WqXM1ANufDYRJ2TIQ4EL4DNviYMnLk,3224
+feffdb/simpledb.py,sha256=CQg8LcmtyVoHAcJImfqxfzKJd4DqrD1KkYFzx3HX6D8,12547
+feffdb/utils.py,sha256=FQwRjM4vQTchp5dzEevgvyA84HjJmEYl8duDFKQW9rU,11068
+feffdb/version.py,sha256=dG56YXWdUYnaF4XVp7VDuwKai6JwmgaruKwoXv7wy0k,523
+feffdb-0.1.dist-info/licenses/LICENSE,sha256=NnCHEmQk-hVaiYelyQ2olHgC2-ixV_alvCBvYjNVbQU,1359
+feffdb-0.1.dist-info/METADATA,sha256=3pSgIKoNjAk-HhBcp7mXFJYLa2EAXTS0a_8ee_r9ex4,2486
+feffdb-0.1.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+feffdb-0.1.dist-info/entry_points.txt,sha256=QLUHJcPcZLQjt1O_eZ6emH2PfUCNzWvTvd7h5V6VCXY,50
+feffdb-0.1.dist-info/top_level.txt,sha256=5lUQJfFqNkLACCVftnG7Vvb8WECZ-4DYxTPWyES4lCI,7
+feffdb-0.1.dist-info/RECORD,,

feffdb-0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.2.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

feffdb-0.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+feffdb = feffdb.apps:feffdb_cli

feffdb-0.1.dist-info/licenses/LICENSE

@@ -0,0 +1,28 @@
+MIT License
+
+Copyright (c) 2026 FeffDB development team, including
+  - Samantha Liao, Cornell University
+  - Juanjuan Huang, Argonne National Laboratory
+  - Nina Andrejevic, Argonne National Laboratory
+  - Yanna Chen, Canadian Light Source
+  - Matthew Newville, The University of Chicago
+  - Shelly Kelly, Argonne National Laboratory
+
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

feffdb-0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+feffdb