proteinspy 1.0.0__tar.gz

proteinspy-1.0.0/PKG-INFO

@@ -0,0 +1,65 @@
+Metadata-Version: 2.4
+Name: proteinspy
+Version: 1.0.0
+Summary: A Poetry package to analyze protein structure from .cif files
+License: MIT
+Keywords: protein,bioinformatics,cif,pdb,gemmi,structure
+Author: AkhilTeja2209
+Author-email: your_email@example.com
+Requires-Python: >=3.9,<4.0
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+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: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Scientific/Engineering :: Bio-Informatics
+Requires-Dist: gemmi
+Requires-Dist: rich
+Project-URL: Homepage, https://akhilteja2209.github.io/Proteinspy/
+Project-URL: Repository, https://github.com/AkhilTeja2209/Proteinspy
+Description-Content-Type: text/markdown
+
+# Proteinspy
+
+This is a python package based on Poetry.
+
+This repository can be used to find the _Resolution_, _Missing residues_, _Ligands_, and _Chains_ in any Protein sample uploaded. The sample must be in a .cif file for the pipeline to run properly. 
+
+## 📚 Data
+A sample [protein](https://github.com/AkhilTeja2209/Proteinspy/blob/main/Final_proj_1/10AJ.cif), has been given, and can also be accessed from the [PDB](https://www.rcsb.org), among many other samples. 
+
+## 🗒️ Requirements
+python [poetry](https://python-poetry.org/docs/) and its pre-requisites must be available on the system.
+
+## 🚀 To run the pipeline,
+
+1. For a mode based implementation
+```bash
+cd "<your complete folder path>"
+poetry install    #installs all the dependencies of the package
+
+poetry run proteinspy analyze 10AJ.cif    #replace the protein input name with your own file if you're using a different input or a filename
+```
+
+2. For an argument based implementation
+```bash
+cd "<your complete folder path>"
+poetry install    #installs all the dependencies of the package
+
+poetry run proteinspy resolution 10AJ.cif    #gives the resolution of the protein
+poetry run proteinspy ligands 10AJ.cif       #gives the ligands in the protein
+poetry run proteinspy missing 10AJ.cif       #gives the missing residues in the protein
+poetry run proteinspy chains 10AJ.cif        #gives the chains in the protein
+```
+
+## 📈 Future Enhancements
+- [ ] UI/UX 
+- [ ] Containerisation, using docker
+
+## ⚠️ NOTE
+This is an open-source project, and any contribtions, even if not mentioned in the future enhancements section, are welcome. 
+

proteinspy-1.0.0/README.md

@@ -0,0 +1,39 @@
+# Proteinspy
+
+This is a python package based on Poetry.
+
+This repository can be used to find the _Resolution_, _Missing residues_, _Ligands_, and _Chains_ in any Protein sample uploaded. The sample must be in a .cif file for the pipeline to run properly. 
+
+## 📚 Data
+A sample [protein](https://github.com/AkhilTeja2209/Proteinspy/blob/main/Final_proj_1/10AJ.cif), has been given, and can also be accessed from the [PDB](https://www.rcsb.org), among many other samples. 
+
+## 🗒️ Requirements
+python [poetry](https://python-poetry.org/docs/) and its pre-requisites must be available on the system.
+
+## 🚀 To run the pipeline,
+
+1. For a mode based implementation
+```bash
+cd "<your complete folder path>"
+poetry install    #installs all the dependencies of the package
+
+poetry run proteinspy analyze 10AJ.cif    #replace the protein input name with your own file if you're using a different input or a filename
+```
+
+2. For an argument based implementation
+```bash
+cd "<your complete folder path>"
+poetry install    #installs all the dependencies of the package
+
+poetry run proteinspy resolution 10AJ.cif    #gives the resolution of the protein
+poetry run proteinspy ligands 10AJ.cif       #gives the ligands in the protein
+poetry run proteinspy missing 10AJ.cif       #gives the missing residues in the protein
+poetry run proteinspy chains 10AJ.cif        #gives the chains in the protein
+```
+
+## 📈 Future Enhancements
+- [ ] UI/UX 
+- [ ] Containerisation, using docker
+
+## ⚠️ NOTE
+This is an open-source project, and any contribtions, even if not mentioned in the future enhancements section, are welcome. 

proteinspy-1.0.0/proteinspy/__init__.py

@@ -0,0 +1,3 @@
+from .analysis import get_resolution, get_chains, get_ligands, get_missing_residues
+
+__version__ = "0.1.0"

proteinspy-1.0.0/proteinspy/__main__.py

@@ -0,0 +1,108 @@
+import click
+from rich.console import Console
+from rich.table import Table
+from rich import box
+
+from .analysis import get_resolution, get_chains, get_ligands, get_missing_residues
+
+console = Console()
+
+
+# ── display helpers ──
+
+def show_resolution(path: str) -> None:
+    r = get_resolution(path)
+    console.print("\n[bold cyan]Resolution[/bold cyan]")
+    if r["resolution"]:
+        console.print(f"  Resolution : [bold]{r['resolution']} {r['unit']}[/bold]")
+    else:
+        console.print("  Resolution : [yellow]Not available[/yellow]")
+    console.print(f"  Method     : {r['method']}\n")
+
+def show_chains(path: str) -> None:
+    r = get_chains(path)
+    console.print(f"[bold cyan]Chains[/bold cyan]  ({r['chain_count']} total)\n")
+    t = Table(box=box.SIMPLE_HEAVY, show_header=True, header_style="bold magenta")
+    t.add_column("Chain ID", justify="center")
+    t.add_column("Type")
+    t.add_column("Residues", justify="right")
+    for ch in r["chains"]:
+        t.add_row(ch["id"], ch["type"], str(ch["residue_count"]))
+    console.print(t)
+    console.print()
+
+def show_ligands(path: str) -> None:
+    r = get_ligands(path)
+    console.print(f"[bold cyan]Ligands[/bold cyan]  ({r['ligand_count']} found)\n")
+    if not r["has_ligand"]:
+        console.print("  [yellow]No ligands detected.[/yellow]\n")
+        return
+    t = Table(box=box.SIMPLE_HEAVY, show_header=True, header_style="bold magenta")
+    t.add_column("Ligand ID", justify="center")
+    t.add_column("Chain", justify="center")
+    t.add_column("Seq Num", justify="right")
+    for lg in r["ligands"]:
+        t.add_row(lg["id"], lg.get("chain", "?"), lg.get("seq_num", "?"))
+    console.print(t)
+    console.print()
+
+def show_missing(path: str) -> None:
+    r = get_missing_residues(path)
+    console.print(f"[bold cyan]Missing Residues[/bold cyan]  ({r['missing_count']} found)\n")
+    if r["missing_count"] == 0:
+        console.print("  [green]No missing residues.[/green]\n")
+        return
+    t = Table(box=box.SIMPLE_HEAVY, show_header=True, header_style="bold magenta")
+    t.add_column("Chain", justify="center")
+    t.add_column("Residue", justify="center")
+    t.add_column("Seq #", justify="right")
+    for mr in r["missing_residues"]:
+        t.add_row(
+            mr.get("chain", "?"),
+            mr.get("residue", "?"),
+            str(mr.get("seq_num", "?")),
+        )
+    console.print(t)
+    console.print()
+
+
+#CLI commands
+
+@click.group()
+def main():
+    """proteinspy — Analyse a .cif protein structure file."""
+
+@main.command("analyze")
+@click.argument("cif_file")
+def cmd_analyze(cif_file: str):
+    """Run all analyses on a .cif file (mode-based)."""
+    console.rule(f"[bold blue]proteinspy — {cif_file}[/bold blue]")
+    show_resolution(cif_file)
+    show_chains(cif_file)
+    show_ligands(cif_file)
+    show_missing(cif_file)
+    console.rule()
+
+@main.command("resolution")
+@click.argument("cif_file")
+def cmd_resolution(cif_file: str):
+    """Report resolution only."""
+    show_resolution(cif_file)
+
+@main.command("chains")
+@click.argument("cif_file")
+def cmd_chains(cif_file: str):
+    """Report chains only."""
+    show_chains(cif_file)
+
+@main.command("ligands")
+@click.argument("cif_file")
+def cmd_ligands(cif_file: str):
+    """Report ligands only."""
+    show_ligands(cif_file)
+
+@main.command("missing")
+@click.argument("cif_file")
+def cmd_missing(cif_file: str):
+    """Report missing residues only."""
+    show_missing(cif_file)

proteinspy-1.0.0/proteinspy/analysis.py

@@ -0,0 +1,146 @@
+import gemmi
+
+# Residue types to exclude from ligand detection
+_STANDARD_AA = {
+    "ALA","ARG","ASN","ASP","CYS","GLN","GLU","GLY","HIS","ILE",
+    "LEU","LYS","MET","PHE","PRO","SER","THR","TRP","TYR","VAL",
+    "SEC","PYL","UNK",
+}
+_STANDARD_NUC = {"DA","DC","DG","DT","DI","A","C","G","U","I"}
+_SOLVENT = {
+    "HOH","WAT","DOD","SO4","EDO","GOL","PEG","ACT","MPD",
+    "PO4","CLR","DMS","FMT","TRS","IOD","BME","EPE"
+}
+
+
+def get_resolution(path: str) -> dict:
+    """Return the resolution of the structure in Angstroms."""
+    st = gemmi.read_structure(path)
+
+    res = st.resolution if st.resolution and st.resolution > 0 else None
+
+    # Fallback: read directly from CIF tags
+    if res is None:
+        try:
+            block = gemmi.cif.read(path).sole_block()
+            for tag in ["_refine.ls_d_res_high",
+                        "_reflns.d_resolution_high",
+                        "_em_3d_reconstruction.resolution"]:
+                val = block.find_value(tag)
+                if val and val not in {"?", "."}:
+                    res = float(val)
+                    break
+        except Exception:
+            pass
+
+    # Get experimental method
+    method = "unknown"
+    try:
+        block = gemmi.cif.read(path).sole_block()
+        m = block.find_value("_exptl.method")
+        if m and m not in {"?", "."}:
+            method = m.strip().strip("'\"")
+    except Exception:
+        pass
+
+    return {"resolution": res, "unit": "Å" if res else None, "method": method}
+
+
+def get_chains(path: str) -> dict:
+    """Return the number and details of chains in the structure."""
+    st = gemmi.read_structure(path)
+    chains = []
+    seen = set()
+
+    for model in st:
+        for chain in model:
+            if chain.name in seen:
+                continue
+            seen.add(chain.name)
+            polymer = chain.get_polymer()
+            ptype = str(polymer.check_polymer_type()) if len(polymer) > 0 else "non-polymer"
+            residue_count = sum(1 for _ in chain)
+            chains.append({"id": chain.name, "type": ptype, "residue_count": residue_count})
+
+    return {"chain_count": len(chains), "chains": chains}
+
+
+def get_ligands(path: str) -> dict:
+    """Return all ligands found in the structure."""
+    st = gemmi.read_structure(path)
+    found = []
+    seen = set()
+
+    for model in st:
+        for chain in model:
+            for res in chain:
+                if res.entity_type not in (gemmi.EntityType.NonPolymer,
+                                           gemmi.EntityType.Unknown):
+                    continue
+                name = res.name.strip()
+                if name in _STANDARD_AA or name in _STANDARD_NUC or name in _SOLVENT:
+                    continue
+                key = f"{name}:{chain.name}:{res.seqid}"
+                if key in seen:
+                    continue
+                seen.add(key)
+                found.append({"id": name, "chain": chain.name, "seq_num": str(res.seqid)})
+
+    # Fallback: read _pdbx_entity_nonpoly from CIF
+    if not found:
+        try:
+            block = gemmi.cif.read(path).sole_block()
+            table = block.find("_pdbx_entity_nonpoly.", ["name", "comp_id"])
+            for row in table:
+                comp = row[1].strip().strip("'\"")
+                if comp in _SOLVENT or comp in _STANDARD_AA:
+                    continue
+                if comp in seen:
+                    continue
+                seen.add(comp)
+                found.append({"id": comp, "chain": "?", "seq_num": "?", "name": row[0].strip().strip("'\"")} )
+        except Exception:
+            pass
+
+    return {"ligand_count": len(found), "has_ligand": len(found) > 0, "ligands": found}
+
+
+def get_missing_residues(path: str) -> dict:
+    """Return residues present in the sequence but missing from ATOM records."""
+    st = gemmi.read_structure(path)
+    missing = []
+
+    # Method A: compare full entity sequence vs observed ATOM residues
+    for model in st:
+        for chain in model:
+            polymer = chain.get_polymer()
+            if len(polymer) == 0:
+                continue
+            observed = {str(r.label_seq) for r in polymer if r.label_seq is not None}
+            entity_id = next((r.entity_id for r in polymer), None)
+            if entity_id is None:
+                continue
+            entity = st.get_entity(entity_id)
+            if entity is None:
+                continue
+            for idx, mon in enumerate(entity.full_sequence, start=1):
+                if str(idx) not in observed:
+                    missing.append({"chain": chain.name, "seq_num": idx, "residue": mon})
+
+    # Method B: read _pdbx_unobs_or_zero_occ_residues from CIF (more reliable)
+    cif_missing = []
+    try:
+        block = gemmi.cif.read(path).sole_block()
+        table = block.find("_pdbx_unobs_or_zero_occ_residues.",
+                           ["auth_asym_id", "auth_comp_id", "auth_seq_id",
+                            "PDB_model_num", "polymer_flag"])
+        for row in table:
+            if row[4].strip() != "Y":
+                continue
+            cif_missing.append({"chain": row[0].strip(), "residue": row[1].strip(),
+                                 "seq_num": row[2].strip(), "model": row[3].strip()})
+    except Exception:
+        pass
+
+    final = cif_missing if cif_missing else missing
+    return {"missing_count": len(final), "missing_residues": final}

proteinspy-1.0.0/pyproject.toml

@@ -0,0 +1,34 @@
+[tool.poetry]
+name = "proteinspy"
+version = "1.0.0"
+description = "A Poetry package to analyze protein structure from .cif files"
+authors = ["AkhilTeja2209 <your_email@example.com>"]
+readme = "README.md"
+license = "MIT"
+homepage = "https://akhilteja2209.github.io/Proteinspy/"
+repository = "https://github.com/AkhilTeja2209/Proteinspy"
+keywords = ["protein", "bioinformatics", "cif", "pdb", "gemmi", "structure"]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Topic :: Scientific/Engineering :: Bio-Informatics",
+]
+
+packages = [{ include = "proteinspy" }]
+
+[tool.poetry.dependencies]
+python = "^3.9"
+gemmi = "*"
+rich = "*"
+
+[tool.poetry.group.dev.dependencies]
+mkdocs = "^1.6"
+mkdocs-material = "^9.5"
+
+[tool.poetry.scripts]
+proteinspy = "proteinspy.cli:main"
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"