automol 0.0.1__tar.gz

automol-0.0.1/PKG-INFO

@@ -0,0 +1,13 @@
+Metadata-Version: 2.3
+Name: automol
+Version: 0.0.1
+Author: Andreas V. Copan
+Author-email: Andreas V. Copan <avcopan@uga.edu>
+Requires-Dist: networkx>=3.3
+Requires-Dist: numpy>=2.0
+Requires-Dist: pint>=0.24
+Requires-Dist: py3dmol>=2.5
+Requires-Dist: pydantic>=2.5
+Requires-Dist: rdkit>=2025
+Requires-Dist: scipy>=1.13
+Requires-Python: >=3.12

automol-0.0.1/pyproject.toml

@@ -0,0 +1,86 @@
+[project]
+name = "automol"
+version = "0.0.1"
+authors = [{name = "Andreas V. Copan", email = "avcopan@uga.edu"}]
+requires-python = ">= 3.12"
+dependencies = [
+    "networkx>=3.3",
+    "numpy>=2.0",
+    "pint>=0.24",
+    "py3dmol>=2.5",
+    "pydantic>=2.5",
+    "rdkit>=2025",
+    "scipy>=1.13",
+]
+
+[build-system]
+build-backend = "uv_build"
+requires = ["uv_build"]
+
+# Ruff configurations
+[tool.ruff]
+exclude = [
+    "docs",
+    "**/*.ipynb",
+]
+
+[tool.ruff.lint]
+select = ["ALL"]
+ignore = [
+    "COM812",   # missing trailing comma (handled by format)
+    "RUF022",   # `__all__` is not sorted
+    "TID252",   # relative import
+    "D203",     # confict: incorrect blank line before class (uses D211 instead)
+    "D213",     # conflict: multi-line summary second line (uses D212 instead)
+]
+
+[tool.ruff.lint.per-file-ignores]
+"tests/**.py" = ["S101"]
+
+[tool.ruff.lint.pydocstyle]
+convention = "numpy"
+
+# Ty configurations
+[tool.ty.environment]
+python = ".pixi/envs/dev/bin/python"
+
+[tool.ty.src]
+include = [
+    "src",
+    "tests",
+]
+
+# Import-linter configurations
+[tool.importlinter]
+root_package = "automol"
+
+[[tool.importlinter.contracts]]
+name = "Module Layering"
+type = "layers"
+layers = [
+    "automol.smiles",
+    "automol.geom",
+    "automol.rd",
+    "automol.types | automol.element",
+]
+
+# Pytest configurations
+[tool.pytest.ini_options]
+testpaths = ["tests", "src"]
+addopts = [
+    "--doctest-modules",
+    "--cov=automol",
+    "--cov-report=term-missing",
+    "--cov-report=xml",
+]
+doctest_optionflags = "NORMALIZE_WHITESPACE"
+
+# Pytest-cov configurations
+[tool.coverage.run]
+branch = true
+source = ["automol"]
+
+[tool.coverage.report]
+show_missing = true
+skip_covered = true
+fail_under = 80

automol-0.0.1/src/automol/__init__.py

@@ -0,0 +1,8 @@
+"""automol."""
+
+__version__ = "0.0.1"
+
+from . import geom, types
+from .geom import Geometry
+
+__all__ = ["geom", "types", "Geometry"]

automol-0.0.1/src/automol/element/__init__.py

@@ -0,0 +1,5 @@
+"""Element data."""
+
+from .core import Element, from_key, mass, mass_number, number, symbol
+
+__all__ = ["Element", "from_key", "mass", "mass_number", "number", "symbol"]

automol-0.0.1/src/automol/element/core.py

