atomforge-py 0.1.0__tar.gz

atomforge_py-0.1.0/PKG-INFO

@@ -0,0 +1,70 @@
+Metadata-Version: 2.4
+Name: atomforge-py
+Version: 0.1.0
+Summary: Python interface for AtomForge: load, edit, and view atomic structures
+Author: AtomForge Contributors
+Author-email: AtomForge Contributors <albert.hzbn@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/albert-hzbn/AtomForge
+Project-URL: Repository, https://github.com/albert-hzbn/AtomForge
+Project-URL: Bug Tracker, https://github.com/albert-hzbn/AtomForge/issues
+Keywords: atomforge,atoms,crystal,materials,structure,viewer
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Chemistry
+Classifier: Topic :: Scientific/Engineering :: Physics
+Requires-Python: >=3.8
+Description-Content-Type: text/x-rst
+Provides-Extra: ase
+Requires-Dist: ase>=3.22; extra == "ase"
+Dynamic: author
+Dynamic: requires-python
+
+atomforge — Python interface for AtomForge
+==========================================
+
+Load, programmatically edit, and launch the AtomForge GUI to view atomic
+structures directly from Python.
+
+Quick-start
+-----------
+
+.. code-block:: python
+
+    import atomforge as af
+
+    # Load any format (XYZ/extXYZ natively; CIF/VASP/PDB via ase extra)
+    s = af.load("crystal.cif")
+
+    # Build from scratch
+    s2 = af.Structure()
+    s2.set_cell(2.87, 2.87, 2.87)   # BCC iron unit cell
+    s2.add_atom("Fe", 0.0,   0.0,   0.0)
+    s2.add_atom("Fe", 1.435, 1.435, 1.435)
+
+    # Supercell + open in the AtomForge GUI (non-blocking)
+    s2.repeat(4, 4, 4).view()
+
+    # Edit and save
+    s2.translate(1, 0, 0).save("shifted.xyz")
+
+Formats
+-------
+XYZ and extended-XYZ are handled natively with no dependencies.
+CIF, VASP/POSCAR, PDB, LAMMPS, mol2, and all other ASE-supported formats
+are available via the ``ase`` extra::
+
+    pip install "atomforge[ase]"
+
+Viewing
+-------
+``structure.view()`` serialises the structure to a temporary XYZ file and
+launches the AtomForge executable as a detached subprocess.  Set the
+``ATOMFORGE_PATH`` environment variable to the full path of ``AtomForge.exe``
+if it is not on PATH.

atomforge_py-0.1.0/atomforge/__init__.py

@@ -0,0 +1,21 @@
+"""
+atomforge — Python interface for AtomForge structures.
+
+Quick-start
+-----------
+>>> import atomforge as af
+>>> s = af.load("my_crystal.cif")
+>>> s.repeat(2, 2, 1).view()          # open in AtomForge GUI
+
+>>> s2 = af.Structure()
+>>> s2.add_atom("Fe", 0, 0, 0)
+>>> s2.add_atom("C",  1.8, 0, 0)
+>>> s2.save("dimer.xyz")
+"""
+
+from ._structure import Atom, Structure
+from ._io import load, save
+from ._viewer import view
+
+__all__ = ["Atom", "Structure", "load", "save", "view"]
+__version__ = "0.1.0"

atomforge_py-0.1.0/atomforge/_io.py

