cloudfit-core 0.1.0__py3-none-any.whl

cloudfit/__init__.py

@@ -0,0 +1,34 @@
+"""cloudfit-core: Cloud-agnostic machine type scoring engine."""
+
+from .models import (
+    WorkloadProfile,
+    MachineType,
+    ScoredInstance,
+    OptimizeFor,
+    Archetype,
+    DiskSpec,
+    GPUSpec,
+    SchedulingSpec,
+)
+from .scorer import rank, score_instance, score
+from .filter import hard_floor_check, apply_floors
+from .disk import compute_disk_tb, compute_disk_breakdown, list_sequencers
+from .yaml_loader import from_yaml, from_dict
+
+__version__ = "0.1.0"
+__author__ = "Chaitanya Krishna Kasaraneni"
+__license__ = "Apache-2.0"
+
+__all__ = [
+    # models
+    "WorkloadProfile", "MachineType", "ScoredInstance",
+    "OptimizeFor", "Archetype", "DiskSpec", "GPUSpec", "SchedulingSpec",
+    # scorer — both names are public API
+    "rank", "score_instance", "score",
+    # filter
+    "hard_floor_check", "apply_floors",
+    # disk
+    "compute_disk_tb", "compute_disk_breakdown", "list_sequencers",
+    # yaml
+    "from_yaml", "from_dict",
+]

cloudfit/disk.py