@@ -0,0 +1,140 @@
+"""Core element interface."""
+
+import json
+from dataclasses import dataclass
+from pathlib import Path
+
+
+@dataclass(frozen=True, slots=True)
+class Element:
+    """
+    Chemical element.
+
+    Attributes
+    ----------
+    Z :
+        Atomic number.
+    A :
+        Mass number.
+    symbol :
+        Chemical symbol.
+    mass :
+        Atomic mass.
+    """
+
+    Z: int
+    A: int
+    symbol: str
+    mass: float
+
+
+ELEMENT_BY_NUMBER: dict[int, Element] = {}
+ELEMENT_BY_SYMBOL: dict[str, Element] = {}
+
+
+def _load_elements() -> None:
+    data_path = Path(__file__).with_name("elements-data.json")
+
+    with data_path.open() as f:
+        elements_data: list[dict[str, object]] = json.load(f)
+
+    for element_data in elements_data:
+        element = Element(**element_data)
+
+        ELEMENT_BY_NUMBER[element.Z] = element
+        ELEMENT_BY_SYMBOL[element.symbol.casefold()] = element
+
+
+_load_elements()
+
+
+def from_key(key: int | str) -> Element:
+    """
+    Retrieve element by atomic number or symbol.
+
+    Parameters
+    ----------
+    key :
+        Atomic number (int) or symbol (str).
+
+    Returns
+    -------
+        Requested element.
+
+    Raises
+    ------
+    TypeError
+        If key is not int or str.
+    """
+    if isinstance(key, int):
+        return ELEMENT_BY_NUMBER[key]
+
+    if isinstance(key, str):
+        return ELEMENT_BY_SYMBOL[key.casefold()]
+
+    msg = f"Element key must be int or str, got {type(key).__name__}"
+    raise TypeError(msg)
+
+
+def number(key: int | str) -> int:
+    """
+    Retrieve atomic number of element by atomic number or symbol.
+
+    Parameters
+    ----------
+    key :
+        Atomic number (int) or symbol (str).
+
+    Returns
+    -------
+        Atomic number.
+    """
+    return from_key(key).Z
+
+
+def mass_number(key: int | str) -> int:
+    """
+    Retrieve mass number of element by atomic number or symbol.
+
+    Parameters
+    ----------
+    key :
+        Atomic number (int) or symbol (str).
+
+    Returns
+    -------
+        Mass number.
+    """
+    return from_key(key).A
+
+
+def symbol(key: int | str) -> str:
+    """
+    Retrieve atomic symbol of element by atomic number or symbol.
+
+    Parameters
+    ----------
+    key :
+        Atomic number (int) or symbol (str).
+
+    Returns
+    -------
+        Atomic symbol.
+    """
+    return from_key(key).symbol
+
+
+def mass(key: int | str) -> float:
+    """
+    Retrieve atomic mass of element by atomic number or symbol.
+
+    Parameters
+    ----------
+    key :
+        Atomic number (int) or symbol (str).
+
+    Returns
+    -------
+        Atomic mass.
+    """
+    return from_key(key).mass

automol-0.0.1/src/automol/element/elements-data.json

