Ekaterina
Khlebova

# Propagate annotations to parent GO classes
# "If a gene is annotated to class X, it is also
# annotated to all parent classes of X"

if go_class in genes_per_go_class.keys():
    for parent_id in parents.split(","):
        parent_id = parent_id.strip()
        if not parent_id.startswith("GO:"):
            parent_id = f"GO:{parent_id.zfill(7)}"
        for gene_id in genes_per_go_class[go_class]:
            go_classes_per_gene[gene_id].add(parent_id)

# Recount and rank the top 50 GO classes by gene count
for gene_id, go_class_set in go_classes_per_gene.items():
    for go_class in go_class_set:
        genes_per_go_class[go_class].add(gene_id)

top_50 = sorted(
    genes_per_go_class.items(),
    key=lambda x: len(x[1]),
    reverse=True
)[:50]

for go_id, genes in top_50:
    name = go_class_names.get(go_id, "Unknown")
    print(f"{go_id:<15} {name:<50} {len(genes)}")

@dataclass
class LactateThresholdState:
    """State for lactate threshold detection"""
    min_trend_length: int = 10

    # Previous values
    prev_rmssd: Optional[float] = None
    prev_index: int = 0

    # Decreasing trend tracking
    decrease_trend_count: int = 0
    decrease_trend_confirmed: bool = False

    # Increasing trend tracking
    increase_trend_count: int = 0
    increase_start_rmssd: Optional[float] = None
    increase_start_speed: Optional[float] = None

# Two-phase detection: first find a sustained decrease
# in RMSSD, then find the reversal (increase)

# Phase 1: Decreasing trend
if not state.decrease_trend_confirmed:
    if prev_val > current_val:
        state.decrease_trend_count += 1
    elif count >= state.min_trend_length:
        state.decrease_trend_confirmed = True

# Phase 2: Increasing trend (reversal found!)
else:
    if prev_val < current_val:
        state.increase_trend_count += 1
    elif count >= state.min_trend_length:
        return Status.THRESHOLD_FOUND, state

# Launch vLLM OpenAI-compatible API server
# with tensor parallelism across 8 GPUs

MODEL="LumiOpen/Llama-Poro-2-70B-Instruct"
CHAT_TEMPLATE="poro_chat_template.jinja"

python -m vllm.entrypoints.openai.api_server \
    --model=$MODEL \
    --tensor-parallel-size 8 \
    --pipeline-parallel-size 1 \
    --gpu-memory-utilization=0.95

# Send translation prompts via OpenAI API
def get_translated_text(text, lang, url, model):
    prompt = system_prompt.format(lang=lang)
    messages = [
        {"role": "system", "content": prompt},
        {"role": "user",   "content": text}
    ]
    headers = {"Content-Type": "application/json"}
    data = {
        "model": model,
        "messages": messages,
        "temperature": 0.7
    }
    resp = requests.post(url, headers=headers,
                         data=json.dumps(data))
    return resp.json()

# Fetch RTT measurements from RIPE Atlas API
# for selected anchor-probe pairs

import requests

def fetch_rtt_measurements(
    measurement_id, start, stop
):
    url = (f"https://atlas.ripe.net/api/v2/"
           f"measurements/{measurement_id}/"
           f"results/?start={start}&stop={stop}")
    response = requests.get(url)
    results = response.json()

    rtts = []
    for result in results:
        for reply in result.get("result", []):
            if "rtt" in reply:
                rtts.append(reply["rtt"])
    return rtts

# Compute summary RTT statistics per region
import numpy as np
from scipy import stats

def compute_rtt_stats(rtt_values):
    return {
        "min":     np.min(rtt_values),
        "max":     np.max(rtt_values),
        "mean":    np.mean(rtt_values),
        "q1":      np.percentile(rtt_values, 25),
        "median":  np.median(rtt_values),
        "q3":      np.percentile(rtt_values, 75),
        "variance": np.var(rtt_values)
    }

# Fit distribution to RTT data
params = stats.lognorm.fit(rtt_values)
pdf = stats.lognorm.pdf(x, *params)