phasepred 1.0.0__tar.gz → 1.0.2__tar.gz

phasepred-1.0.2/CHANGELOG.md

@@ -0,0 +1,40 @@
+# Changelog
+
+## [1.0.2] - 2026-09-28
+
+Patch release for the 1.0.1 installation feedback. Model artifacts and
+training data are unchanged.
+
+### Fixed
+
+- Use `python3` in the Ubuntu venv examples.
+- Document DeepCoil's user-data installation path and show it in missing-tool
+  guidance; keep the legacy checkout environment as a fallback.
+- Show the PScore install command when `check-tools` reports it missing.
+- Let the checkout PScore runner find DBS in the installed user-data copy and
+  accept relative FASTA and output paths when invoked on its own.
+
+## [1.0.1] - 2026-09-28
+
+Patch release based on installation and prediction feedback. Model artifacts
+and training data are unchanged.
+
+### Fixed
+
+- PScore's `install.sh --check` now checks the installed user-data copy instead
+  of mistakenly checking for DBS files in the repository.
+- PhaSePred sends DeepCoil smaller sequence groups to reduce peak memory use
+  during batch prediction. A failed group reports a warning without discarding
+  successful groups; sequences shorter than 20 residues get a specific warning.
+- FCR remains available for sequences containing selenocysteine (`U`) even
+  when the Hydropathy scale cannot score that residue.
+
+### Improved
+
+- `predict` identifies proteins with missing features before the model imputes
+  those values and calculates a score.
+- The READMEs clarify that `features-from-fasta` computes four features and
+  that individual tool checks can be silent on success.
+
+The local catGRANULE scale has no value for `U`, so catGRANULE remains missing
+for such sequences and is imputed during prediction.

{phasepred-1.0.0 → phasepred-1.0.2}/MANIFEST.in

@@ -20,6 +20,7 @@
 # pixi.toml/pixi.lock, and the CI workflow. pip installs the package from the
 # index; the repository remains the route for training on the paper data.
 include environment.yml
+include CHANGELOG.md
 include NOTICE
 include README-pypi.md
 recursive-include scripts *.py *.sh *.md
@@ -31,4 +32,4 @@ recursive-include packages/catgranule/src *.py *.json *.ubj
 recursive-include packages/catgranule/tests *.py *.fasta
 recursive-include packages/catgranule/scripts *.py
 
-global-exclude *.py[cod]
+global-exclude *.py[cod]