@@ -0,0 +1,710 @@
+[
+  {
+    "Z": 1,
+    "A": 1,
+    "symbol": "H",
+    "mass": 1.007825031898
+  },
+  {
+    "Z": 2,
+    "A": 4,
+    "symbol": "He",
+    "mass": 4.00260325413
+  },
+  {
+    "Z": 3,
+    "A": 7,
+    "symbol": "Li",
+    "mass": 7.01600343426
+  },
+  {
+    "Z": 4,
+    "A": 9,
+    "symbol": "Be",
+    "mass": 9.012183062
+  },
+  {
+    "Z": 5,
+    "A": 11,
+    "symbol": "B",
+    "mass": 11.009305166
+  },
+  {
+    "Z": 6,
+    "A": 12,
+    "symbol": "C",
+    "mass": 12.0
+  },
+  {
+    "Z": 7,
+    "A": 14,
+    "symbol": "N",
+    "mass": 14.00307400425
+  },
+  {
+    "Z": 8,
+    "A": 16,
+    "symbol": "O",
+    "mass": 15.99491461926
+  },
+  {
+    "Z": 9,
+    "A": 19,
+    "symbol": "F",
+    "mass": 18.99840316207
+  },
+  {
+    "Z": 10,
+    "A": 20,
+    "symbol": "Ne",
+    "mass": 19.99244017525
+  },
+  {
+    "Z": 11,
+    "A": 23,
+    "symbol": "Na",
+    "mass": 22.98976928195
+  },
+  {
+    "Z": 12,
+    "A": 24,
+    "symbol": "Mg",
+    "mass": 23.985041689
+  },
+  {
+    "Z": 13,
+    "A": 27,
+    "symbol": "Al",
+    "mass": 26.981538408
+  },
+  {
+    "Z": 14,
+    "A": 28,
+    "symbol": "Si",
+    "mass": 27.97692653442
+  },
+  {
+    "Z": 15,
+    "A": 31,
+    "symbol": "P",
+    "mass": 30.97376199768
+  },
+  {
+    "Z": 16,
+    "A": 32,
+    "symbol": "S",
+    "mass": 31.97207117354
+  },
+  {
+    "Z": 17,
+    "A": 35,
+    "symbol": "Cl",
+    "mass": 34.968852694
+  },
+  {
+    "Z": 18,
+    "A": 40,
+    "symbol": "Ar",
+    "mass": 39.96238312204
+  },
+  {
+    "Z": 19,
+    "A": 39,
+    "symbol": "K",
+    "mass": 38.96370648482
+  },
+  {
+    "Z": 20,
+    "A": 40,
+    "symbol": "Ca",
+    "mass": 39.96259085
+  },
+  {
+    "Z": 21,
+    "A": 45,
+    "symbol": "Sc",
+    "mass": 44.955907051
+  },
+  {
+    "Z": 22,
+    "A": 48,
+    "symbol": "Ti",
+    "mass": 47.947940677
+  },
+  {
+    "Z": 23,
+    "A": 51,
+    "symbol": "V",
+    "mass": 50.943957664
+  },
+  {
+    "Z": 24,
+    "A": 52,
+    "symbol": "Cr",
+    "mass": 51.940504714
+  },
+  {
+    "Z": 25,
+    "A": 55,
+    "symbol": "Mn",
+    "mass": 54.93804304
+  },
+  {
+    "Z": 26,
+    "A": 56,
+    "symbol": "Fe",
+    "mass": 55.934935537
+  },
+  {
+    "Z": 27,
+    "A": 59,
+    "symbol": "Co",
+    "mass": 58.933193524
+  },
+  {
+    "Z": 28,
+    "A": 58,
+    "symbol": "Ni",
+    "mass": 57.93534165
+  },
+  {
+    "Z": 29,
+    "A": 63,
+    "symbol": "Cu",
+    "mass": 62.929597119
+  },
+  {
+    "Z": 30,
+    "A": 64,
+    "symbol": "Zn",
+    "mass": 63.929141776
+  },
+  {
+    "Z": 31,
+    "A": 69,
+    "symbol": "Ga",
+    "mass": 68.925573528
+  },
+  {
+    "Z": 32,
+    "A": 74,
+    "symbol": "Ge",
+    "mass": 73.92117776
+  },
+  {
+    "Z": 33,
+    "A": 75,
+    "symbol": "As",
+    "mass": 74.921594562
+  },
+  {
+    "Z": 34,
+    "A": 80,
+    "symbol": "Se",
+    "mass": 79.916521761
+  },
+  {
+    "Z": 35,
+    "A": 79,
+    "symbol": "Br",
+    "mass": 78.918337574
+  },
+  {
+    "Z": 36,
+    "A": 84,
+    "symbol": "Kr",
+    "mass": 83.91149772708
+  },
+  {
+    "Z": 37,
+    "A": 85,
+    "symbol": "Rb",
+    "mass": 84.91178973604
+  },
+  {
+    "Z": 38,
+    "A": 88,
+    "symbol": "Sr",
+    "mass": 87.905612253
+  },
+  {
+    "Z": 39,
+    "A": 89,
+    "symbol": "Y",
+    "mass": 88.905838156
+  },
+  {
+    "Z": 40,
+    "A": 90,
+    "symbol": "Zr",
+    "mass": 89.904698755
+  },
+  {
+    "Z": 41,
+    "A": 93,
+    "symbol": "Nb",
+    "mass": 92.90637317
+  },
+  {
+    "Z": 42,
+    "A": 98,
+    "symbol": "Mo",
+    "mass": 97.905403609
+  },
+  {
+    "Z": 43,
+    "A": 83,
+    "symbol": "Tc",
+    "mass": 82.966377
+  },
+  {
+    "Z": 44,
+    "A": 102,
+    "symbol": "Ru",
+    "mass": 101.904340312
+  },
+  {
+    "Z": 45,
+    "A": 103,
+    "symbol": "Rh",
+    "mass": 102.905494081
+  },
+  {
+    "Z": 46,
+    "A": 106,
+    "symbol": "Pd",
+    "mass": 105.903480287
+  },
+  {
+    "Z": 47,
+    "A": 107,
+    "symbol": "Ag",
+    "mass": 106.905091509
+  },
+  {
+    "Z": 48,
+    "A": 114,
+    "symbol": "Cd",
+    "mass": 113.903364998
+  },
+  {
+    "Z": 49,
+    "A": 115,
+    "symbol": "In",
+    "mass": 114.903878772
+  },
+  {
+    "Z": 50,
+    "A": 120,
+    "symbol": "Sn",
+    "mass": 119.902202557
+  },
+  {
+    "Z": 51,
+    "A": 121,
+    "symbol": "Sb",
+    "mass": 120.903811353
+  },
+  {
+    "Z": 52,
+    "A": 130,
+    "symbol": "Te",
+    "mass": 129.906222745
+  },
+  {
+    "Z": 53,
+    "A": 127,
+    "symbol": "I",
+    "mass": 126.904472592
+  },
+  {
+    "Z": 54,
+    "A": 132,
+    "symbol": "Xe",
+    "mass": 131.90415508346
+  },
+  {
+    "Z": 55,
+    "A": 133,
+    "symbol": "Cs",
+    "mass": 132.905451958
+  },
+  {
+    "Z": 56,
+    "A": 138,
+    "symbol": "Ba",
+    "mass": 137.905247059
+  },
+  {
+    "Z": 57,
+    "A": 139,
+    "symbol": "La",
+    "mass": 138.906362927
+  },
+  {
+    "Z": 58,
+    "A": 140,
+    "symbol": "Ce",
+    "mass": 139.905448433
+  },
+  {
+    "Z": 59,
+    "A": 141,
+    "symbol": "Pr",
+    "mass": 140.907659604
+  },
+  {
+    "Z": 60,
+    "A": 142,
+    "symbol": "Nd",
+    "mass": 141.907728824
+  },
+  {
+    "Z": 61,
+    "A": 126,
+    "symbol": "Pm",
+    "mass": 125.957327
+  },
+  {
+    "Z": 62,
+    "A": 152,
+    "symbol": "Sm",
+    "mass": 151.919738646
+  },
+  {
+    "Z": 63,
+    "A": 153,
+    "symbol": "Eu",
+    "mass": 152.921236789
+  },
+  {
+    "Z": 64,
+    "A": 158,
+    "symbol": "Gd",
+    "mass": 157.9241112
+  },
+  {
+    "Z": 65,
+    "A": 159,
+    "symbol": "Tb",
+    "mass": 158.925353707
+  },
+  {
+    "Z": 66,
+    "A": 164,
+    "symbol": "Dy",
+    "mass": 163.929180819
+  },
+  {
+    "Z": 67,
+    "A": 165,
+    "symbol": "Ho",
+    "mass": 164.930329116
+  },
+  {
+    "Z": 68,
+    "A": 166,
+    "symbol": "Er",
+    "mass": 165.930301067
+  },
+  {
+    "Z": 69,
+    "A": 169,
+    "symbol": "Tm",
+    "mass": 168.934218956
+  },
+  {
+    "Z": 70,
+    "A": 174,
+    "symbol": "Yb",
+    "mass": 173.938867545
+  },
+  {
+    "Z": 71,
+    "A": 175,
+    "symbol": "Lu",
+    "mass": 174.940777211
+  },
+  {
+    "Z": 72,
+    "A": 180,
+    "symbol": "Hf",
+    "mass": 179.946559537
+  },
+  {
+    "Z": 73,
+    "A": 181,
+    "symbol": "Ta",
+    "mass": 180.947998528
+  },
+  {
+    "Z": 74,
+    "A": 184,
+    "symbol": "W",
+    "mass": 183.95093318
+  },
+  {
+    "Z": 75,
+    "A": 187,
+    "symbol": "Re",
+    "mass": 186.955752217
+  },
+  {
+    "Z": 76,
+    "A": 192,
+    "symbol": "Os",
+    "mass": 191.961478765
+  },
+  {
+    "Z": 77,
+    "A": 193,
+    "symbol": "Ir",
+    "mass": 192.962923753
+  },
+  {
+    "Z": 78,
+    "A": 195,
+    "symbol": "Pt",
+    "mass": 194.964794325
+  },
+  {
+    "Z": 79,
+    "A": 197,
+    "symbol": "Au",
+    "mass": 196.966570103
+  },
+  {
+    "Z": 80,
+    "A": 202,
+    "symbol": "Hg",
+    "mass": 201.970643604
+  },
+  {
+    "Z": 81,
+    "A": 205,
+    "symbol": "Tl",
+    "mass": 204.974427318
+  },
+  {
+    "Z": 82,
+    "A": 208,
+    "symbol": "Pb",
+    "mass": 207.976652005
+  },
+  {
+    "Z": 83,
+    "A": 209,
+    "symbol": "Bi",
+    "mass": 208.980398599
+  },
+  {
+    "Z": 84,
+    "A": 186,
+    "symbol": "Po",
+    "mass": 186.004403174
+  },
+  {
+    "Z": 85,
+    "A": 191,
+    "symbol": "At",
+    "mass": 191.004148081
+  },
+  {
+    "Z": 86,
+    "A": 193,
+    "symbol": "Rn",
+    "mass": 193.009707973
+  },
+  {
+    "Z": 87,
+    "A": 197,
+    "symbol": "Fr",
+    "mass": 197.011008086
+  },
+  {
+    "Z": 88,
+    "A": 201,
+    "symbol": "Ra",
+    "mass": 201.012814699
+  },
+  {
+    "Z": 89,
+    "A": 205,
+    "symbol": "Ac",
+    "mass": 205.015144152
+  },
+  {
+    "Z": 90,
+    "A": 232,
+    "symbol": "Th",
+    "mass": 232.038053606
+  },
+  {
+    "Z": 91,
+    "A": 231,
+    "symbol": "Pa",
+    "mass": 231.0358825
+  },
+  {
+    "Z": 92,
+    "A": 238,
+    "symbol": "U",
+    "mass": 238.050786936
+  },
+  {
+    "Z": 93,
+    "A": 219,
+    "symbol": "Np",
+    "mass": 219.031601865
+  },
+  {
+    "Z": 94,
+    "A": 221,
+    "symbol": "Pu",
+    "mass": 221.038572
+  },
+  {
+    "Z": 95,
+    "A": 223,
+    "symbol": "Am",
+    "mass": 223.04584
+  },
+  {
+    "Z": 96,
+    "A": 231,
+    "symbol": "Cm",
+    "mass": 231.050746
+  },
+  {
+    "Z": 97,
+    "A": 233,
+    "symbol": "Bk",
+    "mass": 233.056652
+  },
+  {
+    "Z": 98,
+    "A": 237,
+    "symbol": "Cf",
+    "mass": 237.062199272
+  },
+  {
+    "Z": 99,
+    "A": 239,
+    "symbol": "Es",
+    "mass": 239.06831
+  },
+  {
+    "Z": 100,
+    "A": 241,
+    "symbol": "Fm",
+    "mass": 241.074311
+  },
+  {
+    "Z": 101,
+    "A": 244,
+    "symbol": "Md",
+    "mass": 244.081157
+  },
+  {
+    "Z": 102,
+    "A": 248,
+    "symbol": "No",
+    "mass": 248.086623
+  },
+  {
+    "Z": 103,
+    "A": 251,
+    "symbol": "Lr",
+    "mass": 251.094289
+  },
+  {
+    "Z": 104,
+    "A": 253,
+    "symbol": "Rf",
+    "mass": 253.100528
+  },
+  {
+    "Z": 105,
+    "A": 255,
+    "symbol": "Db",
+    "mass": 255.106919
+  },
+  {
+    "Z": 106,
+    "A": 258,
+    "symbol": "Sg",
+    "mass": 258.11304
+  },
+  {
+    "Z": 107,
+    "A": 260,
+    "symbol": "Bh",
+    "mass": 260.121443
+  },
+  {
+    "Z": 108,
+    "A": 263,
+    "symbol": "Hs",
+    "mass": 263.128479
+  },
+  {
+    "Z": 109,
+    "A": 265,
+    "symbol": "Mt",
+    "mass": 265.135937
+  },
+  {
+    "Z": 110,
+    "A": 267,
+    "symbol": "Ds",
+    "mass": 267.143726
+  },
+  {
+    "Z": 111,
+    "A": 272,
+    "symbol": "Rg",
+    "mass": 272.153273
+  },
+  {
+    "Z": 112,
+    "A": 276,
+    "symbol": "Cn",
+    "mass": 276.161418
+  },
+  {
+    "Z": 113,
+    "A": 278,
+    "symbol": "Nh",
+    "mass": 278.170725
+  },
+  {
+    "Z": 114,
+    "A": 284,
+    "symbol": "Fl",
+    "mass": 284.181192
+  },
+  {
+    "Z": 115,
+    "A": 287,
+    "symbol": "Mc",
+    "mass": 287.19082
+  },
+  {
+    "Z": 116,
+    "A": 289,
+    "symbol": "Lv",
+    "mass": 289.198023
+  },
+  {
+    "Z": 117,
+    "A": 291,
+    "symbol": "Ts",
+    "mass": 291.205748
+  },
+  {
+    "Z": 118,
+    "A": 293,
+    "symbol": "Og",
+    "mass": 293.213423
+  }
+]