@@ -0,0 +1,195 @@
+"""File I/O: native XYZ/extxyz, and optional ASE fallback for CIF/VASP/PDB/etc."""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+from typing import TYPE_CHECKING, Tuple
+
+if TYPE_CHECKING:
+    from ._structure import Structure
+
+# ── CPK / Jmol colour table (RGB 0-1) ──────────────────────────────────────────
+
+_COLORS: dict[str, Tuple[float, float, float]] = {
+    "H":  (1.000, 1.000, 1.000), "He": (0.851, 1.000, 1.000),
+    "Li": (0.800, 0.502, 1.000), "Be": (0.761, 1.000, 0.000),
+    "B":  (1.000, 0.710, 0.710), "C":  (0.565, 0.565, 0.565),
+    "N":  (0.188, 0.314, 0.973), "O":  (1.000, 0.051, 0.051),
+    "F":  (0.565, 0.878, 0.314), "Ne": (0.702, 0.890, 0.961),
+    "Na": (0.671, 0.361, 0.949), "Mg": (0.541, 1.000, 0.000),
+    "Al": (0.749, 0.651, 0.651), "Si": (0.941, 0.784, 0.627),
+    "P":  (1.000, 0.502, 0.000), "S":  (1.000, 1.000, 0.188),
+    "Cl": (0.122, 0.941, 0.122), "Ar": (0.502, 0.820, 0.890),
+    "K":  (0.561, 0.251, 0.831), "Ca": (0.239, 1.000, 0.000),
+    "Sc": (0.902, 0.902, 0.902), "Ti": (0.749, 0.761, 0.780),
+    "V":  (0.651, 0.651, 0.671), "Cr": (0.541, 0.600, 0.780),
+    "Mn": (0.612, 0.478, 0.780), "Fe": (0.878, 0.400, 0.200),
+    "Co": (0.941, 0.565, 0.627), "Ni": (0.314, 0.816, 0.314),
+    "Cu": (0.784, 0.502, 0.200), "Zn": (0.490, 0.502, 0.690),
+    "Ga": (0.761, 0.561, 0.561), "Ge": (0.400, 0.561, 0.561),
+    "As": (0.741, 0.502, 0.890), "Se": (1.000, 0.631, 0.000),
+    "Br": (0.651, 0.161, 0.161), "Kr": (0.361, 0.722, 0.820),
+    "Rb": (0.439, 0.180, 0.690), "Sr": (0.000, 1.000, 0.000),
+    "Y":  (0.580, 1.000, 1.000), "Zr": (0.580, 0.878, 0.878),
+    "Nb": (0.451, 0.761, 0.788), "Mo": (0.329, 0.710, 0.710),
+    "Tc": (0.231, 0.620, 0.620), "Ru": (0.141, 0.561, 0.561),
+    "Rh": (0.039, 0.490, 0.549), "Pd": (0.000, 0.412, 0.522),
+    "Ag": (0.753, 0.753, 0.753), "Cd": (1.000, 0.851, 0.561),
+    "In": (0.651, 0.459, 0.451), "Sn": (0.400, 0.502, 0.502),
+    "Sb": (0.620, 0.388, 0.710), "Te": (0.831, 0.478, 0.000),
+    "I":  (0.580, 0.000, 0.580), "Xe": (0.259, 0.620, 0.690),
+    "Cs": (0.341, 0.090, 0.561), "Ba": (0.000, 0.788, 0.000),
+    "La": (0.439, 0.831, 1.000), "Ce": (1.000, 1.000, 0.780),
+    "Pr": (0.851, 1.000, 0.780), "Nd": (0.780, 1.000, 0.780),
+    "Pm": (0.639, 1.000, 0.780), "Sm": (0.561, 1.000, 0.780),
+    "Eu": (0.380, 1.000, 0.780), "Gd": (0.271, 1.000, 0.780),
+    "Tb": (0.188, 1.000, 0.780), "Dy": (0.122, 1.000, 0.780),
+    "Ho": (0.000, 1.000, 0.612), "Er": (0.000, 0.902, 0.459),
+    "Tm": (0.000, 0.831, 0.322), "Yb": (0.000, 0.749, 0.220),
+    "Lu": (0.000, 0.671, 0.141), "Hf": (0.302, 0.761, 1.000),
+    "Ta": (0.302, 0.651, 1.000), "W":  (0.129, 0.580, 0.839),
+    "Re": (0.149, 0.490, 0.671), "Os": (0.149, 0.400, 0.588),
+    "Ir": (0.090, 0.329, 0.529), "Pt": (0.816, 0.816, 0.878),
+    "Au": (1.000, 0.820, 0.137), "Hg": (0.722, 0.722, 0.816),
+    "Tl": (0.651, 0.329, 0.302), "Pb": (0.341, 0.349, 0.380),
+    "Bi": (0.620, 0.310, 0.710), "Po": (0.671, 0.361, 0.000),
+    "At": (0.459, 0.310, 0.271), "Rn": (0.259, 0.510, 0.588),
+    "Fr": (0.259, 0.000, 0.400), "Ra": (0.000, 0.490, 0.000),
+    "Ac": (0.439, 0.671, 0.980), "Th": (0.000, 0.729, 1.000),
+    "Pa": (0.000, 0.631, 1.000), "U":  (0.000, 0.561, 1.000),
+    "Np": (0.000, 0.502, 1.000), "Pu": (0.000, 0.420, 1.000),
+}
+
+
+def _default_color(symbol: str) -> Tuple[float, float, float]:
+    return _COLORS.get(symbol, (0.8, 0.8, 0.8))
+
+
+# ── XYZ / extended-XYZ ─────────────────────────────────────────────────────────
+
+def _load_xyz(path: str) -> "Structure":
+    from ._structure import Atom, Structure
+    s = Structure()
+    with open(path, encoding="utf-8") as fh:
+        lines = fh.readlines()
+    if not lines:
+        return s
+    n = int(lines[0].strip())
+    comment = lines[1] if len(lines) > 1 else ""
+
+    # Parse extended-XYZ lattice from comment line
+    if 'Lattice=' in comment or 'lattice=' in comment:
+        import re
+        m = re.search(r'[Ll]attice="([^"]+)"', comment)
+        if m:
+            vals = list(map(float, m.group(1).split()))
+            if len(vals) == 9:
+                s.cell = [vals[0:3], vals[3:6], vals[6:9]]
+
+    atom_lines = lines[2:2 + n]
+    properties_order = ["species", "pos", "pos", "pos"]
+    if 'Properties=' in comment or 'properties=' in comment:
+        import re
+        m = re.search(r'[Pp]roperties=(\S+)', comment)
+        if m:
+            properties_order = m.group(1).split(":")
+
+    for line in atom_lines:
+        parts = line.split()
+        if not parts:
+            continue
+        sym = parts[0]
+        x, y, z = float(parts[1]), float(parts[2]), float(parts[3])
+        cr, cg, cb = _default_color(sym)
+        s.atoms.append(Atom(sym, x, y, z, cr, cg, cb))
+    return s
+
+
+def _save_xyz(s: "Structure", path: str) -> None:
+    lines = [str(len(s.atoms)) + "\n"]
+    if s.cell:
+        a, b, c = s.cell
+        lat = " ".join(f"{v:.6f}" for row in [a, b, c] for v in row)
+        lines.append(f'Lattice="{lat}" Properties=species:S:1:pos:R:3\n')
+    else:
+        lines.append("AtomForge structure\n")
+    for atom in s.atoms:
+        lines.append(f"{atom.symbol} {atom.x:.6f} {atom.y:.6f} {atom.z:.6f}\n")
+    with open(path, "w", encoding="utf-8") as fh:
+        fh.writelines(lines)
+
+
+# ── ASE fallback ────────────────────────────────────────────────────────────────
+
+def _load_ase(path: str) -> "Structure":
+    try:
+        import ase.io
+        import numpy as np
+    except ImportError:
+        raise ImportError(
+            "Install the 'ase' package to load this file format:\n"
+            "    pip install ase"
+        )
+    from ._structure import Atom, Structure
+    atoms_ase = ase.io.read(path)
+    s = Structure()
+    if atoms_ase.cell is not None and any(atoms_ase.pbc):
+        cell = np.array(atoms_ase.cell)
+        s.cell = [list(cell[0]), list(cell[1]), list(cell[2])]
+    for sym, (x, y, z) in zip(atoms_ase.get_chemical_symbols(),
+                               atoms_ase.get_positions()):
+        cr, cg, cb = _default_color(sym)
+        s.atoms.append(Atom(sym, float(x), float(y), float(z), cr, cg, cb))
+    return s
+
+
+def _save_ase(s: "Structure", path: str) -> None:
+    try:
+        import ase
+        import ase.io
+        import numpy as np
+    except ImportError:
+        raise ImportError(
+            "Install the 'ase' package to save this file format:\n"
+            "    pip install ase"
+        )
+    syms = [a.symbol for a in s.atoms]
+    pos  = np.array([[a.x, a.y, a.z] for a in s.atoms])
+    cell = np.array(s.cell) if s.cell else None
+    pbc  = s.cell is not None
+    ase_atoms = ase.Atoms(symbols=syms, positions=pos, cell=cell, pbc=pbc)
+    ase.io.write(path, ase_atoms)
+
+
+# ── Format dispatch ─────────────────────────────────────────────────────────────
+
+_XYZ_EXTS = {".xyz", ".extxyz"}
+_ASE_EXTS = {".cif", ".vasp", ".poscar", ".pdb", ".mol", ".mol2", ".lmp",
+             ".lammps", ".dump", ".gen", ".sdf", ".cfg"}
+
+
+def load(path: str) -> "Structure":
+    """Load a structure from file.  XYZ/extxyz is handled natively; other formats require ASE."""
+    ext = Path(path).suffix.lower()
+    if ext in _XYZ_EXTS:
+        return _load_xyz(path)
+    if ext in _ASE_EXTS or not ext:
+        return _load_ase(path)
+    # Try XYZ first, fall back to ASE
+    try:
+        return _load_xyz(path)
+    except Exception:
+        return _load_ase(path)
+
+
+def save(s: "Structure", path: str) -> None:
+    """Save a structure to file.  XYZ/extxyz is handled natively; other formats require ASE."""
+    ext = Path(path).suffix.lower()
+    if ext in _XYZ_EXTS:
+        _save_xyz(s, path)
+    elif ext in _ASE_EXTS:
+        _save_ase(s, path)
+    else:
+        # Default to XYZ
+        _save_xyz(s, path)