{phasepred-1.0.0/src/phasepred.egg-info → phasepred-1.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: phasepred
-Version: 1.0.0
+Version: 1.0.2
 Summary: Paper-faithful re-implementation of the PhaSePred phase-separation predictor (Chen et al. 2022, PNAS).
 Author: Tingting Li Lab, Department of Biochemistry and Molecular Biology, School of Basic Medical Sciences, Peking University
 License-Expression: MIT
@@ -48,7 +48,24 @@ Implementation of [Chen et al. 2022 *PNAS*](https://doi.org/10.1073/pnas.2115369
 pip install phasepred
 ```
 
-Requires Python >= 3.12.
+Requires Python >= 3.12. The models and the DeepPhase table ship inside the
+package.
+
+Four feature components cannot be redistributed and need a one-time install from
+the repository:
+
+```bash
+git clone https://github.com/notwhiteblank/PhaSePred.git && cd PhaSePred
+bash tools/PScore/install.sh
+bash tools/ESpritz/install.sh
+bash tools/DeepCoil/install.sh
+bash tools/PhosphoSitePlus/install.sh   # only needed for hSaPS / hPdPS
+```
+
+The installers put their data under `~/.local/share/phasepred/`, where the
+package finds it automatically. `phasepred check-tools` prints a status row per
+component, and for every missing one the exact command that installs it. A
+complete install reports `9 OK`.
 
 ## Use
 
@@ -65,18 +82,6 @@ Input can also be UniProt accessions:
 phasepred predict --ids "P35637,Q9Y2W1" --mode SaPS --output scores.csv
 ```
 
-## Feature tools
-
-Five of the nine feature components ship with the package and work immediately.
-The rest need a one-time install:
-
-```bash
-phasepred check-tools
-```
-
-This prints a status row per component, and for every missing one the exact
-command that installs it.
-
 ## More
 
 Source, training data, retraining and AUC validation against the paper:

{phasepred-1.0.0 → phasepred-1.0.2}/README-pypi.md

@@ -9,7 +9,24 @@ Implementation of [Chen et al. 2022 *PNAS*](https://doi.org/10.1073/pnas.2115369
 pip install phasepred
 ```
 
-Requires Python >= 3.12.
+Requires Python >= 3.12. The models and the DeepPhase table ship inside the
+package.
+
+Four feature components cannot be redistributed and need a one-time install from
+the repository:
+
+```bash
+git clone https://github.com/notwhiteblank/PhaSePred.git && cd PhaSePred
+bash tools/PScore/install.sh
+bash tools/ESpritz/install.sh
+bash tools/DeepCoil/install.sh
+bash tools/PhosphoSitePlus/install.sh   # only needed for hSaPS / hPdPS
+```
+
+The installers put their data under `~/.local/share/phasepred/`, where the
+package finds it automatically. `phasepred check-tools` prints a status row per
+component, and for every missing one the exact command that installs it. A
+complete install reports `9 OK`.
 
 ## Use
 
@@ -26,18 +43,6 @@ Input can also be UniProt accessions:
 phasepred predict --ids "P35637,Q9Y2W1" --mode SaPS --output scores.csv
 ```
 
-## Feature tools
-
-Five of the nine feature components ship with the package and work immediately.
-The rest need a one-time install:
-
-```bash
-phasepred check-tools
-```
-
-This prints a status row per component, and for every missing one the exact
-command that installs it.
-
 ## More
 
 Source, training data, retraining and AUC validation against the paper:

{phasepred-1.0.0 → phasepred-1.0.2}/README.md

@@ -40,16 +40,24 @@ The ten features, of which the 8-feature modes use all but the last two:
 
 ### Install
 
-The package needs Python `>=3.12`. Pick one of four routes:
+Python `>=3.12`. Clone the repository and install:
 
 ```bash
-pixi install                                                        # pixi
-uv venv --python 3.12 && uv pip install .                           # uv
-conda env create -f environment.yml && conda activate phasepred     # conda
-python -m venv .venv && .venv/bin/pip install -e . -e packages/catgranule   # plain venv
+git clone https://github.com/notwhiteblank/PhaSePred.git && cd PhaSePred
+pixi install
 ```
 
-Install the external tools separately:
+`uv`, `conda` and a plain venv work just as well:
+
+```bash
+uv venv --python 3.12 && uv pip install .
+conda env create -f environment.yml && conda activate phasepred
+python3 -m venv .venv && .venv/bin/pip install -e . -e packages/catgranule
+```
+
+Then install the external feature tools. Each installer is idempotent and puts
+its data under `~/.local/share/phasepred/`, where the package finds it
+automatically:
 
 ```bash
 bash tools/SEG/install.sh
@@ -61,14 +69,21 @@ bash tools/LocalCIDER/install.sh
 bash tools/PhosphoSitePlus/install.sh   # only needed for hSaPS / hPdPS
 ```
 
-Then check:
+`check-tools` confirms the result; a complete install reports `9 OK`:
 
 ```bash
-phasepred check-tools          # table, with an install hint on every MISSING row
+phasepred check-tools          # status table, with an install hint per missing component
 phasepred check-tools --strict # exits 1 when a required tool is missing; use this in scripts and CI
 ```
 
-`SEG`, `PLAAC`, `LocalCIDER`, `catGRANULE` and `DeepPhase` ship with the package and work immediately. `PScore`, `ESpritz`, `DeepCoil` and `PhosphoSitePlus` need the installers above.
+The models and the DeepPhase table ship inside the package, so nothing else is
+needed to predict. `SEG`, `PLAAC`, `LocalCIDER` and `catGRANULE` also ship with
+it; the installers above cover the four components that cannot be redistributed.
+
+Installing from PyPI instead (`pip install phasepred`) gives you the same
+package. The tool installers live in `tools/`, which is part of the repository
+rather than the wheel, so clone it to run them — after that everything resolves
+the same way.
 
 ### Run
 
@@ -93,7 +108,25 @@ phasepred predict --fasta my.fasta --ids "P35637" --mode SaPS --output scores.cs
 phasepred features-from-fasta --input my.fasta --output features.csv
 ```
 
-The output CSV carries the numeric value of every feature alongside `score`.
+The `predict` output CSV carries every model feature alongside `score`. If a
+feature is unavailable for a protein, `predict` lists the missing columns on
+stderr and the model imputes them before scoring. A score with missing features
+should be interpreted with that limitation. For example, selenocysteine (`U`)
+has no value in the local catGRANULE scale, so that feature stays empty; FCR
+is still computed from the charged residues in the original sequence.
+
+`features-from-fasta` is a smaller four-feature command: Hydropathy, FCR,
+ESpritz IDR fraction, and SEG LCR fraction. Use `predict` when the complete
+model feature table is needed.
+
+DeepCoil predictions are sent in bounded groups (at most four proteins and
+normally 4,000 residues per call; a single longer protein stays intact) to
+reduce peak memory use. A failed group emits a
+warning and its DeepCoil values are imputed. If the operating system still
+kills a group for memory, split the FASTA into smaller files or increase the
+available memory. Sequences shorter than 20 residues are skipped with a
+specific warning. `phasepred check-tools` is the consolidated status display;
+individual `run --check` commands may be silent when they succeed.
 
 ## Reproduction
 

{phasepred-1.0.0 → phasepred-1.0.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "phasepred"
-version = "1.0.0"
+version = "1.0.2"
 description = "Paper-faithful re-implementation of the PhaSePred phase-separation predictor (Chen et al. 2022, PNAS)."
 readme = { file = "README-pypi.md", content-type = "text/markdown" }
 license = "MIT"

{phasepred-1.0.0 → phasepred-1.0.2}/src/phasepred/__init__.py

@@ -1,3 +1,3 @@
 """PhaSePred reconstruction package."""
 
-__version__ = "1.0.0"
+__version__ = "1.0.2"

{phasepred-1.0.0 → phasepred-1.0.2}/src/phasepred/cli.py

@@ -18,7 +18,7 @@ from sklearn.metrics import average_precision_score, roc_auc_score
 
 from phasepred import __version__ as _phasepred_version
 from phasepred import data
-from phasepred.features import FeatureSchemaError, compute_native_features
+from phasepred.features import FeatureSchemaError, compute_fcr, compute_native_features
 from phasepred.legacy_features import (
     compute_lcr_features,
     compute_phosphosite_frequencies,
@@ -143,10 +143,23 @@ def features_from_fasta(
     idr_rows = _compute_espritz_idr_fraction(records)
     lcr_rows = _compute_lcr_fraction(records)
     for record in records:
+        try:
+            native = compute_native_features(record.sequence)
+        except FeatureSchemaError as exc:
+            native = {
+                "length": float(len(record.sequence)),
+                "Hydropathy": float("nan"),
+                "FCR": compute_fcr(record.sequence),
+            }
+            typer.echo(
+                f"WARNING: {record.accession}: Hydropathy unavailable ({exc}); "
+                "FCR was computed from the original sequence.",
+                err=True,
+            )
         row = {
             "UniprotEntry": record.accession,
             "sequence": record.sequence,
-            **compute_native_features(record.sequence),
+            **native,
         }
         row["espritz-idr-fraction"] = idr_rows.get(record.accession, float("nan"))
         row["lcr-fraction"] = lcr_rows.get(record.accession, float("nan"))
@@ -593,6 +606,24 @@ def predict(
     typer.echo(f"Computing features for {len(records)} protein(s), mode={mode}...")
     feature_df = compute_all_features(records, include_human=is_human)
 
+    columns = HUMAN_FEATURE_COLUMNS if is_human else BASE_FEATURE_COLUMNS
+    missing_by_row = feature_df[list(columns)].isna()
+    affected = missing_by_row.any(axis=1)
+    if affected.any():
+        typer.echo(
+            f"WARNING: {int(affected.sum())}/{len(feature_df)} protein(s) have missing "
+            "features; the model will impute them before scoring.",
+            err=True,
+        )
+        for index in feature_df.index[affected][:8]:
+            absent = [column for column in columns if missing_by_row.loc[index, column]]
+            typer.echo(
+                f"  {feature_df.loc[index, 'UniprotEntry']}: {', '.join(absent)}",
+                err=True,
+            )
+        if affected.sum() > 8:
+            typer.echo(f"  ... and {int(affected.sum()) - 8} more", err=True)
+
     # Load model(s)
     model_path_or_dir = chosen_models_dir / f"{mode}.joblib"
     if model_path_or_dir.exists():
@@ -632,7 +663,6 @@ def predict(
         )
 
     # Predict
-    columns = HUMAN_FEATURE_COLUMNS if is_human else BASE_FEATURE_COLUMNS
     predictions = predict_scores(models, feature_df, list(columns))
 
     # Merge features for informative output

{phasepred-1.0.0 → phasepred-1.0.2}/src/phasepred/data/tools/DeepCoil/README.md

@@ -27,8 +27,10 @@ tools/DeepCoil/
 └── README.md      this file
 ```
 
-No entity is vendored — the tool lives in an isolated Python 3.8 conda env
-at `.external_envs/deepcoil` (gitignored).
+No entity is vendored — the tool lives in an isolated Python 3.8 conda env.
+New installations use `~/.local/share/phasepred/envs/deepcoil` by default,
+or `$XDG_DATA_HOME/phasepred/envs/deepcoil` / `$PHASEPRED_DATA_ROOT/envs/deepcoil`
+when set. Existing `.external_envs/deepcoil` environments remain supported.
 
 ## Install
 
@@ -38,14 +40,12 @@ bash tools/DeepCoil/install.sh --check  # verify env/bin/deepcoil present
 ```
 
 Overrides: `DEEPCOIL_ENV_PREFIX=/path/to/env DEEPCOIL_PYTHON_VERSION=3.8
-DEEPCOIL_VERSION=2.0.2`. The env prefix declared in
-`manifest.toml` `[runtime]` is `.external_envs/deepcoil`; the manifest
-`env_prefix` and the wrapper's `DEEPCOIL_ENV_PREFIX` override agree.
+DEEPCOIL_VERSION=2.0.2`. The `manifest.toml` `[runtime]` prefix names the
+legacy checkout fallback; the installer and runner prefer the user data root.
 
 ## Usage
 
 ```bash
-DEEPCOIL_ENV_PREFIX="$PWD/.external_envs/deepcoil" \
 tools/DeepCoil/run -i in.fasta -out_path /tmp/dc_out -n_cpu 4
 tools/DeepCoil/run --check
 ```
@@ -58,4 +58,4 @@ DeepCoil sanitizes output filenames (alnum + `_`). Writes
 ## Attribution
 
 Reference the DeepCoil meta-server page / Ludwiczak et al. (2019) when
-publishing scores produced by this tool.
+publishing scores produced by this tool.

{phasepred-1.0.0 → phasepred-1.0.2}/src/phasepred/data/tools/DeepCoil/manifest.toml

@@ -15,4 +15,4 @@ description = "Writes per-accession '<safe_id>.out' tab-separated files (aa, cc,
 
 [install]
 command = "bash tools/DeepCoil/install.sh"
-hint = "DeepCoil has no upstream license (not redistributable). Build the isolated Python 3.8 conda env with deepcoil==2.0.2: bash tools/DeepCoil/install.sh (env at .external_envs/deepcoil; override with DEEPCOIL_ENV_PREFIX)."
+hint = "DeepCoil has no upstream license (not redistributable). Install the isolated Python 3.8 env with deepcoil==2.0.2: bash tools/DeepCoil/install.sh (default: ~/.local/share/phasepred/envs/deepcoil; override with DEEPCOIL_ENV_PREFIX)."

{phasepred-1.0.0 → phasepred-1.0.2}/src/phasepred/data/tools/PScore/README.md

@@ -43,8 +43,9 @@ bash tools/PScore/install.sh --check  # verify predictor + DBS present
 
 ## Usage
 
-Run from anywhere; the wrapper `cd`s into `SourceCodeS2/` because the
-predictor reads `DBS/` relative to its own location:
+Run from anywhere with relative or absolute FASTA and output paths. The wrapper
+uses the installed user-data `SourceCodeS2/DBS/` when the checkout has no DBS,
+then changes into `SourceCodeS2/` as required by the predictor:
 
 ```bash
 tools/PScore/run input.fasta -output pscore.tsv -overwrite -mute
@@ -62,4 +63,4 @@ Standard output: one `PScore:  <value>  >ACC` line per scored accession
 
 Carry the reference above and the CC-BY 4.0 notice. The archived
 `SourceCodeS2/README.txt` documents the original authors. Data derived from
-the upstream `DBS/` must be attributed to Vernon et al. (2018).
+the upstream `DBS/` must be attributed to Vernon et al. (2018).

{phasepred-1.0.0 → phasepred-1.0.2}/src/phasepred/data/tools/PScore/install.sh

@@ -85,7 +85,7 @@ policy="$(manifest_get sha256_policy)"
 if [[ "$mode" == "check" ]]; then
   if available_in "$target"; then
     echo "PScore: ok ($target)"
-    exec "$pkg_dir/run" --check
+    exec "$target/run" --check
   fi
   if available_in "$pkg_dir"; then
     echo "PScore: ok ($pkg_dir, vendored checkout)"

{phasepred-1.0.0 → phasepred-1.0.2}/src/phasepred/data/tools/PScore/manifest.toml

@@ -28,4 +28,4 @@ description = "One 'PScore:  <value>  >ACC' line per scored accession (via stdou
 
 [install]
 command = "bash tools/PScore/install.sh"
-hint = "PScore code is vendored (CC-BY 4.0, eLife 31486). Data (DBS) is gitignored: bash tools/PScore/install.sh --check verifies script + DBS."
+hint = "PScore is unavailable. Install its code and DBS with: bash tools/PScore/install.sh (then verify: bash tools/PScore/install.sh --check)."

{phasepred-1.0.0 → phasepred-1.0.2}/src/phasepred/data/tools/PScore/run

@@ -12,6 +12,27 @@ pkg_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 src_dir="$pkg_dir/SourceCodeS2"
 script="$src_dir/elife_phase_separation_predictor.py"
 
+# The installer writes DBS into the user data root, not the checkout. A
+# checkout runner can use that complete installation when its local DBS is
+# absent. An installed runner continues to use its adjacent SourceCodeS2.
+if [[ ! -d "$src_dir/DBS" ]]; then
+  data_root=""
+  if [[ -n "${PHASEPRED_DATA_ROOT:-}" ]]; then
+    data_root="$PHASEPRED_DATA_ROOT"
+  elif [[ -n "${XDG_DATA_HOME:-}" ]]; then
+    data_root="$XDG_DATA_HOME/phasepred"
+  elif [[ -n "${HOME:-}" ]]; then
+    data_root="$HOME/.local/share/phasepred"
+  fi
+  if [[ -n "$data_root" ]]; then
+    installed_src="$data_root/pscore/SourceCodeS2"
+    if [[ -f "$installed_src/elife_phase_separation_predictor.py" && -d "$installed_src/DBS" ]]; then
+      src_dir="$(cd "$installed_src" && pwd -P)"
+      script="$src_dir/elife_phase_separation_predictor.py"
+    fi
+  fi
+fi
+
 if [[ "${1:-}" == "--check" ]]; then
   if [[ ! -f "$script" ]]; then
     echo "PScore predictor script missing: $script" >&2
@@ -38,6 +59,10 @@ if [[ ! -f "$script" ]]; then
   echo "PScore predictor script missing: $script" >&2
   exit 1
 fi
+if [[ ! -d "$src_dir/DBS" ]]; then
+  echo "PScore DBS data missing: $src_dir/DBS (gitignored). Install with: bash $pkg_dir/install.sh" >&2
+  exit 1
+fi
 
 python_cmd=""
 for cand in "${PHASEPRED_PYTHON:-}" python3 python; do
@@ -52,5 +77,17 @@ if [[ -z "$python_cmd" ]]; then
   exit 1
 fi
 
+# The predictor must run from SourceCodeS2 so its relative DBS path works.
+# Resolve the caller's relative FASTA and -output paths before changing cwd.
+args=("$@")
+if [[ "${args[0]}" != /* ]]; then
+  args[0]="$PWD/${args[0]}"
+fi
+for ((i = 1; i < ${#args[@]} - 1; i++)); do
+  if [[ "${args[i]}" == "-output" && "${args[i+1]}" != /* ]]; then
+    args[i+1]="$PWD/${args[i+1]}"
+  fi
+done
+
 cd "$src_dir"
-exec "$python_cmd" "$script" "$@"
+exec "$python_cmd" "$script" "${args[@]}"

{phasepred-1.0.0 → phasepred-1.0.2}/src/phasepred/features.py

@@ -58,6 +58,14 @@ class FeatureSchemaError(ValueError):
     """Raised when feature inputs do not satisfy a model schema."""
 
 
+def compute_fcr(sequence: str) -> float:
+    """Charged-residue fraction; defined even when another scale lacks a residue."""
+    normalized = sequence.upper()
+    if not normalized:
+        raise FeatureSchemaError("Cannot compute features for an empty sequence")
+    return sum(residue in CHARGED_RESIDUES for residue in normalized) / len(normalized)
+
+
 def compute_native_features(sequence: str) -> dict[str, float]:
     normalized = sequence.upper()
     if not normalized:
@@ -69,7 +77,7 @@ def compute_native_features(sequence: str) -> dict[str, float]:
     return {
         "length": float(length),
         "Hydropathy": SequenceParameters(normalized).get_uversky_hydropathy(),
-        "FCR": sum(1 for residue in normalized if residue in CHARGED_RESIDUES) / length,
+        "FCR": compute_fcr(normalized),
     }
 
 

{phasepred-1.0.0 → phasepred-1.0.2}/src/phasepred/predictor.py

@@ -33,6 +33,7 @@ def compute_all_features(
     from catgranule import CatGranuleInputError, score_sequence
 
     from phasepred import tools
+    from phasepred.features import compute_fcr
     from phasepred.features import compute_native_features as _native
 
     t_start = time.time()
@@ -55,9 +56,9 @@ def compute_all_features(
             native_rows.append(
                 {
                     "UniprotEntry": r["accession"],
-                    "length": float("nan"),
+                    "length": float(len(seq)),
                     "Hydropathy": float("nan"),
-                    "FCR": float("nan"),
+                    "FCR": compute_fcr(seq) if seq else float("nan"),
                 }
             )
 
@@ -212,4 +213,4 @@ def _model_predict_proba(model, X: pd.DataFrame) -> np.ndarray:
     if hasattr(model, "estimator"):
         # ModelArtifact wrapper
         return model.estimator.predict_proba(X)
-    return model.predict_proba(X)
+    return model.predict_proba(X)

{phasepred-1.0.0 → phasepred-1.0.2}/src/phasepred/tool_features.py

@@ -23,7 +23,7 @@ from typing import cast
 import pandas as pd
 
 from phasepred import tools
-from phasepred.features import CHARGED_RESIDUES, compute_native_features
+from phasepred.features import CHARGED_RESIDUES, compute_fcr, compute_native_features
 
 # Tool vocabulary (web API order).
 TOOL_NAMES = [
@@ -94,7 +94,10 @@ def compute_tool_features(
         try:
             native[r["accession"]] = compute_native_features(str(r["sequence"]).upper())
         except Exception:
-            native[r["accession"]] = {}
+            seq = str(r["sequence"]).upper()
+            native[r["accession"]] = {
+                "FCR": compute_fcr(seq) if seq else float("nan")
+            }
 
     if "hydropathy" in requested:
         for i, r in enumerate(records):