automol-0.0.1/src/automol/geom.py

@@ -0,0 +1,80 @@
+"""Molecular geometries."""
+
+import numpy as np
+from pydantic import BaseModel, ConfigDict
+
+from . import element, rd
+from .types import CoordinatesField, FloatArray
+
+
+class Geometry(BaseModel):
+    """
+    Molecular geometry.
+
+    Parameters
+    ----------
+    symbols : list[str]
+        Atomic symbols in order (e.g., ``["H", "O", "H"]``).
+        The length of ``symbols`` must match the number of atoms.
+
+    coordinates : CoordinatesField
+        Cartesian coordinates of the atoms.
+        Shape is ``(len(symbols), 3)`` and the ordering corresponds to ``symbols``.
+        Units are assumed to be **angstroms** unless otherwise specified.
+
+    charge : int, optional
+        Total molecular charge.
+        Default is ``0``.
+
+    spin : int, optional
+        Total spin multiplicity or spin quantum number (depending on convention).
+        Default is ``0``.
+    """
+
+    symbols: list[str]
+    coordinates: CoordinatesField
+    charge: int = 0
+    spin: int = 0
+
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+
+def from_rdkit_molecule(mol: rd.Mol) -> Geometry:
+    """
+    Generate geometry from RDKit molecule.
+
+    Parameters
+    ----------
+    mol
+        RDKit molecule.
+
+    Returns
+    -------
+        Geometry.
+    """
+    if not rd.mol.has_coordinates(mol):
+        mol = rd.mol.add_coordinates(mol)
+
+    return Geometry(
+        symbols=rd.mol.symbols(mol),
+        coordinates=rd.mol.coordinates(mol),
+        charge=rd.mol.charge(mol),
+        spin=rd.mol.spin(mol),
+    )
+
+
+def center_of_mass(geo: Geometry) -> FloatArray:
+    """
+    Calculate geometry center of mass.
+
+    Parameters
+    ----------
+        Geometry.
+
+    Returns
+    -------
+        Center of mass coordinates.
+    """
+    masses = list(map(element.mass, geo.symbols))
+    coords = geo.coordinates
+    return np.sum(np.reshape(masses, (-1, 1)) * coords, axis=0) / np.sum(masses)