@@ -0,0 +1,191 @@
+"""Dynamic disk sizing for sequencing workloads.
+
+Computes total scratch disk required for a sequencing demultiplexing run
+from experiment parameters rather than using a fixed estimate.
+
+Disk components
+---------------
+    input_gb        Raw sequencer output (compressed or uncompressed format)
+    output_gb       Demultiplexed output files (FASTQ)
+    tmp_gb          Working directory during processing (~35% of input)
+    retained_input_gb  Raw input kept post-run (if retain_input=True)
+
+Compressed vs uncompressed input
+---------------------------------
+    Some sequencers write a compressed input format that is ~4x smaller
+    than the uncompressed equivalent before demultiplexing. Output file
+    size is the same regardless of input format.
+
+Safety margin
+-------------
+    Applied to the total before returning. Default 20%.
+"""
+
+from __future__ import annotations
+from dataclasses import dataclass
+
+
+@dataclass
+class _FlowcellProfile:
+    label: str
+    gb_per_lane: float
+    max_lanes: int
+    compressed: bool    # True if sequencer writes compressed input format
+
+
+_SEQUENCER_PROFILES: dict[str, list[_FlowcellProfile]] = {
+    "miseq": [
+        _FlowcellProfile("nano",     gb_per_lane=0.8,    max_lanes=1, compressed=False),
+        _FlowcellProfile("micro",    gb_per_lane=1.5,    max_lanes=1, compressed=False),
+        _FlowcellProfile("standard", gb_per_lane=15.0,   max_lanes=1, compressed=False),
+    ],
+    "nextseq": [
+        _FlowcellProfile("mid",      gb_per_lane=40.0,   max_lanes=4, compressed=False),
+        _FlowcellProfile("high",     gb_per_lane=120.0,  max_lanes=4, compressed=False),
+    ],
+    "novaseq_6000": [
+        _FlowcellProfile("sp",       gb_per_lane=200.0,  max_lanes=2, compressed=False),
+        _FlowcellProfile("s1",       gb_per_lane=400.0,  max_lanes=2, compressed=False),
+        _FlowcellProfile("s2",       gb_per_lane=500.0,  max_lanes=4, compressed=False),
+        _FlowcellProfile("s4",       gb_per_lane=1200.0, max_lanes=4, compressed=False),
+    ],
+    "novaseq_x": [
+        _FlowcellProfile("1.5b",     gb_per_lane=380.0,  max_lanes=2, compressed=True),
+        _FlowcellProfile("10b",      gb_per_lane=600.0,  max_lanes=8, compressed=True),
+        _FlowcellProfile("25b",      gb_per_lane=1500.0, max_lanes=8, compressed=True),
+    ],
+    "hiseq": [
+        _FlowcellProfile("rapid",    gb_per_lane=150.0,  max_lanes=2, compressed=False),
+        _FlowcellProfile("high",     gb_per_lane=400.0,  max_lanes=8, compressed=False),
+    ],
+}
+
+# Compressed input format is ~4x smaller than uncompressed equivalent
+_COMPRESSION_FACTOR = 0.25
+
+# Output files are ~1.4x the (uncompressed-equivalent) input size
+_OUTPUT_MULTIPLIER = 1.40
+
+# Reads that don't match any sample add ~8% to output
+_UNDETERMINED_FACTOR = 1.08
+
+# Temp/working directory is ~35% of input during processing
+_TMP_FRACTION = 0.35
+
+
+@dataclass
+class DiskBreakdown:
+    """Detailed breakdown of disk components in GB."""
+    input_gb: float
+    output_gb: float
+    tmp_gb: float
+    retained_input_gb: float
+    subtotal_gb: float
+    safety_margin: float
+    total_gb: float
+
+    @property
+    def total_tb(self) -> float:
+        return self.total_gb / 1000
+
+
+def compute_disk_tb(
+    sequencer: str,
+    flowcell: str,
+    lanes: int,
+    *,
+    samples: int = 96,
+    retain_input: bool = False,
+    keep_undetermined: bool = False,
+    safety_margin: float = 0.20,
+) -> float:
+    """Compute total scratch disk required in TB.
+
+    Args:
+        sequencer:          Sequencer model key (e.g. "novaseq_6000", "miseq")
+        flowcell:           Flowcell type key (e.g. "s4", "nano", "high")
+        lanes:              Number of lanes used in this run
+        samples:            Number of samples (reserved for future use)
+        retain_input:       If True, raw input files are kept post-run
+        keep_undetermined:  If True, unmatched reads are written to disk (+8%)
+        safety_margin:      Fractional headroom added to total (default 0.20)
+
+    Returns:
+        Total disk required in TB (with safety margin applied).
+
+    Raises:
+        ValueError: If sequencer or flowcell key is not recognised.
+    """
+    breakdown = compute_disk_breakdown(
+        sequencer=sequencer,
+        flowcell=flowcell,
+        lanes=lanes,
+        samples=samples,
+        retain_input=retain_input,
+        keep_undetermined=keep_undetermined,
+        safety_margin=safety_margin,
+    )
+    return round(breakdown.total_tb, 2)
+
+
+def compute_disk_breakdown(
+    sequencer: str,
+    flowcell: str,
+    lanes: int,
+    *,
+    samples: int = 96,
+    retain_input: bool = False,
+    keep_undetermined: bool = False,
+    safety_margin: float = 0.20,
+) -> DiskBreakdown:
+    """Compute a full disk breakdown with all components in GB."""
+    seq_key = sequencer.lower().replace("-", "_").replace(" ", "_")
+    fc_key  = flowcell.lower().replace("-", "_").replace(" ", "_")
+
+    if seq_key not in _SEQUENCER_PROFILES:
+        raise ValueError(
+            f"Unknown sequencer {sequencer!r}. "
+            f"Known: {list(_SEQUENCER_PROFILES)}"
+        )
+
+    profiles = _SEQUENCER_PROFILES[seq_key]
+    fc_profile = next((p for p in profiles if p.label == fc_key), None)
+    if fc_profile is None:
+        known = [p.label for p in profiles]
+        raise ValueError(
+            f"Unknown flowcell {flowcell!r} for {sequencer!r}. "
+            f"Known flowcells: {known}"
+        )
+
+    lanes = min(lanes, fc_profile.max_lanes)
+
+    # Apply compression factor to input only — output is always full size
+    compression = _COMPRESSION_FACTOR if fc_profile.compressed else 1.0
+    input_gb = fc_profile.gb_per_lane * lanes * compression
+
+    undetermined_factor = _UNDETERMINED_FACTOR if keep_undetermined else 1.0
+    output_gb = input_gb * _OUTPUT_MULTIPLIER * undetermined_factor
+
+    tmp_gb            = input_gb * _TMP_FRACTION
+    retained_input_gb = input_gb if retain_input else 0.0
+
+    subtotal_gb = input_gb + output_gb + tmp_gb + retained_input_gb
+    total_gb    = subtotal_gb * (1 + safety_margin)
+
+    return DiskBreakdown(
+        input_gb=round(input_gb, 1),
+        output_gb=round(output_gb, 1),
+        tmp_gb=round(tmp_gb, 1),
+        retained_input_gb=round(retained_input_gb, 1),
+        subtotal_gb=round(subtotal_gb, 1),
+        safety_margin=safety_margin,
+        total_gb=round(total_gb, 1),
+    )
+
+
+def list_sequencers() -> dict[str, list[str]]:
+    """Return all known sequencer/flowcell combinations."""
+    return {
+        seq: [fc.label for fc in profiles]
+        for seq, profiles in _SEQUENCER_PROFILES.items()
+    }

cloudfit/filter.py