atomforge_py-0.1.0/atomforge/_structure.py

@@ -0,0 +1,163 @@
+"""Core data types: Atom and Structure."""
+
+import copy
+import math
+from dataclasses import dataclass, field
+from typing import List, Optional
+
+
+@dataclass
+class Atom:
+    """A single atom with Cartesian coordinates (Angstrom) and display colour."""
+
+    symbol: str
+    x: float
+    y: float
+    z: float
+    r: float = field(default=1.0, repr=False)
+    g: float = field(default=1.0, repr=False)
+    b: float = field(default=1.0, repr=False)
+
+    def __repr__(self) -> str:
+        return f"Atom({self.symbol!r}, x={self.x:.4f}, y={self.y:.4f}, z={self.z:.4f})"
+
+    def copy(self) -> "Atom":
+        return copy.copy(self)
+
+
+class Structure:
+    """
+    A collection of atoms with an optional periodic unit cell.
+
+    Attributes
+    ----------
+    atoms : list[Atom]
+        All atoms in Cartesian coordinates (Angstrom).
+    cell : list[list[float]] | None
+        3×3 lattice vectors ``[[a1,a2,a3], [b1,b2,b3], [c1,c2,c3]]``
+        in Angstrom, or ``None`` for a non-periodic (cluster) structure.
+    """
+
+    def __init__(self) -> None:
+        self.atoms: List[Atom] = []
+        self.cell: Optional[List[List[float]]] = None
+
+    # ── Dunder helpers ──────────────────────────────────────────────────────────
+
+    def __len__(self) -> int:
+        return len(self.atoms)
+
+    def __repr__(self) -> str:
+        periodicity = "periodic" if self.cell else "non-periodic"
+        species: dict = {}
+        for a in self.atoms:
+            species[a.symbol] = species.get(a.symbol, 0) + 1
+        comp = " ".join(f"{s}{n}" for s, n in sorted(species.items()))
+        return f"Structure({len(self.atoms)} atoms, {comp}, {periodicity})"
+
+    def copy(self) -> "Structure":
+        s = Structure()
+        s.atoms = [a.copy() for a in self.atoms]
+        s.cell = [list(row) for row in self.cell] if self.cell else None
+        return s
+
+    # ── Atom editing ────────────────────────────────────────────────────────────
+
+    def add_atom(self, symbol: str, x: float, y: float, z: float,
+                 r: float = -1.0, g: float = -1.0, b: float = -1.0) -> Atom:
+        """Append an atom and return it.  Default colour is the element's CPK colour."""
+        from ._io import _default_color
+        cr, cg, cb = _default_color(symbol)
+        atom = Atom(symbol, float(x), float(y), float(z),
+                    r=cr if r < 0 else r,
+                    g=cg if g < 0 else g,
+                    b=cb if b < 0 else b)
+        self.atoms.append(atom)
+        return atom
+
+    def remove_atom(self, index: int) -> Atom:
+        """Remove and return the atom at *index*."""
+        return self.atoms.pop(index)
+
+    # ── Bulk transforms ─────────────────────────────────────────────────────────
+
+    def translate(self, dx: float, dy: float, dz: float) -> "Structure":
+        """Shift all atoms in-place by (dx, dy, dz) Angstrom.  Returns self."""
+        for a in self.atoms:
+            a.x += dx
+            a.y += dy
+            a.z += dz
+        return self
+
+    def scale(self, factor: float) -> "Structure":
+        """Scale all Cartesian coordinates and cell vectors by *factor*.  Returns self."""
+        for a in self.atoms:
+            a.x *= factor
+            a.y *= factor
+            a.z *= factor
+        if self.cell:
+            self.cell = [[v * factor for v in row] for row in self.cell]
+        return self
+
+    def repeat(self, nx: int, ny: int = 1, nz: int = 1) -> "Structure":
+        """Return a new supercell replicated *nx × ny × nz* times.  Requires a unit cell."""
+        if not self.cell:
+            raise ValueError("repeat() requires a unit cell (set structure.cell first)")
+        a, b, c = self.cell
+        out = Structure()
+        out.cell = [
+            [a[i] * nx for i in range(3)],
+            [b[i] * ny for i in range(3)],
+            [c[i] * nz for i in range(3)],
+        ]
+        for ix in range(nx):
+            for iy in range(ny):
+                for iz in range(nz):
+                    for atom in self.atoms:
+                        new_atom = atom.copy()
+                        new_atom.x += a[0]*ix + b[0]*iy + c[0]*iz
+                        new_atom.y += a[1]*ix + b[1]*iy + c[1]*iz
+                        new_atom.z += a[2]*ix + b[2]*iy + c[2]*iz
+                        out.atoms.append(new_atom)
+        return out
+
+    def filter_species(self, *symbols: str) -> "Structure":
+        """Return a new Structure containing only atoms of the given element symbols."""
+        keep = set(symbols)
+        out = self.copy()
+        out.atoms = [a for a in out.atoms if a.symbol in keep]
+        return out
+
+    def set_cell(self, a: float, b: float, c: float,
+                 alpha: float = 90.0, beta: float = 90.0,
+                 gamma: float = 90.0) -> "Structure":
+        """
+        Set the unit cell from lattice parameters (lengths in Å, angles in degrees).
+        Uses the standard convention: **a** along x, **b** in the xy-plane.
+        Returns self.
+        """
+        rad = math.pi / 180.0
+        ca = math.cos(alpha * rad)
+        cb = math.cos(beta  * rad)
+        cg = math.cos(gamma * rad)
+        sg = math.sin(gamma * rad)
+        ax = a
+        bx = b * cg
+        by = b * sg
+        cx = c * cb
+        cy = c * (ca - cb * cg) / sg if sg > 1e-10 else 0.0
+        cz = math.sqrt(max(0.0, c * c - cx * cx - cy * cy))
+        self.cell = [[ax, 0.0, 0.0], [bx, by, 0.0], [cx, cy, cz]]
+        return self
+
+    # ── Viewing / I/O ───────────────────────────────────────────────────────────
+
+    def view(self) -> None:
+        """Open this structure in the AtomForge GUI (non-blocking)."""
+        from ._viewer import view
+        view(self)
+
+    def save(self, path: str) -> None:
+        """Save to file; format is inferred from the file extension."""
+        from ._io import save
+        save(self, path)