automol-0.0.1/src/automol/rd/__init__.py

@@ -0,0 +1,6 @@
+"""RDKit interface."""
+
+from . import mol
+from .mol import Mol
+
+__all__ = ["mol", "Mol"]

automol-0.0.1/src/automol/rd/mol.py

@@ -0,0 +1,153 @@
+"""RDKit molecule."""
+
+import numpy as np
+from rdkit import Chem
+from rdkit.Chem import Descriptors, Mol
+from rdkit.Chem.rdDistGeom import EmbedMolecule
+
+from ..types import FloatArray
+
+
+# Generators
+def from_smiles(smi: str, *, with_coords: bool = False) -> Mol:
+    """
+    Get RDKit molecule from SMILES string.
+
+    Parameters
+    ----------
+    smi
+        SMILES string.
+
+    with_coords, optional
+        If `True`, generate 3D coordinates for the molecule.
+        If `False` (default), return a molecule without coordinates.
+
+    Returns
+    -------
+        RDKit molecule.
+    """
+    mol = Chem.MolFromSmiles(smi)
+    mol = Chem.AddHs(mol)
+    if with_coords:
+        add_coordinates(mol, in_place=True)
+    return mol
+
+
+# Properties
+def symbols(mol: Mol) -> list[str]:
+    """
+    Get atomic symbols.
+
+    Parameters
+    ----------
+    mol
+        RDKit molecule object.
+
+    Returns
+    -------
+        List of atomic symbols.
+    """
+    return [a.GetSymbol() for a in mol.GetAtoms()]
+
+
+def coordinates(mol: Mol) -> FloatArray:
+    """
+    Get atom coordinates.
+
+    Parameters
+    ----------
+    mol
+        RDKit molecule object.
+
+    Returns
+    -------
+        Atomic coordinates as (N, 3) numpy array.
+
+    Raises
+    ------
+    ValueError
+        If the molecule has no coordinates.
+    """
+    if not has_coordinates(mol):
+        msg = "Molecule has no coordinates. Did you forget to add them?"
+        raise ValueError(msg)
+
+    natms = mol.GetNumAtoms()
+    conf = mol.GetConformer()
+    coords = [conf.GetAtomPosition(i) for i in range(natms)]
+    return np.array(coords, dtype=np.float64)
+
+
+def charge(mol: Mol) -> int:
+    """
+    Get molecular charge.
+
+    Parameters
+    ----------
+    mol
+        RDKit molecule object.
+
+    Returns
+    -------
+        Molecular charge as an integer.
+    """
+    return Chem.GetFormalCharge(mol)
+
+
+def spin(mol: Mol) -> int:
+    """
+    Get molecular spin (number of unpaired electrons).
+
+    Parameters
+    ----------
+    mol
+        RDKit molecule object.
+
+    Returns
+    -------
+        Number of unpaired electrons as an integer.
+    """
+    return Descriptors.NumRadicalElectrons(mol)
+
+
+# Boolean properties
+def has_coordinates(mol: Mol) -> bool:
+    """
+    Check if coordinates have been added.
+
+    Parameters
+    ----------
+    mol
+        RDKit molecule object.
+
+    Returns
+    -------
+        `True` if the molecule has coordinates, False otherwise.
+    """
+    return bool(mol.GetNumConformers())
+
+
+# Transformations
+def add_coordinates(mol: Mol, *, in_place: bool = False) -> Mol:
+    """
+    Add coordinates, if missing.
+
+    Parameters
+    ----------
+    mol
+        RDKit molecule object.
+    in_place, optional
+        If `True`, modify the molecule in place.
+        If `False` (default), return a new molecule.
+
+    Returns
+    -------
+        RDKit molecule object with coordinates.
+        (Unmodified if it already had coordinates.)
+    """
+    if has_coordinates(mol):
+        return mol
+
+    mol = mol if in_place else Mol(mol)
+    EmbedMolecule(mol)
+    return mol