@@ -0,0 +1,76 @@
+"""Hard floor filters for cloudfit-core.
+
+Hard floors run before scoring and eliminate instances that cannot
+satisfy the workload requirements, regardless of their composite score.
+"""
+
+from __future__ import annotations
+from .models import WorkloadProfile, MachineType
+
+
+def hard_floor_check(instance: MachineType, profile: WorkloadProfile) -> str | None:
+    """Return a disqualify reason string if the instance fails any hard floor.
+
+    Returns None if the instance passes all floors and is eligible for scoring.
+
+    Floors checked (in order):
+        1. RAM — instance.ram_gb >= profile.ram_floor_gb (or ram_gb if no floor set)
+        2. vCPU — instance.vcpu >= profile.vcpu
+        3. GPU presence — if profile.gpu.required, instance must have gpu_count > 0
+        4. GPU VRAM — if profile.gpu.vram_gb set, instance.gpu_vram_gb must meet it
+        5. Status — tombstoned instances are always disqualified
+    """
+    # 1. RAM floor
+    floor_ram = profile.ram_floor_gb if profile.ram_floor_gb is not None else profile.ram_gb
+    if instance.ram_gb < floor_ram:
+        return (
+            f"RAM {instance.ram_gb:.0f} GB < required {floor_ram:.0f} GB"
+        )
+
+    # 2. vCPU floor
+    if instance.vcpu < profile.vcpu:
+        return f"vCPU {instance.vcpu} < required {profile.vcpu}"
+
+    # 3. GPU presence
+    if profile.gpu.required and instance.gpu_count == 0:
+        return "GPU required but instance has no GPU"
+
+    # 4. GPU VRAM
+    if (
+        profile.gpu.required
+        and profile.gpu.vram_gb is not None
+        and instance.gpu_vram_gb is not None
+        and instance.gpu_vram_gb < profile.gpu.vram_gb
+    ):
+        return (
+            f"GPU VRAM {instance.gpu_vram_gb} GB < required {profile.gpu.vram_gb} GB"
+        )
+
+    # 5. Tombstoned instances are never recommended
+    if instance.status == "tombstoned":
+        return f"Instance {instance.id!r} is tombstoned — no longer available from {instance.provider}"
+
+    return None
+
+
+def apply_floors(
+    instances: list[MachineType],
+    profile: WorkloadProfile,
+) -> tuple[list[MachineType], list[tuple[MachineType, str]]]:
+    """Partition instances into (qualified, disqualified) lists.
+
+    Returns:
+        qualified:    instances that passed all hard floors
+        disqualified: list of (instance, reason) tuples that failed
+    """
+    qualified: list[MachineType] = []
+    disqualified: list[tuple[MachineType, str]] = []
+
+    for inst in instances:
+        reason = hard_floor_check(inst, profile)
+        if reason is None:
+            qualified.append(inst)
+        else:
+            disqualified.append((inst, reason))
+
+    return qualified, disqualified

cloudfit/models.py

@@ -0,0 +1,84 @@
+"""Core data models for cloudfit-core."""
+
+from __future__ import annotations
+from enum import Enum
+from typing import Optional
+from pydantic import BaseModel, Field
+
+
+class OptimizeFor(str, Enum):
+    cost = "cost"
+    balanced = "balanced"
+    performance = "performance"
+    availability = "availability"
+
+
+class Archetype(str, Enum):
+    io = "io"           # disk-saturating (BCLConvert, BWA)
+    cpu = "cpu"         # thread-parallel (GATK, Trinity)
+    mem = "mem"         # large index / reference (Kraken2, Cell Ranger)
+    gpu = "gpu"         # GPU inference (AlphaFold, Parabricks)
+    burst = "burst"     # scatter-gather fleet (Nextflow, Snakemake)
+
+
+class GPUSpec(BaseModel):
+    required: bool = False
+    vram_gb: Optional[int] = None
+
+
+class DiskSpec(BaseModel):
+    sizing: str = "static"
+    scratch_tb: Optional[float] = None
+    preferred: str = "network_ssd"
+    safety_margin: float = 0.20
+
+
+class SchedulingSpec(BaseModel):
+    spot: bool = False
+    restart_tolerant: bool = False
+
+
+class WorkloadProfile(BaseModel):
+    """Describes the resource requirements of a computational workload."""
+    vcpu: int = Field(gt=0)
+    ram_gb: float = Field(gt=0)
+    ram_floor_gb: Optional[float] = None
+    workload: str = "generic"
+    archetype: Archetype = Archetype.cpu
+    tool: Optional[str] = None
+    parallelism: str = "sample"
+    disk: DiskSpec = Field(default_factory=DiskSpec)
+    gpu: GPUSpec = Field(default_factory=GPUSpec)
+    scheduling: SchedulingSpec = Field(default_factory=SchedulingSpec)
+    optimize_for: OptimizeFor = OptimizeFor.balanced
+    providers: list[str] = Field(default_factory=lambda: ["gcp", "aws"])
+    weights: Optional[dict[str, float]] = None
+
+
+class MachineType(BaseModel):
+    """A cloud provider machine type with specs and pricing."""
+    id: str
+    provider: str
+    vcpu: int
+    ram_gb: float
+    price_hr: float
+    local_ssd_tb: float = 0.0
+    gpu_count: int = 0
+    gpu_vram_gb: Optional[int] = None
+    region: str = "us-central1"
+    status: str = "active"
+    generation: Optional[str] = None
+
+
+class ScoredInstance(BaseModel):
+    """A MachineType with its composite score and sub-scores."""
+    instance: MachineType
+    score: float
+    cost_score: float
+    perf_score: float
+    avail_score: float
+    disqualified: bool = False
+    disqualify_reason: Optional[str] = None
+
+    def __lt__(self, other: "ScoredInstance") -> bool:
+        return self.score < other.score

cloudfit/providers/base.py

@@ -0,0 +1,23 @@
+"""Abstract base class for cloudfit provider plugins."""
+
+from abc import ABC, abstractmethod
+from ..models import MachineType
+
+
+class Provider(ABC):
+    """Interface that all cloudfit provider packages must implement."""
+
+    @abstractmethod
+    def fetch_instances(self, region: str) -> list[MachineType]:
+        """Fetch all available machine types for a region."""
+        ...
+
+    @abstractmethod
+    def get_pricing(self, instance_id: str, region: str) -> float:
+        """Return on-demand price per hour for an instance in a region."""
+        ...
+
+    @abstractmethod
+    def get_availability(self, instance_id: str, region: str) -> float:
+        """Return availability score 0.0–1.0 (1.0 = actively maintained)."""
+        ...

