Skip to content

foryourhealth111-pixel/Vibe-Skills / bundled/skills/rowan

Cloud-based quantum chemistry platform with Python API. Preferred for computational chemistry workflows including pKa prediction, geometry optimization, conformer searching, molecular property calculations, protein-ligand docking (AutoDock Vina), and AI protein cofolding (Chai-1, Boltz-1/2). Use when tasks involve quantum chemistry calculations, molecular property prediction, DFT or semiempirical methods, neural network potentials (AIMNet2), protein-ligand binding predictions, or automated computational chemistry pipelines. Provides cloud compute resources with no local setup required.

references/proteins_and_organization.md

View on GitHub
# Rowan Proteins and Organization Reference

## Table of Contents

1. [Protein Management](#protein-management)
2. [Folder Organization](#folder-organization)
3. [Project Management](#project-management)
4. [Best Practices](#best-practices)

---

## Protein Management

### Protein Class

The `Protein` class represents a protein structure stored on Rowan.

**Attributes:**

| Attribute | Type | Description |
|-----------|------|-------------|
| `uuid` | str | Unique identifier |
| `name` | str | User-assigned name |
| `data` | str | PDB structure data (lazy-loaded) |
| `sanitized` | bool | Whether structure has been cleaned |
| `public` | bool | Public visibility flag |
| `created_at` | datetime | Upload timestamp |

---

### Upload Protein from File

```python
import rowan

# Upload PDB file
protein = rowan.upload_protein(
    name="EGFR Kinase",
    file_path="protein.pdb"
)

print(f"Protein UUID: {protein.uuid}")
print(f"Name: {protein.name}")
```

---

### Create from PDB ID

Fetch structure directly from RCSB PDB database.

```python
import rowan

# Download from PDB
protein = rowan.create_protein_from_pdb_id(
    name="EGFR Kinase (1M17)",
    code="1M17"
)

print(f"Created protein: {protein.uuid}")
```

---

### Retrieve Protein

```python
import rowan

# Get by UUID
protein = rowan.retrieve_protein("protein-uuid")

# List all proteins
proteins = rowan.list_proteins()
for p in proteins:
    print(f"{p.name}: {p.uuid}")

# Filter by name
proteins = rowan.list_proteins(name="EGFR")
```

---

### Sanitize Protein

Clean up protein structure (remove waters, artifacts, fix residues).

```python
import rowan

protein = rowan.create_protein_from_pdb_id("Target", "1M17")

# Sanitize the structure
protein.sanitize()

# Check status
print(f"Sanitized: {protein.sanitized}")
```

**Sanitization performs:**
- Removes non-protein molecules (waters, ligands, ions)
- Fixes missing atoms in residues
- Resolves alternate conformations
- Standardizes residue names

---

### Update Protein Metadata

```python
import rowan

protein = rowan.retrieve_protein("protein-uuid")

# Update name
protein.update(name="EGFR Kinase Domain")

# Define binding pocket
protein.update(
    pocket={
        "center": [10.0, 20.0, 30.0],
        "size": [20.0, 20.0, 20.0]
    }
)
```

---

### Download Protein Structure

```python
import rowan

protein = rowan.retrieve_protein("protein-uuid")

# Load structure data
protein.refresh()  # Fetches PDB data if not loaded

# Download to file
protein.download_pdb_file("output.pdb")

# Or access data directly
pdb_content = protein.data
```

---

### Delete Protein

```python
import rowan

protein = rowan.retrieve_protein("protein-uuid")
protein.delete()
```

---

## Folder Organization

### Folder Class

Folders provide hierarchical organization for workflows.

**Attributes:**

| Attribute | Type | Description |
|-----------|------|-------------|
| `uuid` | str | Unique identifier |
| `name` | str | Folder name |
| `parent_uuid` | str | Parent folder UUID (None for root) |
| `starred` | bool | Starred status |
| `public` | bool | Public visibility |
| `created_at` | datetime | Creation timestamp |

---

### Create Folder

```python
import rowan

# Create root folder
folder = rowan.create_folder(name="Drug Discovery Project")

# Create subfolder
subfolder = rowan.create_folder(
    name="Lead Compounds",
    parent_uuid=folder.uuid
)
```

---

### Retrieve Folder

```python
import rowan

# Get by UUID
folder = rowan.retrieve_folder("folder-uuid")

# List all folders
folders = rowan.list_folders()
for f in folders:
    print(f"{f.name}: {f.uuid}")

# Filter
folders = rowan.list_folders(name="Project", starred=True)
```

---

### Update Folder

```python
import rowan

folder = rowan.retrieve_folder("folder-uuid")

# Rename
folder.update(name="New Name")

# Move to different parent
folder.update(parent_uuid="new-parent-uuid")

# Star folder
folder.update(starred=True)
```

---

### Print Folder Tree

Visualize folder hierarchy.

```python
import rowan

# Print structure starting from root
rowan.print_folder_tree()

# Print from specific folder
rowan.print_folder_tree(root_uuid="folder-uuid")
```

Output:
```
πŸ“ Drug Discovery Project
β”œβ”€β”€ πŸ“ Lead Compounds
β”‚   β”œβ”€β”€ πŸ“„ Lead 1 pKa (completed)
β”‚   └── πŸ“„ Lead 2 pKa (completed)
└── πŸ“ Backup Series
    └── πŸ“„ Backup 1 conformers (running)
```

---

### Delete Folder

**Warning:** Deleting a folder removes all workflows inside!

```python
import rowan

folder = rowan.retrieve_folder("folder-uuid")
folder.delete()  # Deletes folder and all contents
```

---

### Submit Workflow to Folder

```python
import rowan
import stjames

folder = rowan.create_folder(name="pKa Calculations")

mol = stjames.Molecule.from_smiles("CCO")
workflow = rowan.submit_pka_workflow(
    initial_molecule=mol,
    name="Ethanol pKa",
    folder_uuid=folder.uuid  # Organize in folder
)
```

---

### List Workflows in Folder

```python
import rowan

folder = rowan.retrieve_folder("folder-uuid")
workflows = rowan.list_workflows(folder_uuid=folder.uuid)

for wf in workflows:
    print(f"{wf.name}: {wf.status}")
```

---

## Project Management

### Project Class

Projects are top-level containers for organizing folders and workflows.

**Attributes:**

| Attribute | Type | Description |
|-----------|------|-------------|
| `uuid` | str | Unique identifier |
| `name` | str | Project name |
| `created_at` | datetime | Creation timestamp |

---

### Create Project

```python
import rowan

project = rowan.create_project(name="Cancer Drug Discovery")
print(f"Project UUID: {project.uuid}")
```

---

### Retrieve Project

```python
import rowan

# Get by UUID
project = rowan.retrieve_project("project-uuid")

# List all projects
projects = rowan.list_projects()
for p in projects:
    print(f"{p.name}: {p.uuid}")

# Get default project
default = rowan.default_project()
```

---

### Update Project

```python
import rowan

project = rowan.retrieve_project("project-uuid")
project.update(name="Renamed Project")
```

---

### Delete Project

**Warning:** Deletes all folders and workflows in project!

```python
import rowan

project = rowan.retrieve_project("project-uuid")
project.delete()
```

---

### Create Folder in Project

```python
import rowan

project = rowan.create_project("Drug Discovery")
folder = rowan.create_folder(
    name="Phase 1 Compounds",
    project_uuid=project.uuid
)
```

---

## Best Practices

### Organizing a Drug Discovery Campaign

```python
import rowan
import stjames

# Create project structure
project = rowan.create_project("EGFR Inhibitor Campaign")

# Create organized folders
target_folder = rowan.create_folder("Target Preparation", project_uuid=project.uuid)
hit_folder = rowan.create_folder("Hit Finding", project_uuid=project.uuid)
lead_folder = rowan.create_folder("Lead Optimization", project_uuid=project.uuid)

# Upload and prepare protein
protein = rowan.create_protein_from_pdb_id("EGFR", "1M17")
protein.sanitize()

# Define binding site
pocket = {
    "center": [10.0, 20.0, 30.0],  # From crystal ligand
    "size": [20.0, 20.0, 20.0]
}

# Submit docking workflows to hit folder
for smiles in hit_compounds:
    mol = stjames.Molecule.from_smiles(smiles)
    workflow = rowan.submit_docking_workflow(
        protein=protein.uuid,
        pocket=pocket,
        initial_molecule=mol,
        name=f"Dock: {smiles[:20]}",
        folder_uuid=hit_folder.uuid
    )
```

### Reusing Proteins Across Workflows

```python
import rowan

# Upload once
protein = rowan.upload_protein("My Target", "target.pdb")
protein.sanitize()

# Save UUID for later use
protein_uuid = protein.uuid

# Use in multiple workflows
for compound in compounds:
    workflow = rowan.submit_docking_workflow(
        protein=protein_uuid,  # Reuse same protein
        pocket=pocket,
        initial_molecule=compound,
        name=f"Dock: {compound.name}"
    )
```

### Folder Naming Conventions

```python
import rowan
from datetime import datetime

# Include date in folder name
date_str = datetime.now().strftime("%Y%m%d")
folder = rowan.create_folder(f"{date_str}_Lead_Optimization")

# Include project phase
folder = rowan.create_folder("Phase2_pKa_Calculations")

# Include target name
folder = rowan.create_folder("EGFR_Conformer_Search")
```

### Cleaning Up Old Workflows

```python
import rowan
from datetime import datetime, timedelta

# Find old completed workflows
old_cutoff = datetime.now() - timedelta(days=30)
workflows = rowan.list_workflows(status="completed")

for wf in workflows:
    if wf.completed_at < old_cutoff:
        # Delete data but keep metadata
        wf.delete_data()
        # Or delete entirely
        # wf.delete()
```

### Monitoring Credit Usage

```python
import rowan

# Check before submitting
user = rowan.whoami()
print(f"Available credits: {user.credits}")

# Set credit limit per workflow
workflow = rowan.submit_pka_workflow(
    initial_molecule=mol,
    name="pKa calculation",
    max_credits=10.0  # Fail if exceeds 10 credits
)
```
writing-skillsobra/superpowersUse when creating new skills, editing existing skills, or verifying skills work before deploymentStars: 323kUpdated Claude CodeCodexVerifiedInstall
xlsxanthropics/skillsUse this skill any time a spreadsheet file is the primary input or output. This means any task where the user wants to: open, read, edit, or fix an existing .xlsx, .xlsm, .xltx, .csv, or .tsv file (e.g., adding columns, computing formulas, formatting, charting, cleaning messy data); create a new spreadsheet from scratch or from other data sources; or convert between tabular file formats. Trigger especially when the user references a spreadsheet file by name or path β€” even casually (like "the xlsx in my downloads") β€” and wants something done to it or produced from it. Also trigger for cleaning or restructuring messy tabular data files (malformed rows, misplaced headers, junk data) into proper spreadsheets. The deliverable must be a spreadsheet file. Do NOT trigger when the primary deliverable is a Word document, HTML report, standalone Python script, database pipeline, or Google Sheets API integration, even if tabular data is involved.Stars: 198kUpdated Claude CodeCodexVerifiedInstall
shipping-and-launchaddyosmani/agent-skillsPrepares production launches. Use when preparing to deploy to production, or when asking what needs to be in place before shipping. Use when you need a pre-launch checklist, when setting up monitoring, when planning a staged rollout, or when you need a rollback strategy.Stars: 119kUpdated Claude CodeCodexVerifiedInstall
childhoodthedotmack/claude-memBabysit a shipped release after merge, publication, or deployment. Verify published packages, production behavior, installed plugins, and late CI or user reports until the observation window is clean; use babysit for PR readiness before release.Stars: 118kUpdated Claude CodeCodexVerifiedInstall