automol-0.0.1/src/automol/smiles.py

@@ -0,0 +1,20 @@
+"""SMILES strings."""
+
+from . import geom, rd
+from .geom import Geometry
+
+
+def geometry(smi: str) -> Geometry:
+    """Get the geometry corresponding to a SMILES string.
+
+    Parameters
+    ----------
+    smi : str
+        Input SMILES string.
+
+    Returns
+    -------
+        Corresponding geometry.
+    """
+    mol = rd.mol.from_smiles(smi, with_coords=True)
+    return geom.from_rdkit_molecule(mol)

automol-0.0.1/src/automol/types/__init__.py

@@ -0,0 +1,6 @@
+"""Types."""
+
+from .core import FloatArray
+from .pydantic import CoordinatesField, FloatArrayField
+
+__all__ = ["FloatArray", "CoordinatesField", "FloatArrayField"]

automol-0.0.1/src/automol/types/core.py

@@ -0,0 +1,6 @@
+"""Core types."""
+
+import numpy as np
+from numpy import typing as npt
+
+FloatArray = npt.NDArray[np.float64]

automol-0.0.1/src/automol/types/pydantic.py

@@ -0,0 +1,44 @@
+"""Pydantic types."""
+
+from typing import Annotated
+
+import numpy as np
+from numpy import typing as npt
+from pydantic import BeforeValidator, PlainSerializer
+from pydantic.functional_validators import SkipValidation
+
+from .core import FloatArray
+
+
+# Float array field
+def _float_array_validator(obj: object) -> FloatArray:
+    return np.asarray(obj, dtype=np.float64)
+
+
+def _float_array_serializer(arr: FloatArray) -> list:
+    return arr.tolist()
+
+
+FloatArrayField = Annotated[
+    SkipValidation[npt.ArrayLike],
+    BeforeValidator(_float_array_validator),
+    PlainSerializer(_float_array_serializer, return_type=list),
+]
+
+
+# Coordinates field
+def _coordinates_validator(obj: object) -> FloatArray:
+    arr = _float_array_validator(obj)
+
+    if arr.ndim != 2 or arr.shape[-1] != 3:  # noqa: PLR2004
+        msg = f"Expected array of shape (N, 3) but got {arr.shape}."
+        raise ValueError(msg)
+
+    return arr
+
+
+CoordinatesField = Annotated[
+    SkipValidation[npt.ArrayLike],
+    BeforeValidator(_coordinates_validator),
+    PlainSerializer(_float_array_serializer, return_type=list),
+]