cloudfit/scorer.py

@@ -0,0 +1,129 @@
+"""Weighted scoring engine for cloudfit-core."""
+
+from __future__ import annotations
+from .models import WorkloadProfile, MachineType, ScoredInstance, OptimizeFor
+
+WEIGHT_MATRIX: dict[str, dict[str, float]] = {
+    OptimizeFor.cost:         {"cost": 0.70, "perf": 0.20, "avail": 0.10},
+    OptimizeFor.balanced:     {"cost": 0.33, "perf": 0.34, "avail": 0.33},
+    OptimizeFor.performance:  {"cost": 0.10, "perf": 0.80, "avail": 0.10},
+    OptimizeFor.availability: {"cost": 0.10, "perf": 0.20, "avail": 0.70},
+}
+
+# Max price reference for normalizing cost score (~$35/hr covers most instances)
+_MAX_PRICE_HR = 35.0
+
+# Normalize long-form weight keys to short internal keys.
+# Users may pass "performance" or "availability" (as documented in README);
+# the engine uses "perf" and "avail" internally.
+_KEY_ALIASES: dict[str, str] = {
+    "performance": "perf",
+    "availability": "avail",
+}
+
+
+def _normalize_weights(weights: dict[str, float]) -> dict[str, float]:
+    """Accept both short (perf/avail) and long (performance/availability) keys."""
+    return {_KEY_ALIASES.get(k, k): v for k, v in weights.items()}
+
+
+def _cost_score(instance: MachineType) -> float:
+    """Lower price → higher score. Normalized 0–1."""
+    return max(0.0, 1.0 - (instance.price_hr / _MAX_PRICE_HR))
+
+
+def _perf_score(instance: MachineType, profile: WorkloadProfile) -> float:
+    """Higher vCPU + RAM density relative to request → higher score."""
+    vcpu_ratio = min(instance.vcpu / max(profile.vcpu, 1), 2.0) / 2.0
+    ram_ratio  = min(instance.ram_gb / max(profile.ram_gb, 1), 2.0) / 2.0
+    return vcpu_ratio * 0.5 + ram_ratio * 0.5
+
+
+def _avail_score(instance: MachineType) -> float:
+    """Active > deprecated > tombstoned."""
+    return {"active": 1.0, "deprecated": 0.4, "tombstoned": 0.0}.get(
+        instance.status, 0.5
+    )
+
+
+def _hard_floor_check(instance: MachineType, profile: WorkloadProfile) -> str | None:
+    """Return a disqualify reason string if this instance fails any hard floor."""
+    floor_ram = profile.ram_floor_gb if profile.ram_floor_gb is not None else profile.ram_gb
+    if instance.ram_gb < floor_ram:
+        return f"RAM {instance.ram_gb} GB < required {floor_ram} GB"
+    if instance.vcpu < profile.vcpu:
+        return f"vCPU {instance.vcpu} < required {profile.vcpu}"
+    if profile.gpu.required:
+        if instance.gpu_count == 0:
+            return "GPU required but not available"
+        if (
+            profile.gpu.vram_gb is not None
+            and instance.gpu_vram_gb is not None
+            and instance.gpu_vram_gb < profile.gpu.vram_gb
+        ):
+            return (
+                f"GPU VRAM {instance.gpu_vram_gb} GB "
+                f"< required {profile.gpu.vram_gb} GB"
+            )
+    if instance.status == "tombstoned":
+        return f"Instance {instance.id!r} is tombstoned — no longer available"
+    return None
+
+
+def score_instance(instance: MachineType, profile: WorkloadProfile) -> ScoredInstance:
+    """Score a single instance against a workload profile.
+
+    Returns a ScoredInstance with composite score and sub-scores.
+    Disqualified instances have score=0.0 and disqualified=True.
+    """
+    reason = _hard_floor_check(instance, profile)
+    if reason:
+        return ScoredInstance(
+            instance=instance, score=0.0,
+            cost_score=0.0, perf_score=0.0, avail_score=0.0,
+            disqualified=True, disqualify_reason=reason,
+        )
+
+    raw_weights = profile.weights or WEIGHT_MATRIX[profile.optimize_for]
+    weights = _normalize_weights(raw_weights)
+
+    c = _cost_score(instance)
+    p = _perf_score(instance, profile)
+    a = _avail_score(instance)
+
+    composite = (
+        weights.get("cost", 0.33) * c
+        + weights.get("perf", 0.34) * p
+        + weights.get("avail", 0.33) * a
+    )
+
+    return ScoredInstance(
+        instance=instance,
+        score=round(composite, 4),
+        cost_score=round(c, 4),
+        perf_score=round(p, 4),
+        avail_score=round(a, 4),
+    )
+
+
+# Alias — both names are public API
+score = score_instance
+
+
+def rank(
+    profile: WorkloadProfile,
+    candidates: list[MachineType],
+) -> list[ScoredInstance]:
+    """Score and rank all candidates.
+
+    Qualified instances are returned first, sorted by score descending.
+    Disqualified instances appear at the end (score=0.0).
+    """
+    scored = [score_instance(m, profile) for m in candidates]
+    qualified    = sorted(
+        [s for s in scored if not s.disqualified],
+        key=lambda s: s.score,
+        reverse=True,
+    )
+    disqualified = [s for s in scored if s.disqualified]
+    return qualified + disqualified