atomforge_py-0.1.0/atomforge/_viewer.py

@@ -0,0 +1,97 @@
+"""Launch the AtomForge GUI to view a Structure."""
+
+from __future__ import annotations
+
+import os
+import subprocess
+import sys
+import tempfile
+from pathlib import Path
+from typing import TYPE_CHECKING, Optional
+
+if TYPE_CHECKING:
+    from ._structure import Structure
+
+
+def _find_atomforge() -> Optional[str]:
+    """Return the path to the AtomForge executable, or None if not found."""
+    # 1. Explicit env var
+    env = os.environ.get("ATOMFORGE_PATH")
+    if env and Path(env).is_file():
+        return env
+
+    # 2. Relative to this package file (handles unpacked release: python/ lives next to AtomForge.exe)
+    pkg_dir = Path(__file__).resolve().parent
+    for candidate in [
+        pkg_dir / "AtomForge.exe",
+        pkg_dir / "AtomForge",
+        pkg_dir.parent / "AtomForge.exe",
+        pkg_dir.parent / "AtomForge",
+        pkg_dir.parent.parent / "AtomForge.exe",
+        pkg_dir.parent.parent / "AtomForge",
+        pkg_dir.parent.parent / "build" / "Release" / "AtomForge.exe",
+        pkg_dir.parent.parent / "build" / "AtomForge.exe",
+        pkg_dir.parent.parent / "build" / "AtomForge",
+    ]:
+        if candidate.is_file():
+            return str(candidate)
+
+    # 3. System PATH
+    import shutil
+    found = shutil.which("AtomForge") or shutil.which("atomforge")
+    if found:
+        return found
+
+    # 4. Common Windows install paths
+    if sys.platform == "win32":
+        program_files = os.environ.get("ProgramFiles", r"C:\Program Files")
+        for root in [program_files, os.environ.get("ProgramFiles(x86)", "")]:
+            candidate = Path(root) / "AtomForge" / "AtomForge.exe"
+            if candidate.is_file():
+                return str(candidate)
+
+    return None
+
+
+def view(s: "Structure") -> None:
+    """
+    Open *s* in the AtomForge GUI (non-blocking).
+
+    The structure is serialised to a temporary extXYZ file and AtomForge is
+    launched as a detached subprocess.  The temp file is cleaned up after
+    AtomForge exits (on POSIX) or left to the OS temp-file sweeper (Windows),
+    because AtomForge must be able to read the file after this function returns.
+    """
+    exe = _find_atomforge()
+    if exe is None:
+        raise FileNotFoundError(
+            "AtomForge executable not found.  Set the ATOMFORGE_PATH environment "
+            "variable to the full path of AtomForge.exe, or ensure it is on PATH."
+        )
+
+    # Write to a named temp file that survives past this function
+    suffix = ".xyz"
+    tmp = tempfile.NamedTemporaryFile(
+        prefix="atomforge_view_", suffix=suffix, delete=False
+    )
+    tmp_path = tmp.name
+    tmp.close()
+
+    from ._io import _save_xyz
+    _save_xyz(s, tmp_path)
+
+    if sys.platform == "win32":
+        # DETACHED_PROCESS: new console, parent death does not kill child
+        DETACHED_PROCESS = 0x00000008
+        CREATE_NEW_PROCESS_GROUP = 0x00000200
+        subprocess.Popen(
+            [exe, tmp_path],
+            creationflags=DETACHED_PROCESS | CREATE_NEW_PROCESS_GROUP,
+            close_fds=True,
+        )
+    else:
+        subprocess.Popen(
+            [exe, tmp_path],
+            start_new_session=True,
+            close_fds=True,
+        )

