atomecon 0.1.0__tar.gz

atomecon-0.1.0/PKG-INFO

@@ -0,0 +1,196 @@
+Metadata-Version: 2.4
+Name: atomecon
+Version: 0.1.0
+Summary: Lightweight green chemistry metrics (atom economy, E-factor, yield) from plain chemical formulas - no RDKit, no SMILES.
+Author-email: Your Name <you@example.com>
+License: MIT
+Project-URL: Homepage, https://github.com/YOUR_USERNAME/atomecon
+Project-URL: Issues, https://github.com/YOUR_USERNAME/atomecon/issues
+Keywords: chemistry,green-chemistry,atom-economy,stoichiometry,e-factor
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Intended Audience :: Education
+Classifier: Topic :: Scientific/Engineering :: Chemistry
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+
+# atomecon
+
+🧪 **[Try it live in your browser](https://atomecon.streamlit.app/)** - no install needed.
+
+Lightweight green chemistry metrics - atom economy, theoretical yield, percent yield, E-factor, and automatic equation balancing - computed from **plain chemical formulas**. No RDKit, no SMILES, no heavy dependencies.
+
+## Who this is for
+
+- Chemistry students taking green chemistry coursework, tired of redoing molar-mass arithmetic by hand for every reaction
+- Anyone comparing multiple synthesis routes for the same product, who wants to score them programmatically instead of recalculating each one manually
+- Developers who want atom economy and equation balancing without installing RDKit or learning SMILES notation
+
+## Why this exists
+
+Existing chemistry packages either don't cover green chemistry metrics at all (they focus on general stoichiometry), or require RDKit and SMILES notation to calculate even a single metric like atom economy. `atomecon` bundles the standard metrics together, balances equations automatically, takes formulas the way you'd write them in a chemistry class (`"C2H5OH"`, not `"CCO"`), and has zero dependencies.
+
+## Try it without installing anything
+
+**[atomecon.streamlit.app](https://atomecon.streamlit.app/)** - type in a reaction's formulas, get it balanced and analyzed instantly in your browser.
+
+## Install (to use in your own Python code)
+
+```bash
+pip install -e .
+```
+
+Or install directly from this repo:
+```bash
+pip install git+https://github.com/JvenDeepak0203/atomecon.git
+```
+
+## Core concepts
+
+- **Atom economy** is *theoretical* - it only depends on the balanced equation and molar masses. It's always computable, with no lab data.
+- **Theoretical yield**, **percent yield**, and **E-factor** are *experimental* - they depend on the real masses of reactants you used and the real mass of product you isolated. These vary run to run.
+
+`atomecon` keeps this distinction explicit: `atom_economy()` takes no arguments beyond the reaction itself, while `e_factor()` and `percent_yield()` require you to supply real measured masses.
+
+## Quick start - the one-line version
+
+```python
+from atomecon import analyze
+
+analyze(["CH4", "O2"], ["CO2", "H2O"], desired_product="CO2")
+```
+Balances the equation automatically and prints a full report - no coefficients, no separate method calls needed.
+
+## Full walkthrough
+
+```python
+from atomecon import Reaction
+
+# Aspirin synthesis: salicylic acid + acetic anhydride -> aspirin + acetic acid
+rxn = Reaction(
+    reactants={"C7H6O3": 1, "C4H6O3": 1},
+    products={"C9H8O4": 1, "C2H4O2": 1},
+    desired_product="C9H8O4",
+)
+
+print(rxn.atom_economy())
+# 75.0  (theoretical - no lab data needed)
+
+masses = {"C7H6O3": 5.0, "C4H6O3": 5.0}
+print(rxn.theoretical_yield_g(masses))
+print(rxn.percent_yield(masses, actual_yield_g=4.2))
+print(rxn.e_factor(masses, actual_yield_g=4.2))
+print(rxn.green_grade(masses, actual_yield_g=4.2))
+
+print(rxn.summary_table(reactant_masses_g=masses, actual_yield_g=4.2))
+```
+
+## Automatic equation balancing
+
+Don't want to work out coefficients yourself? Just give formulas:
+
+```python
+from atomecon import Reaction
+
+rxn = Reaction.auto(["N2", "H2"], ["NH3"], desired_product="NH3")
+print(rxn)
+# <Reaction N2 + 3H2 -> 2NH3>
+```
+
+This uses real linear algebra (Gaussian elimination over exact fractions) to solve for the smallest whole-number coefficients - the same process you'd do by hand, automated.
+
+**Known limitation:** a small number of equations have more than one valid balancing ratio (a genuine mathematical ambiguity, not a bug) and will raise a clear error asking you to specify coefficients manually instead of guessing.
+
+## Learning mode: see the calculation, not just the answer
+
+```python
+print(rxn.explain_atom_economy())
+```
+
+## Green grade: one number to compare reactions at a glance
+
+```python
+print(rxn.green_grade(masses, actual_yield_g=4.2))
+# B  (Atom economy: 75% | E-factor: 1.4)
+```
+
+A simple, transparent scoring rule (not a scientific standard) - combines atom economy and E-factor into a single A-F grade.
+
+## Comparing multiple reactions
+
+```python
+from atomecon import Reaction, ReactionLog
+
+log = ReactionLog()
+log.add("Aspirin route", rxn, reactant_masses_g=masses, actual_yield_g=4.2)
+
+combustion = Reaction.auto(["CH4", "O2"], ["CO2", "H2O"], desired_product="CO2")
+log.add("Methane combustion", combustion)  # lab data is optional per entry
+
+print(log.comparison_table())
+```
+Builds a table sorted by atom economy (greenest first). `ReactionLog` is in-memory only - it resets each time your program runs.
+
+## Formula plausibility checking
+
+Before balancing, `atomecon` can flag formulas that are chemically impossible using valence-parity math (every bond connects exactly 2 atoms, so a molecule's total valence must be even):
+
+```python
+from atomecon import is_formula_plausible
+
+is_formula_plausible("C8H18")   # True  (real octane)
+is_formula_plausible("C8H23")   # False (impossible - odd total valence)
+is_formula_plausible("Fe2O3")   # True  (iron has variable valence - not checked, benefit of the doubt)
+```
+
+**Important limitation:** this can only rule out formulas as impossible - it cannot prove a formula is real, and it deliberately skips elements with variable real-world valence (iron, sulfur, phosphorus, nitrogen, most transition metals) rather than risk a wrong answer. This is a long way from full molecular validity checking (which is what RDKit does using real molecular structure) - it's one useful mathematical shortcut, not a replacement for it.
+
+## Formula syntax
+
+Supports condensed formulas and nested parentheses:
+
+```python
+from atomecon import parse_formula, molar_mass
+
+parse_formula("Ca(OH)2")       # {"Ca": 1, "O": 2, "H": 2}
+parse_formula("Fe3(Fe(CN)6)2") # {"Fe": 5, "C": 12, "N": 12}
+molar_mass("C6H12O6")          # 180.156
+```
+
+## Reaction balance checking
+
+`Reaction` verifies the equation is atom-balanced on construction and raises a clear error if it isn't (atom economy is not meaningful for an unbalanced equation). Pass `allow_unbalanced=True` to override.
+
+## What this library does NOT do (known scope limits)
+
+Being upfront about the boundaries:
+- **Does not verify a formula represents a real molecule** beyond the basic valence-parity check above - no bonding/structure model like RDKit
+- **Does not verify a reaction is chemically real** - if you give it atom-balanced but chemically implausible reactants/products (e.g. a reaction that wouldn't actually occur), it will still calculate metrics for it. Verifying real reaction mechanisms is a much larger problem (closer to quantum chemistry / reaction databases) that's out of scope here.
+- **No charge/ionic support** - formulas are tracked by atoms only, not electric charge, so redox half-reactions and charged species aren't supported
+
+## Try the demo script
+
+```bash
+python demo.py
+```
+Runs through every feature of the library end to end.
+
+## Web app
+
+The `app.py` file is a Streamlit interface to the library - see it live at [atomecon.streamlit.app](https://atomecon.streamlit.app/), or run it yourself:
+```bash
+pip install streamlit
+streamlit run app.py
+```
+
+## Running tests
+
+```bash
+pip install pytest
+pytest
+```
+
+## License
+
+MIT

atomecon-0.1.0/README.md

@@ -0,0 +1,179 @@
+# atomecon
+
+🧪 **[Try it live in your browser](https://atomecon.streamlit.app/)** - no install needed.
+
+Lightweight green chemistry metrics - atom economy, theoretical yield, percent yield, E-factor, and automatic equation balancing - computed from **plain chemical formulas**. No RDKit, no SMILES, no heavy dependencies.
+
+## Who this is for
+
+- Chemistry students taking green chemistry coursework, tired of redoing molar-mass arithmetic by hand for every reaction
+- Anyone comparing multiple synthesis routes for the same product, who wants to score them programmatically instead of recalculating each one manually
+- Developers who want atom economy and equation balancing without installing RDKit or learning SMILES notation
+
+## Why this exists
+
+Existing chemistry packages either don't cover green chemistry metrics at all (they focus on general stoichiometry), or require RDKit and SMILES notation to calculate even a single metric like atom economy. `atomecon` bundles the standard metrics together, balances equations automatically, takes formulas the way you'd write them in a chemistry class (`"C2H5OH"`, not `"CCO"`), and has zero dependencies.
+
+## Try it without installing anything
+
+**[atomecon.streamlit.app](https://atomecon.streamlit.app/)** - type in a reaction's formulas, get it balanced and analyzed instantly in your browser.
+
+## Install (to use in your own Python code)
+
+```bash
+pip install -e .
+```
+
+Or install directly from this repo:
+```bash
+pip install git+https://github.com/JvenDeepak0203/atomecon.git
+```
+
+## Core concepts
+
+- **Atom economy** is *theoretical* - it only depends on the balanced equation and molar masses. It's always computable, with no lab data.
+- **Theoretical yield**, **percent yield**, and **E-factor** are *experimental* - they depend on the real masses of reactants you used and the real mass of product you isolated. These vary run to run.
+
+`atomecon` keeps this distinction explicit: `atom_economy()` takes no arguments beyond the reaction itself, while `e_factor()` and `percent_yield()` require you to supply real measured masses.
+
+## Quick start - the one-line version
+
+```python
+from atomecon import analyze
+
+analyze(["CH4", "O2"], ["CO2", "H2O"], desired_product="CO2")
+```
+Balances the equation automatically and prints a full report - no coefficients, no separate method calls needed.
+
+## Full walkthrough
+
+```python
+from atomecon import Reaction
+
+# Aspirin synthesis: salicylic acid + acetic anhydride -> aspirin + acetic acid
+rxn = Reaction(
+    reactants={"C7H6O3": 1, "C4H6O3": 1},
+    products={"C9H8O4": 1, "C2H4O2": 1},
+    desired_product="C9H8O4",
+)
+
+print(rxn.atom_economy())
+# 75.0  (theoretical - no lab data needed)
+
+masses = {"C7H6O3": 5.0, "C4H6O3": 5.0}
+print(rxn.theoretical_yield_g(masses))
+print(rxn.percent_yield(masses, actual_yield_g=4.2))
+print(rxn.e_factor(masses, actual_yield_g=4.2))
+print(rxn.green_grade(masses, actual_yield_g=4.2))
+
+print(rxn.summary_table(reactant_masses_g=masses, actual_yield_g=4.2))
+```
+
+## Automatic equation balancing
+
+Don't want to work out coefficients yourself? Just give formulas:
+
+```python
+from atomecon import Reaction
+
+rxn = Reaction.auto(["N2", "H2"], ["NH3"], desired_product="NH3")
+print(rxn)
+# <Reaction N2 + 3H2 -> 2NH3>
+```
+
+This uses real linear algebra (Gaussian elimination over exact fractions) to solve for the smallest whole-number coefficients - the same process you'd do by hand, automated.
+
+**Known limitation:** a small number of equations have more than one valid balancing ratio (a genuine mathematical ambiguity, not a bug) and will raise a clear error asking you to specify coefficients manually instead of guessing.
+
+## Learning mode: see the calculation, not just the answer
+
+```python
+print(rxn.explain_atom_economy())
+```
+
+## Green grade: one number to compare reactions at a glance
+
+```python
+print(rxn.green_grade(masses, actual_yield_g=4.2))
+# B  (Atom economy: 75% | E-factor: 1.4)
+```
+
+A simple, transparent scoring rule (not a scientific standard) - combines atom economy and E-factor into a single A-F grade.
+
+## Comparing multiple reactions
+
+```python
+from atomecon import Reaction, ReactionLog
+
+log = ReactionLog()
+log.add("Aspirin route", rxn, reactant_masses_g=masses, actual_yield_g=4.2)
+
+combustion = Reaction.auto(["CH4", "O2"], ["CO2", "H2O"], desired_product="CO2")
+log.add("Methane combustion", combustion)  # lab data is optional per entry
+
+print(log.comparison_table())
+```
+Builds a table sorted by atom economy (greenest first). `ReactionLog` is in-memory only - it resets each time your program runs.
+
+## Formula plausibility checking
+
+Before balancing, `atomecon` can flag formulas that are chemically impossible using valence-parity math (every bond connects exactly 2 atoms, so a molecule's total valence must be even):
+
+```python
+from atomecon import is_formula_plausible
+
+is_formula_plausible("C8H18")   # True  (real octane)
+is_formula_plausible("C8H23")   # False (impossible - odd total valence)
+is_formula_plausible("Fe2O3")   # True  (iron has variable valence - not checked, benefit of the doubt)
+```
+
+**Important limitation:** this can only rule out formulas as impossible - it cannot prove a formula is real, and it deliberately skips elements with variable real-world valence (iron, sulfur, phosphorus, nitrogen, most transition metals) rather than risk a wrong answer. This is a long way from full molecular validity checking (which is what RDKit does using real molecular structure) - it's one useful mathematical shortcut, not a replacement for it.
+
+## Formula syntax
+
+Supports condensed formulas and nested parentheses:
+
+```python
+from atomecon import parse_formula, molar_mass
+
+parse_formula("Ca(OH)2")       # {"Ca": 1, "O": 2, "H": 2}
+parse_formula("Fe3(Fe(CN)6)2") # {"Fe": 5, "C": 12, "N": 12}
+molar_mass("C6H12O6")          # 180.156
+```
+
+## Reaction balance checking
+
+`Reaction` verifies the equation is atom-balanced on construction and raises a clear error if it isn't (atom economy is not meaningful for an unbalanced equation). Pass `allow_unbalanced=True` to override.
+
+## What this library does NOT do (known scope limits)
+
+Being upfront about the boundaries:
+- **Does not verify a formula represents a real molecule** beyond the basic valence-parity check above - no bonding/structure model like RDKit
+- **Does not verify a reaction is chemically real** - if you give it atom-balanced but chemically implausible reactants/products (e.g. a reaction that wouldn't actually occur), it will still calculate metrics for it. Verifying real reaction mechanisms is a much larger problem (closer to quantum chemistry / reaction databases) that's out of scope here.
+- **No charge/ionic support** - formulas are tracked by atoms only, not electric charge, so redox half-reactions and charged species aren't supported
+
+## Try the demo script
+
+```bash
+python demo.py
+```
+Runs through every feature of the library end to end.
+
+## Web app
+
+The `app.py` file is a Streamlit interface to the library - see it live at [atomecon.streamlit.app](https://atomecon.streamlit.app/), or run it yourself:
+```bash
+pip install streamlit
+streamlit run app.py
+```
+
+## Running tests
+
+```bash
+pip install pytest
+pytest
+```
+
+## License
+
+MIT

atomecon-0.1.0/pyproject.toml

@@ -0,0 +1,29 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "atomecon"
+version = "0.1.0"
+description = "Lightweight green chemistry metrics (atom economy, E-factor, yield) from plain chemical formulas - no RDKit, no SMILES."
+readme = "README.md"
+requires-python = ">=3.8"
+license = { text = "MIT" }
+authors = [
+    { name = "Your Name", email = "you@example.com" }
+]
+keywords = ["chemistry", "green-chemistry", "atom-economy", "stoichiometry", "e-factor"]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Intended Audience :: Education",
+    "Topic :: Scientific/Engineering :: Chemistry",
+]
+
+[project.urls]
+Homepage = "https://github.com/YOUR_USERNAME/atomecon"
+Issues = "https://github.com/YOUR_USERNAME/atomecon/issues"
+
+[tool.setuptools.packages.find]
+where = ["src"]

atomecon-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

atomecon-0.1.0/src/atomecon/__init__.py

@@ -0,0 +1,24 @@
+"""
+atomecon - lightweight green chemistry metrics from plain chemical formulas.
+
+No RDKit, no SMILES - just formulas and molar masses.
+"""
+
+from .formula import parse_formula, molar_mass
+from .reaction import Reaction
+from .reaction_log import ReactionLog
+from .balance import balance_equation
+from .convenience import analyze
+from .valence import is_formula_plausible, explain_formula_plausibility
+
+__all__ = [
+    "parse_formula",
+    "molar_mass",
+    "Reaction",
+    "ReactionLog",
+    "balance_equation",
+    "analyze",
+    "is_formula_plausible",
+    "explain_formula_plausibility",
+]
+__version__ = "0.1.0"

atomecon-0.1.0/src/atomecon/balance.py

@@ -0,0 +1,163 @@
+"""
+Automatic chemical equation balancing.
+
+Given just the reactant and product formulas (no coefficients), this
+works out the smallest whole-number coefficients that balance the
+equation - the same thing you'd do by hand in intro chemistry, done
+here with linear algebra instead of trial and error.
+
+HOW IT WORKS (high level):
+Every element must appear in equal total amounts on both sides. That
+gives one equation per element, with the coefficients as the unknowns.
+Solving that system of equations (its "null space") gives the ratio of
+coefficients; scaling that ratio up to whole numbers gives the answer.
+
+This file is more mathematically advanced than the rest of the library
+(it uses exact fractions and row reduction). If you're reading through
+line by line, it's fine to treat this as "trusted machinery" - the way
+you'd use a library function without re-deriving how it works - rather
+than trace every line the way we did with formula.py.
+"""
+
+import math
+from fractions import Fraction
+from typing import Dict, List, Tuple
+
+from .formula import parse_formula
+
+
+def balance_equation(
+    reactant_formulas: List[str], product_formulas: List[str]
+) -> Tuple[Dict[str, int], Dict[str, int]]:
+    species = reactant_formulas + product_formulas
+    num_species = len(species)
+
+    element_counts_per_species = []
+    all_elements = []
+    for formula in species:
+        counts = parse_formula(formula)
+        element_counts_per_species.append(counts)
+        for element in counts:
+            if element not in all_elements:
+                all_elements.append(element)
+
+    num_reactants = len(reactant_formulas)
+
+    matrix = []
+    for element in all_elements:
+        row = []
+        for i, counts in enumerate(element_counts_per_species):
+            count = counts.get(element, 0)
+            if i >= num_reactants:
+                count = -count
+            row.append(Fraction(count))
+        matrix.append(row)
+
+    coefficients = _solve_null_space(matrix, num_species)
+
+    reactant_coeffs = {}
+    for i in range(num_reactants):
+        reactant_coeffs[reactant_formulas[i]] = coefficients[i]
+
+    product_coeffs = {}
+    for i in range(num_reactants, num_species):
+        product_index = i - num_reactants
+        product_coeffs[product_formulas[product_index]] = coefficients[i]
+
+    return reactant_coeffs, product_coeffs
+
+
+def _solve_null_space(matrix, num_species):
+    num_rows = len(matrix)
+
+    working = []
+    for row in matrix:
+        working.append(list(row))
+
+    pivot_columns = []
+    current_row = 0
+
+    for col in range(num_species):
+        pivot_row = None
+        for r in range(current_row, num_rows):
+            if working[r][col] != 0:
+                pivot_row = r
+                break
+
+        if pivot_row is None:
+            continue
+
+        working[current_row], working[pivot_row] = working[pivot_row], working[current_row]
+
+        pivot_value = working[current_row][col]
+        for c in range(num_species):
+            working[current_row][c] = working[current_row][c] / pivot_value
+
+        for r in range(num_rows):
+            if r != current_row and working[r][col] != 0:
+                factor = working[r][col]
+                for c in range(num_species):
+                    working[r][c] = working[r][c] - factor * working[current_row][c]
+
+        pivot_columns.append(col)
+        current_row += 1
+        if current_row == num_rows:
+            break
+
+    free_columns = []
+    for col in range(num_species):
+        if col not in pivot_columns:
+            free_columns.append(col)
+
+    if len(free_columns) != 1:
+        raise ValueError(
+            "Could not automatically balance this equation (expected exactly "
+            "one degree of freedom, found "
+            f"{len(free_columns)}). Try specifying coefficients manually "
+            "with Reaction(reactants={...}, products={...})."
+        )
+
+    free_col = free_columns[0]
+
+    values = [Fraction(0)] * num_species
+    values[free_col] = Fraction(1)
+
+    for i, col in enumerate(pivot_columns):
+        values[col] = -working[i][free_col]
+
+    lcm_of_denominators = 1
+    for v in values:
+        lcm_of_denominators = _lcm(lcm_of_denominators, v.denominator)
+
+    whole_numbers = []
+    for v in values:
+        whole_numbers.append(int(v * lcm_of_denominators))
+
+    all_non_positive = True
+    for w in whole_numbers:
+        if w > 0:
+            all_non_positive = False
+    if all_non_positive:
+        whole_numbers = [-w for w in whole_numbers]
+
+    for w in whole_numbers:
+        if w <= 0:
+            raise ValueError(
+                "Could not automatically balance this equation into all "
+                "positive coefficients. Try specifying coefficients "
+                "manually with Reaction(reactants={...}, products={...})."
+            )
+
+    overall_gcd = whole_numbers[0]
+    for w in whole_numbers[1:]:
+        overall_gcd = math.gcd(overall_gcd, w)
+
+    simplified = []
+    for w in whole_numbers:
+        simplified.append(w // overall_gcd)
+
+    return simplified
+
+
+def _lcm(a, b):
+    return a * b // math.gcd(a, b)

atomecon-0.1.0/src/atomecon/convenience.py

@@ -0,0 +1,27 @@
+"""
+One-call convenience function for the common case: you just have
+formulas (no coefficients) and, optionally, real lab masses, and you
+want the full picture without creating objects and calling several
+methods yourself.
+"""
+
+from typing import Dict, List, Optional
+
+from .reaction import Reaction
+
+
+def analyze(
+    reactants: List[str],
+    products: List[str],
+    desired_product: str,
+    reactant_masses_g: Optional[Dict[str, float]] = None,
+    actual_yield_g: Optional[float] = None,
+) -> Reaction:
+    """
+    Auto-balance the equation, build the Reaction, print a full summary
+    table, and return the Reaction object in case you want to do more
+    with it afterward.
+    """
+    rxn = Reaction.auto(reactants, products, desired_product)
+    print(rxn.summary_table(reactant_masses_g, actual_yield_g))
+    return rxn

atomecon-0.1.0/src/atomecon/elements.py

@@ -0,0 +1,34 @@
+"""
+Standard atomic weights for elements 1-118 (approximate, IUPAC-style averages).
+
+These values are sufficient for typical stoichiometry and green-chemistry
+calculations in an educational context. They are not intended for
+high-precision analytical work.
+"""
+
+ATOMIC_MASSES = {
+    "H": 1.008, "He": 4.0026, "Li": 6.94, "Be": 9.0122, "B": 10.81,
+    "C": 12.011, "N": 14.007, "O": 15.999, "F": 18.998, "Ne": 20.180,
+    "Na": 22.990, "Mg": 24.305, "Al": 26.982, "Si": 28.085, "P": 30.974,
+    "S": 32.06, "Cl": 35.45, "Ar": 39.948, "K": 39.098, "Ca": 40.078,
+    "Sc": 44.956, "Ti": 47.867, "V": 50.942, "Cr": 51.996, "Mn": 54.938,
+    "Fe": 55.845, "Co": 58.933, "Ni": 58.693, "Cu": 63.546, "Zn": 65.38,
+    "Ga": 69.723, "Ge": 72.630, "As": 74.922, "Se": 78.971, "Br": 79.904,
+    "Kr": 83.798, "Rb": 85.468, "Sr": 87.62, "Y": 88.906, "Zr": 91.224,
+    "Nb": 92.906, "Mo": 95.95, "Tc": 98.0, "Ru": 101.07, "Rh": 102.91,
+    "Pd": 106.42, "Ag": 107.87, "Cd": 112.41, "In": 114.82, "Sn": 118.71,
+    "Sb": 121.76, "Te": 127.60, "I": 126.90, "Xe": 131.29, "Cs": 132.91,
+    "Ba": 137.33, "La": 138.91, "Ce": 140.12, "Pr": 140.91, "Nd": 144.24,
+    "Pm": 145.0, "Sm": 150.36, "Eu": 151.96, "Gd": 157.25, "Tb": 158.93,
+    "Dy": 162.50, "Ho": 164.93, "Er": 167.26, "Tm": 168.93, "Yb": 173.05,
+    "Lu": 174.97, "Hf": 178.49, "Ta": 180.95, "W": 183.84, "Re": 186.21,
+    "Os": 190.23, "Ir": 192.22, "Pt": 195.08, "Au": 196.97, "Hg": 200.59,
+    "Tl": 204.38, "Pb": 207.2, "Bi": 208.98, "Po": 209.0, "At": 210.0,
+    "Rn": 222.0, "Fr": 223.0, "Ra": 226.0, "Ac": 227.0, "Th": 232.04,
+    "Pa": 231.04, "U": 238.03, "Np": 237.0, "Pu": 244.0, "Am": 243.0,
+    "Cm": 247.0, "Bk": 247.0, "Cf": 251.0, "Es": 252.0, "Fm": 257.0,
+    "Md": 258.0, "No": 259.0, "Lr": 262.0, "Rf": 267.0, "Db": 270.0,
+    "Sg": 271.0, "Bh": 270.0, "Hs": 277.0, "Mt": 278.0, "Ds": 281.0,
+    "Rg": 282.0, "Cn": 285.0, "Nh": 286.0, "Fl": 289.0, "Mc": 290.0,
+    "Lv": 293.0, "Ts": 294.0, "Og": 294.0,
+}