cloudfit/yaml_loader.py

@@ -0,0 +1,149 @@
+"""YAML workload schema loader for cloudfit-core.
+
+Loads a workload profile from a YAML file or dict and returns
+a validated WorkloadProfile instance.
+
+Schema example
+--------------
+    workload:
+      type: io-intensive
+      archetype: io
+      parallelism: lane
+
+      resources:
+        vcpu: 60
+        ram_gb: 224
+        disk:
+          sizing: dynamic
+          scratch_tb: 18
+          preferred: local_ssd_first
+          safety_margin: 0.20
+        gpu:
+          required: false
+
+      scheduling:
+        spot: false
+        restart_tolerant: false
+
+      optimize_for: balanced
+      providers:
+        - gcp
+        - aws
+"""
+
+from __future__ import annotations
+from pathlib import Path
+from typing import Any
+
+try:
+    import yaml
+except ImportError as exc:
+    raise ImportError(
+        "PyYAML is required for from_yaml(). "
+        "Install it with: pip install pyyaml"
+    ) from exc
+
+from .models import (
+    WorkloadProfile,
+    DiskSpec,
+    GPUSpec,
+    SchedulingSpec,
+    OptimizeFor,
+    Archetype,
+)
+
+
+def from_yaml(path: str | Path) -> WorkloadProfile:
+    """Load a WorkloadProfile from a YAML file.
+
+    Args:
+        path: Path to the YAML file.
+
+    Returns:
+        A validated WorkloadProfile instance.
+
+    Raises:
+        FileNotFoundError: If the file does not exist.
+        ValueError: If required fields are missing or invalid.
+    """
+    path = Path(path)
+    if not path.exists():
+        raise FileNotFoundError(f"Workload file not found: {path}")
+
+    with path.open() as f:
+        raw = yaml.safe_load(f)
+
+    return from_dict(raw)
+
+
+def from_dict(data: dict[str, Any]) -> WorkloadProfile:
+    """Parse a WorkloadProfile from a plain dict (e.g. parsed JSON or YAML).
+
+    Accepts both flat and nested schemas:
+
+    Nested (preferred):
+        workload:
+          resources:
+            vcpu: 60
+            ram_gb: 224
+
+    Flat (also accepted):
+        vcpu: 60
+        ram_gb: 224
+
+    Args:
+        data: Raw dict from YAML/JSON.
+
+    Returns:
+        A validated WorkloadProfile.
+    """
+    # Support both top-level "workload:" key and flat dict
+    w = data.get("workload", data)
+    resources = w.get("resources", w)
+
+    # Disk spec
+    disk_raw = resources.get("disk", {})
+    disk = DiskSpec(
+        sizing=disk_raw.get("sizing", "static"),
+        scratch_tb=disk_raw.get("scratch_tb"),
+        preferred=disk_raw.get("preferred", "network_ssd"),
+        safety_margin=disk_raw.get("safety_margin", 0.20),
+    )
+
+    # GPU spec
+    gpu_raw = resources.get("gpu", {})
+    gpu = GPUSpec(
+        required=gpu_raw.get("required", False),
+        vram_gb=gpu_raw.get("vram_gb"),
+    )
+
+    # Scheduling spec
+    sched_raw = w.get("scheduling", {})
+    scheduling = SchedulingSpec(
+        spot=sched_raw.get("spot", False),
+        restart_tolerant=sched_raw.get("restart_tolerant", False),
+    )
+
+    vcpu = resources.get("vcpu")
+    ram_gb = resources.get("ram_gb")
+
+    if vcpu is None:
+        raise ValueError("workload.resources.vcpu is required")
+    if ram_gb is None:
+        raise ValueError("workload.resources.ram_gb is required")
+
+    return WorkloadProfile(
+        vcpu=int(vcpu),
+        ram_gb=float(ram_gb),
+        ram_floor_gb=resources.get("ram_floor_gb"),
+        workload=w.get("type", "generic"),
+        archetype=Archetype(w.get("archetype", "cpu")),
+        tool=w.get("tool"),
+        parallelism=w.get("parallelism", "sample"),
+        disk=disk,
+        gpu=gpu,
+        scheduling=scheduling,
+        optimize_for=OptimizeFor(w.get("optimize_for", "balanced")),
+        providers=w.get("providers", ["gcp", "aws"]),
+        weights=w.get("weights"),
+    )

cloudfit_core-0.1.0.dist-info/METADATA