atomforge_py-0.1.0/atomforge_py.egg-info/PKG-INFO

@@ -0,0 +1,70 @@
+Metadata-Version: 2.4
+Name: atomforge-py
+Version: 0.1.0
+Summary: Python interface for AtomForge: load, edit, and view atomic structures
+Author: AtomForge Contributors
+Author-email: AtomForge Contributors <albert.hzbn@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/albert-hzbn/AtomForge
+Project-URL: Repository, https://github.com/albert-hzbn/AtomForge
+Project-URL: Bug Tracker, https://github.com/albert-hzbn/AtomForge/issues
+Keywords: atomforge,atoms,crystal,materials,structure,viewer
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Chemistry
+Classifier: Topic :: Scientific/Engineering :: Physics
+Requires-Python: >=3.8
+Description-Content-Type: text/x-rst
+Provides-Extra: ase
+Requires-Dist: ase>=3.22; extra == "ase"
+Dynamic: author
+Dynamic: requires-python
+
+atomforge — Python interface for AtomForge
+==========================================
+
+Load, programmatically edit, and launch the AtomForge GUI to view atomic
+structures directly from Python.
+
+Quick-start
+-----------
+
+.. code-block:: python
+
+    import atomforge as af
+
+    # Load any format (XYZ/extXYZ natively; CIF/VASP/PDB via ase extra)
+    s = af.load("crystal.cif")
+
+    # Build from scratch
+    s2 = af.Structure()
+    s2.set_cell(2.87, 2.87, 2.87)   # BCC iron unit cell
+    s2.add_atom("Fe", 0.0,   0.0,   0.0)
+    s2.add_atom("Fe", 1.435, 1.435, 1.435)
+
+    # Supercell + open in the AtomForge GUI (non-blocking)
+    s2.repeat(4, 4, 4).view()
+
+    # Edit and save
+    s2.translate(1, 0, 0).save("shifted.xyz")
+
+Formats
+-------
+XYZ and extended-XYZ are handled natively with no dependencies.
+CIF, VASP/POSCAR, PDB, LAMMPS, mol2, and all other ASE-supported formats
+are available via the ``ase`` extra::
+
+    pip install "atomforge[ase]"
+
+Viewing
+-------
+``structure.view()`` serialises the structure to a temporary XYZ file and
+launches the AtomForge executable as a detached subprocess.  Set the
+``ATOMFORGE_PATH`` environment variable to the full path of ``AtomForge.exe``
+if it is not on PATH.

atomforge_py-0.1.0/atomforge_py.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+pyproject.toml
+setup.py
+atomforge/__init__.py
+atomforge/_io.py
+atomforge/_structure.py
+atomforge/_viewer.py
+atomforge_py.egg-info/PKG-INFO
+atomforge_py.egg-info/SOURCES.txt
+atomforge_py.egg-info/dependency_links.txt
+atomforge_py.egg-info/requires.txt
+atomforge_py.egg-info/top_level.txt

atomforge_py-0.1.0/atomforge_py.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

atomforge_py-0.1.0/atomforge_py.egg-info/requires.txt

@@ -0,0 +1,3 @@
+
+[ase]
+ase>=3.22

atomforge_py-0.1.0/atomforge_py.egg-info/top_level.txt

@@ -0,0 +1 @@
+atomforge

atomforge_py-0.1.0/pyproject.toml

@@ -0,0 +1,76 @@
+[build-system]
+requires = ["setuptools>=61", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "atomforge-py"
+version = "0.1.0"
+description = "Python interface for AtomForge: load, edit, and view atomic structures"
+authors = [{ name = "AtomForge Contributors", email = "albert.hzbn@gmail.com" }]
+readme = { text = """
+atomforge — Python interface for AtomForge
+==========================================
+
+Load, programmatically edit, and launch the AtomForge GUI to view atomic
+structures directly from Python.
+
+Quick-start
+-----------
+
+.. code-block:: python
+
+    import atomforge as af
+
+    # Load any format (XYZ/extXYZ natively; CIF/VASP/PDB via ase extra)
+    s = af.load("crystal.cif")
+
+    # Build from scratch
+    s2 = af.Structure()
+    s2.set_cell(2.87, 2.87, 2.87)   # BCC iron unit cell
+    s2.add_atom("Fe", 0.0,   0.0,   0.0)
+    s2.add_atom("Fe", 1.435, 1.435, 1.435)
+
+    # Supercell + open in the AtomForge GUI (non-blocking)
+    s2.repeat(4, 4, 4).view()
+
+    # Edit and save
+    s2.translate(1, 0, 0).save("shifted.xyz")
+
+Formats
+-------
+XYZ and extended-XYZ are handled natively with no dependencies.
+CIF, VASP/POSCAR, PDB, LAMMPS, mol2, and all other ASE-supported formats
+are available via the ``ase`` extra::
+
+    pip install "atomforge[ase]"
+
+Viewing
+-------
+``structure.view()`` serialises the structure to a temporary XYZ file and
+launches the AtomForge executable as a detached subprocess.  Set the
+``ATOMFORGE_PATH`` environment variable to the full path of ``AtomForge.exe``
+if it is not on PATH.
+""", content-type = "text/x-rst" }
+requires-python = ">=3.8"
+license = "MIT"
+keywords = ["atomforge", "atoms", "crystal", "materials", "structure", "viewer"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Science/Research",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Scientific/Engineering :: Chemistry",
+    "Topic :: Scientific/Engineering :: Physics",
+]
+
+[project.optional-dependencies]
+ase = ["ase>=3.22"]
+
+[project.urls]
+Homepage = "https://github.com/albert-hzbn/AtomForge"
+Repository = "https://github.com/albert-hzbn/AtomForge"
+"Bug Tracker" = "https://github.com/albert-hzbn/AtomForge/issues"

atomforge_py-0.1.0/setup.cfg

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

atomforge_py-0.1.0/setup.py

@@ -0,0 +1,19 @@
+from setuptools import setup, find_packages
+
+setup(
+    name="atomforge-py",
+    version="0.1.0",
+    description="Python interface for AtomForge: load, edit, and view atomic structures",
+    author="AtomForge Contributors",
+    python_requires=">=3.8",
+    packages=find_packages(),
+    install_requires=[],
+    extras_require={
+        "ase": ["ase>=3.22"],
+    },
+    classifiers=[
+        "Programming Language :: Python :: 3",
+        "Topic :: Scientific/Engineering :: Chemistry",
+        "Topic :: Scientific/Engineering :: Physics",
+    ],
+)