@@ -0,0 +1,346 @@
+Metadata-Version: 2.4
+Name: cloudfit-core
+Version: 0.1.0
+Summary: Cloud-agnostic machine type scoring engine for computational workloads
+Project-URL: Homepage, https://github.com/cloudfit-io/cloudfit-core
+Project-URL: Repository, https://github.com/cloudfit-io/cloudfit-core
+Project-URL: Bug Tracker, https://github.com/cloudfit-io/cloudfit-core/issues
+Project-URL: Google Scholar, https://scholar.google.com/citations?user=Y2S8D2UAAAAJ
+Project-URL: ORCID, https://orcid.org/0000-0001-5792-1095
+Author-email: Chaitanya Krishna Kasaraneni <kc.kasaraneni@gmail.com>
+License: Apache-2.0
+License-File: LICENSE
+Keywords: aws,azure,bioinformatics,cloud,gcp,genomics,instance-recommendation,machine-type,terraform
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: Apache Software License
+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: Topic :: Scientific/Engineering :: Bio-Informatics
+Classifier: Topic :: System :: Systems Administration
+Requires-Python: >=3.9
+Requires-Dist: pydantic>=2.0
+Requires-Dist: pyyaml>=6.0
+Provides-Extra: dev
+Requires-Dist: mypy; extra == 'dev'
+Requires-Dist: pytest-cov; extra == 'dev'
+Requires-Dist: pytest>=7.0; extra == 'dev'
+Requires-Dist: ruff; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# cloudfit-core
+
+[![PyPI version](https://img.shields.io/pypi/v/cloudfit-core)](https://pypi.org/project/cloudfit-core/)
+[![Python 3.9+](https://img.shields.io/badge/python-3.9+-blue)](https://pypi.org/project/cloudfit-core/)
+[![License: Apache 2.0](https://img.shields.io/badge/license-Apache%202.0-green)](LICENSE)
+[![Tests](https://github.com/cloudfit-io/cloudfit-core/actions/workflows/test.yml/badge.svg)](https://github.com/cloudfit-io/cloudfit-core/actions)
+
+**Cloud-agnostic machine type scoring engine for computational workloads.**
+
+`cloudfit-core` is the foundation of the [cloudfit](https://github.com/cloudfit-io) ecosystem — a pure Python library that, given a workload profile, scores and ranks available cloud instances across providers. No cloud credentials required. No API calls. Just a workload spec in, ranked recommendations out.
+
+---
+
+## The problem
+
+Teams hardcode instance types (`c2-standard-60`, `c7i.16xlarge`) in infrastructure-as-code. When providers deprecate them or release better generations, nothing updates — costs drift and performance degrades silently. There is no open-source tool that takes a workload description and returns the best available instance across AWS, GCP, and Azure with explainable scoring.
+
+cloudfit-core is that scoring engine.
+
+---
+
+## Installation
+
+```bash
+pip install cloudfit-core
+```
+
+Requires Python 3.9+.
+
+---
+
+## Quick start
+
+```python
+from cloudfit import WorkloadProfile, MachineType, rank
+
+# Define your workload
+profile = WorkloadProfile(
+    vcpu=60,
+    ram_gb=224,
+    workload="io-intensive",
+    archetype="io",            # io | cpu | mem | gpu | burst
+    optimize_for="balanced",   # cost | performance | availability | balanced
+)
+
+# Provide candidate instances (from a cloudfit-provider-* package or your own list)
+candidates = [
+    MachineType(id="c2-standard-60",       provider="gcp", vcpu=60, ram_gb=240, price_hr=3.13),
+    MachineType(id="c3d-standard-60-lssd", provider="gcp", vcpu=60, ram_gb=240, price_hr=3.39),
+    MachineType(id="t2d-standard-60",      provider="gcp", vcpu=60, ram_gb=240, price_hr=2.31),
+    MachineType(id="c7i.24xlarge",         provider="aws", vcpu=96, ram_gb=192, price_hr=4.28),
+]
+
+# Score and rank
+results = rank(profile, candidates)
+for r in results:
+    print(f"{r.instance.id:30s}  score={r.score:.2f}  ${r.instance.price_hr:.2f}/hr")
+```
+
+Output:
+```
+t2d-standard-60                 score=0.81  $2.31/hr
+c2-standard-60                  score=0.81  $3.13/hr
+c3d-standard-60-lssd            score=0.80  $3.39/hr
+c7i.24xlarge                    score=0.00  $4.28/hr
+```
+
+`c7i.24xlarge` scores `0.00` and ranks last because its 192 GB RAM is below the
+requested 224 GB — it's eliminated by the hard floor filter, not just ranked low
+(see [How scoring works](#how-scoring-works)).
+
+---
+
+## How scoring works
+
+Every recommendation runs through the same weighted scoring function:
+
+```
+score = w_cost × cost_score + w_perf × perf_score + w_avail × avail_score
+```
+
+The `optimize_for` mode sets the weights:
+
+| Mode | w_cost | w_perf | w_avail | Best for |
+|---|---|---|---|---|
+| `cost` | 0.70 | 0.20 | 0.10 | Batch jobs, dev environments |
+| `balanced` | 0.33 | 0.34 | 0.33 | Default — production workloads |
+| `performance` | 0.10 | 0.80 | 0.10 | Latency-sensitive, GPU inference |
+| `availability` | 0.10 | 0.20 | 0.70 | Long-running jobs, deprecation risk |
+
+**Hard floor filters** run before scoring — instances that don't meet minimum RAM, vCPU, or GPU requirements are eliminated entirely, not just ranked low.
+
+Advanced users can override weights directly:
+
+```python
+profile = WorkloadProfile(
+    vcpu=60,
+    ram_gb=224,
+    # Both short and long key spellings are accepted:
+    # short: {"cost": 0.5, "perf": 0.4, "avail": 0.1}
+    # long:  {"cost": 0.5, "performance": 0.4, "availability": 0.1}
+    weights={"cost": 0.5, "performance": 0.4, "availability": 0.1}
+)
+```
+
+---
+
+## Workload archetypes
+
+cloudfit-core understands five resource archetypes, each reflecting a different dominant constraint:
+
+| Archetype | Dominant constraint | Typical workloads |
+|---|---|---|
+| `io` | Disk throughput | Sequencing demultiplexing, short-read alignment |
+| `cpu` | Thread parallelism | Variant calling, de novo assembly, quantification |
+| `mem` | RAM capacity | Metagenomics classification, single-cell RNA-seq, Hi-C |
+| `gpu` | GPU VRAM | Protein structure prediction, GPU variant calling, basecalling |
+| `burst` | Fleet × small instances | Nextflow pipelines, Snakemake DAGs, WDL scatter-gather |
+
+In this release the archetype is recorded on the workload profile for classification and downstream tooling; scoring weights are driven by `optimize_for`. Archetype-aware weighting and fleet-vs-single-instance recommendations (e.g. many small spot instances for `burst`) are planned for a future release.
+
+---
+
+## Dynamic disk sizing
+
+For sequencing workloads, disk requirements scale with experiment parameters rather than being fixed. cloudfit-core computes disk from first principles:
+
+```python
+from cloudfit import compute_disk_tb, WorkloadProfile, DiskSpec
+
+disk_tb = compute_disk_tb(
+    sequencer="novaseq_6000",
+    flowcell="s4",
+    lanes=4,
+    retain_input=False,        # if True, raw input files are kept post-run
+    keep_undetermined=False,   # if True, unmatched reads written to disk (+8%)
+    safety_margin=0.20,
+)
+# → 15.84 TB
+
+# Use the result when building your workload profile
+profile = WorkloadProfile(
+    vcpu=60,
+    ram_gb=224,
+    workload="io-intensive",
+    archetype="io",
+    disk=DiskSpec(sizing="static", scratch_tb=disk_tb),
+)
+```
+
+`compute_disk_tb` is a standalone helper — call it before constructing your `WorkloadProfile` and pass the result into `DiskSpec.scratch_tb`.
+
+---
+
+## Workload YAML schema
+
+```yaml
+workload:
+  type: io-intensive
+  archetype: io
+  parallelism: lane        # lane | sample | interval | process | rule
+
+  resources:
+    vcpu: 60
+    ram_gb: 224
+    disk:
+      sizing: dynamic      # "dynamic" computes from experiment params; "static" uses scratch_tb
+      preferred: local_ssd_first
+    gpu:
+      required: false
+
+  scheduling:
+    spot: false
+    restart_tolerant: false
+
+  optimize_for: balanced   # cost | performance | availability | balanced
+  providers:
+    - gcp
+    - aws
+```
+
+Load from file:
+
+```python
+from cloudfit import from_yaml
+
+profile = from_yaml("my-workload.yaml")
+results = rank(profile, candidates)
+```
+
+---
+
+## Provider plugins
+
+`cloudfit-core` is the scoring engine only — it scores whatever instances you give it. Provider plugins fetch live instance data from cloud APIs on a schedule and feed the registry:
+
+```bash
+pip install cloudfit-provider-gcp   # fetches GCP Compute Engine machine types
+pip install cloudfit-provider-aws   # fetches AWS EC2 instance specs and pricing
+```
+
+Each provider implements a simple interface:
+
+```python
+from cloudfit.providers.base import Provider
+
+class MyProvider(Provider):
+    def fetch_instances(self, region: str) -> list[MachineType]: ...
+    def get_pricing(self, instance_id: str, region: str) -> float: ...
+    def get_availability(self, instance_id: str, region: str) -> float: ...
+```
+
+Want to add a provider? See [CONTRIBUTING.md](CONTRIBUTING.md).
+
+---
+
+## Terraform / OpenTofu integration
+
+Once `cloudfit-api` is running, use the Terraform provider to resolve instance types at plan time:
+
+```hcl
+data "cloudfit_recommendation" "demux_worker" {
+  vcpu         = 60
+  ram_gb       = 224
+  workload     = "sequencing-demux"
+  optimize_for = "balanced"
+}
+
+resource "google_compute_instance" "worker" {
+  machine_type = data.cloudfit_recommendation.demux_worker.machine_type
+}
+```
+
+---
+
+## Citing cloudfit-core
+
+If you use cloudfit-core in your research, please cite it:
+
+```bibtex
+@software{kasaraneni2026cloudfit,
+  author    = {Kasaraneni, Chaitanya Krishna},
+  title     = {cloudfit-core: Cloud-agnostic machine type scoring engine
+               for computational workloads},
+  year      = {2026},
+  publisher = {GitHub},
+  url       = {https://github.com/cloudfit-io/cloudfit-core},
+  orcid     = {0000-0001-5792-1095}
+}
+```
+
+GitHub also shows a **Cite this repository** button in the sidebar (powered by `CITATION.cff`).
+
+---
+
+## Related publications
+
+- Kasaraneni, C.K. et al. (2025). *AI-Driven Drug Repurposing: A Graph Neural Network and Self-Supervised Learning Approach.* IEEE CIACON. [doi:10.1109/CIACON65473.2025.11189545](https://doi.org/10.1109/CIACON65473.2025.11189545)
+- Kasaraneni, C.K. et al. (2025). *Multi-modality Medical Image Fusion Using Machine Learning/Deep Learning.* Springer. [doi:10.1007/978-3-031-98728-1_16](https://doi.org/10.1007/978-3-031-98728-1_16)
+
+---
+
+## Related projects
+
+- [`samplesheet-parser`](https://github.com/chaitanyakasaraneni/samplesheet-parser) — Format-agnostic Illumina SampleSheet parser (BCLConvert V2 + IEM V1)
+- [`clinops`](https://github.com/chaitanyakasaraneni/clinops) — Clinical ML data quality library
+
+---
+
+## Repository structure
+
+```
+cloudfit-core/
+├── README.md               # first thing every visitor reads
+├── CITATION.cff            # GitHub "Cite this repository" button — ORCID linked
+├── pyproject.toml          # packaging, dependencies, PyPI metadata
+├── CONTRIBUTING.md         # provider plugin interface guide
+├── LICENSE                 # Apache 2.0
+├── .gitignore
+│
+├── cloudfit/
+│   ├── __init__.py         # exports rank, recommend, key models
+│   ├── models.py           # WorkloadProfile, MachineType, ScoredInstance (pydantic v2)
+│   ├── scorer.py           # rank(), score_instance(), weight matrix
+│   ├── filter.py           # hard_floor_check() — RAM, vCPU, GPU hard filters
+│   ├── disk.py             # compute_disk_tb() — dynamic disk sizing formula
+│   ├── yaml_loader.py      # from_yaml() — loads workload YAML schema
+│   └── providers/
+│       ├── __init__.py
+│       └── base.py         # abstract Provider class — plugin contract
+│
+└── tests/
+    ├── test_scorer.py      # rank, scores, weight modes, hard floors
+    ├── test_disk.py        # disk formula, CBCL vs BCL factor, sequencer profiles
+    └── test_yaml.py        # from_yaml() loads profiles correctly
+```
+
+---
+
+## Contributing
+
+See [CONTRIBUTING.md](CONTRIBUTING.md). Issues and pull requests are welcome — especially provider plugins for new cloud platforms (Azure, Hetzner, Oracle Cloud).
+
+## License
+
+Apache 2.0 — see [LICENSE](LICENSE).
+
+---
+
+<sub>Author: <a href="https://ckasaraneni.com">Chaitanya Krishna Kasaraneni</a> &nbsp;·&nbsp;
+<a href="https://scholar.google.com/citations?user=Y2S8D2UAAAAJ">Google Scholar</a> &nbsp;·&nbsp;
+<a href="https://orcid.org/0000-0001-5792-1095">ORCID 0000-0001-5792-1095</a></sub>

cloudfit_core-0.1.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+cloudfit/__init__.py,sha256=0TQ8s8DHq5zLdEhTtyuhYWKf7i2pvUCibJdgTtUeyB4,953
+cloudfit/disk.py,sha256=5n8vZkCCSCM7xCntGZ9hkDKHKl_ra-7WFdbvZ5mm6Uc,6584
+cloudfit/filter.py,sha256=CGueCMItkfx29HXzuaAAaxHjUtEa1Evgz8aSCgmG-vU,2665
+cloudfit/models.py,sha256=290zJuJGleTBQNbBXh_J7qAGO31lxZ2lZwbneW5WV44,2445
+cloudfit/scorer.py,sha256=fOwiPvam4Ngju_5GXTUHPqmr51iXryt7FJIan_lF0mE,4622
+cloudfit/yaml_loader.py,sha256=dYgQ6aoUVp71M1FV_4XQ08rVpAZafq8h2n5k8umEVRI,3645
+cloudfit/providers/base.py,sha256=imDbyAePMFj5RVkSJ5LH1_eWGb-1qNWxm2N49Z5oPCc,741
+cloudfit_core-0.1.0.dist-info/METADATA,sha256=LmjkZ97OEy7-BRRvdkoRlDVWijSBqrHgVT6oUdKaUDE,12405
+cloudfit_core-0.1.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+cloudfit_core-0.1.0.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+cloudfit_core-0.1.0.dist-info/RECORD,,

cloudfit_core-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

cloudfit_core-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.