From e6224a7800034a46211a5bedb92c27c63cc727bc Mon Sep 17 00:00:00 2001 From: Sahana Yadnakudige Subramanya Date: Wed, 15 Apr 2026 14:35:19 +0200 Subject: [PATCH 01/47] added optimization code --- .../optimization/baseline_optimization.py | 302 ++++++++++++++++ .../optimization/contrastive_optimization.py | 333 +++++++++++++++++ .../generate_contrastive_answers.py | 125 +++++++ learn2rag/optimization/readme.md | 0 .../optimization/self_judge_optimization.py | 340 ++++++++++++++++++ 5 files changed, 1100 insertions(+) create mode 100644 learn2rag/optimization/baseline_optimization.py create mode 100644 learn2rag/optimization/contrastive_optimization.py create mode 100644 learn2rag/optimization/generate_contrastive_answers.py create mode 100644 learn2rag/optimization/readme.md create mode 100644 learn2rag/optimization/self_judge_optimization.py diff --git a/learn2rag/optimization/baseline_optimization.py b/learn2rag/optimization/baseline_optimization.py new file mode 100644 index 0000000..ea5b0c4 --- /dev/null +++ b/learn2rag/optimization/baseline_optimization.py @@ -0,0 +1,302 @@ +""" +RAG Pipeline Optimization with BERTScore evaluation. +""" + +import argparse +import json +import logging +import pathlib +import time +import copy + +import numpy as np +from bert_score import score as bert_score +from ConfigSpace import ConfigurationSpace, Integer, Categorical, ForbiddenGreaterThanRelation +from smac import HyperparameterOptimizationFacade, Scenario + +from learn2rag.evaluation.tools import read_dataset_qa +from learn2rag.pipeline.config import opt_config +import learn2rag.pipeline.search +import learn2rag.pipeline.generate + + +DATASET_CONFIG = { + "WikiEval": { + "subdirectory": "", + "split": "train", + "question_field": "question", + "answer_field": "answer", + "id_field": "id", + }, + "rag-mini-bioasq": { + "subdirectory": "question-answer-passages", + "split": "test", + "question_field": "question", + "answer_field": "answer", + "id_field": "id", + }, + "hotpot_qa": { # Not being used + "subdirectory": "distractor", + "split": "validation", + "question_field": "question", + "answer_field": "answer", + "id_field": "id", + }, + "repliqa": { # Not being used + "subdirectory": "repliqa_4", + "split": None, + "question_field": "question", + "answer_field": "long_answer", + "id_field": "question_id", + }, +} + +PROMPT_MAP = { + "default": ( + "# Role and Objective\nYou will act as a smart AI chatbot that answers " + "questions only by using the content from the provided information list.\n\n" + "# Instructions\n- Respond in the language of the question.\n" + "- Answer clear and concise.\n- Only use the provided information.\n" + "- NEVER use your general knowledge.\n\n" + "# Information:\n{context}" + ), + "concise": ( + "Answer the question using ONLY the provided information. " + "Be concise and direct. If the information does not contain the answer, say so.\n\n" + "Information:\n{context}" + ), + "detailed": ( + "You are a knowledgeable assistant. Using ONLY the provided information below, " + "answer the question thoroughly. Cite your sources. " + "If the information is insufficient, state that clearly.\n\n" + "Information:\n{context}" + ), +} + + +def run_pipeline(question, user_config, working_config): + t0 = time.time() + docs = learn2rag.pipeline.search.search(question, user_config, working_config) + search_time = time.time() - t0 + + t0 = time.time() + answer = learn2rag.pipeline.generate.generate(question, docs, working_config) + gen_time = time.time() - t0 + + doc_list = docs.points if hasattr(docs, "points") else docs + context = "" + if doc_list: + context = "\n\n".join([ + f"Source: {d.payload.get('path', 'unknown')}\nContent: {d.payload.get('content', '')}" + for d in doc_list + ]) + return answer, context[:3000], search_time, gen_time + + +def objective(config, seed, questions, dataset_name, state, answers_dir): + state["trial_count"] += 1 + tid = state["trial_count"] + cfg = dict(config) + logging.info(f"Trial {tid}: {cfg}") + + wcfg = copy.deepcopy(opt_config) + wcfg["top_k"] = cfg["top_k"] + wcfg["chunk_size"] = cfg["chunk_size"] + wcfg["chunk_overlap"] = cfg["chunk_overlap"] + wcfg["prompt"] = PROMPT_MAP[cfg["prompt_template"]] + ucfg = {"file_path": None, "collection_name": dataset_name, + "imported_documents_file_path": None, "llm": None} + + predictions, goldens = [], [] + qa_pairs = [] + t_start = time.time() + t_search, t_gen = 0.0, 0.0 + + for idx, q in enumerate(questions): + if not q["question"]: + continue + try: + answer, context, st, gt = run_pipeline(q["question"], ucfg, wcfg) + t_search += st + t_gen += gt + predictions.append(answer) + goldens.append(q["ground_truth"]) + qa_pairs.append({ + "id": q["id"], + "question": q["question"], + "golden_answer": q["ground_truth"], + "generated_answer": answer, + "retrieved_context": context, + }) + except Exception as e: + logging.warning(f"Trial {tid}, q{idx} failed: {e}") + predictions.append("") + goldens.append(q["ground_truth"]) + qa_pairs.append({ + "id": q["id"], + "question": q["question"], + "golden_answer": q["ground_truth"], + "generated_answer": "", + "retrieved_context": "", + }) + + if not predictions: + return 1.0 + + t_score = time.time() + _, _, F1_gold = bert_score(predictions, goldens, lang="en", verbose=False, rescale_with_baseline=True) + scoring_time = time.time() - t_score + + # objective function + bert_gold = [max(0.0, f.item()) for f in F1_gold] + avg_bert_gold = np.mean(bert_gold) + cost = 1.0 - avg_bert_gold + total_time = time.time() - t_start + + trial_answers = { + "trial_id": tid, + "config": cfg, + "cost": float(cost), + "avg_bertscore_golden": float(avg_bert_gold), + "qa_pairs": qa_pairs, + } + answers_file = answers_dir / f"trial_{tid}_answers.json" + with open(answers_file, "w") as f: + json.dump(trial_answers, f, indent=2, default=str) + + state["best_cost"] = min(state["best_cost"], cost) + state["convergence"].append({"trial": tid, "cost": float(cost), "best_cost": float(state["best_cost"])}) + state["history"].append({ + "trial_id": tid, "config": cfg, + "avg_bertscore_golden": float(avg_bert_gold), + "cost": float(cost), "time_s": round(total_time, 2), + "search_s": round(t_search, 2), "gen_s": round(t_gen, 2), + "scoring_s": round(scoring_time, 2), + }) + + logging.info( + f"Trial {tid}: bertscore_golden={avg_bert_gold:.4f} cost={cost:.4f} " + f"time={total_time:.1f}s (search={t_search:.1f} gen={t_gen:.1f} score={scoring_time:.1f})" + ) + return float(cost) + + +def param_importance(smac, output_path): + params = list(smac.scenario.configspace.keys()) + configs, costs = [], [] + for key, val in smac.runhistory.items(): + configs.append(dict(smac.runhistory.get_config(key.config_id))) + costs.append(val.cost) + if len(configs) < 3: + return {} + + raw = {} + for p in params: + groups = {} + for c, cost in zip(configs, np.array(costs)): + groups.setdefault(str(c[p]), []).append(cost) + means = [np.mean(g) for g in groups.values()] + raw[p] = float(np.var(means)) if len(means) > 1 else 0.0 + + total = sum(raw.values()) + imp = {p: round(v / total, 4) for p, v in raw.items()} if total > 0 else raw + ranking = sorted(imp, key=imp.get, reverse=True) + result = {"method": "variance_based", "ranking": ranking, "individual": imp} + with open(output_path / "parameter_importance.json", "w") as f: + json.dump(result, f, indent=2) + return result + + +def run(dataset_name, max_questions, n_trials, output_dir): + if dataset_name not in DATASET_CONFIG: + raise ValueError( + f"Unknown dataset: {dataset_name}. " + f"Available: {list(DATASET_CONFIG.keys())}" + ) + + dcfg = DATASET_CONFIG[dataset_name] + out = pathlib.Path(output_dir) / dataset_name + out.mkdir(parents=True, exist_ok=True) + + answers_dir = out / "trial_answers" + answers_dir.mkdir(parents=True, exist_ok=True) + + qa = read_dataset_qa(dataset_name, dcfg["subdirectory"], dcfg["split"]) + if max_questions: + qa = qa.select(range(min(max_questions, len(qa)))) + + questions = [] + for i, r in enumerate(qa): + questions.append({ + "question": r.get(dcfg["question_field"], ""), + "ground_truth": r.get(dcfg["answer_field"], ""), + "id": r.get(dcfg["id_field"], str(i)), + }) + logging.info(f"Loaded {len(questions)} questions from {dataset_name}") + + cs = ConfigurationSpace(seed=42) + cs.add([Integer("top_k", (1, 20), default=4), + Integer("chunk_size", (200, 4000), default=2000), + Integer("chunk_overlap", (0, 500), default=200), + Categorical("prompt_template", ["default", "concise", "detailed"], default="default")]) + cs.add(ForbiddenGreaterThanRelation(cs["chunk_overlap"], cs["chunk_size"])) + + scenario = Scenario(configspace=cs, deterministic=True, n_trials=n_trials, + walltime_limit=7200, seed=42, output_directory=out / "smac_output") + + state = {"trial_count": 0, "best_cost": 1.0, "convergence": [], "history": []} + smac = HyperparameterOptimizationFacade( + scenario=scenario, + target_function=lambda config, seed=0: objective( + config, seed, questions, dataset_name, state, answers_dir + ), + ) + + t0 = time.time() + incumbent = smac.optimize() + total_time = time.time() - t0 + + importance = param_importance(smac, out) + + with open(out / "optimization_results.json", "w") as f: + json.dump({ + "best_config": dict(incumbent), + "run_history": state["history"], + "convergence": state["convergence"], + "parameter_importance": importance, + "total_time_s": round(total_time, 2), + "dataset": dataset_name, + "metric": "bertscore_golden", + "answers_dir": str(answers_dir), + }, f, indent=2, default=str) + + logging.info(f"Done in {total_time:.0f}s") + logging.info(f"Trial answers saved to {answers_dir}") + return incumbent, state["history"], importance + + +if __name__ == "__main__": + parser = argparse.ArgumentParser() + parser.add_argument("--dataset", type=str, default="WikiEval", + choices=list(DATASET_CONFIG.keys())) + parser.add_argument("--max_questions", type=int, default=50) + parser.add_argument("--n_trials", type=int, default=10) + parser.add_argument("--output_dir", type=str, default="optimization_results_baseline") + args = parser.parse_args() + + logging.basicConfig( + level=logging.INFO, + format="%(asctime)s %(levelname)s %(message)s", + force=True, + ) + incumbent, history, importance = run( + args.dataset, args.max_questions, args.n_trials, args.output_dir, + ) + + best = min(history, key=lambda x: x["cost"]) + print(f"\nBest config: {dict(incumbent)}") + print(f"BERTScore (golden): {best['avg_bertscore_golden']:.4f}") + if importance: + print(f"\nParameter importance:") + for i, p in enumerate(importance["ranking"], 1): + print(f" {i}. {p}: {importance['individual'][p]:.4f}") \ No newline at end of file diff --git a/learn2rag/optimization/contrastive_optimization.py b/learn2rag/optimization/contrastive_optimization.py new file mode 100644 index 0000000..91a5d50 --- /dev/null +++ b/learn2rag/optimization/contrastive_optimization.py @@ -0,0 +1,333 @@ +""" +RAG Pipeline Optimization with contrastive evaluation. +""" + +import argparse +import json +import logging +import pathlib +import time +import copy + +import numpy as np +from bert_score import score as bert_score +from ConfigSpace import ConfigurationSpace, Integer, Categorical, ForbiddenGreaterThanRelation +from smac import HyperparameterOptimizationFacade, Scenario + +from learn2rag.evaluation.tools import read_dataset_qa +from learn2rag.pipeline.config import opt_config +import learn2rag.pipeline.search +import learn2rag.pipeline.generate + + +DATASET_CONFIG = { + "WikiEval": { + "subdirectory": "", + "split": "train", + "question_field": "question", + "answer_field": "answer", + "id_field": "id", + }, + "rag-mini-bioasq": { + "subdirectory": "question-answer-passages", + "split": "test", + "question_field": "question", + "answer_field": "answer", + "id_field": "id", + }, + "hotpot_qa": { # Not being used + "subdirectory": "distractor", + "split": "validation", + "question_field": "question", + "answer_field": "answer", + "id_field": "id", + }, + "repliqa": { # Not being used + "subdirectory": "repliqa_4", + "split": None, + "question_field": "question", + "answer_field": "long_answer", + "id_field": "question_id", + }, +} + +PROMPT_MAP = { + "default": ( + "# Role and Objective\nYou will act as a smart AI chatbot that answers " + "questions only by using the content from the provided information list.\n\n" + "# Instructions\n- Respond in the language of the question.\n" + "- Answer clear and concise.\n- Only use the provided information.\n" + "- NEVER use your general knowledge.\n\n" + "# Information:\n{context}" + ), + "concise": ( + "Answer the question using ONLY the provided information. " + "Be concise and direct. If the information does not contain the answer, say so.\n\n" + "Information:\n{context}" + ), + "detailed": ( + "You are a knowledgeable assistant. Using ONLY the provided information below, " + "answer the question thoroughly. Cite your sources. " + "If the information is insufficient, state that clearly.\n\n" + "Information:\n{context}" + ), +} + + +def load_false_answers(contrastive_file): + with open(contrastive_file) as f: + data = json.load(f) + return {item["question"]: item["false_answer"] for item in data} + + +def run_pipeline(question, user_config, working_config): + t0 = time.time() + docs = learn2rag.pipeline.search.search(question, user_config, working_config) + search_time = time.time() - t0 + + t0 = time.time() + answer = learn2rag.pipeline.generate.generate(question, docs, working_config) + gen_time = time.time() - t0 + + doc_list = docs.points if hasattr(docs, "points") else docs + context = "" + if doc_list: + context = "\n\n".join([ + f"Source: {d.payload.get('path', 'unknown')}\nContent: {d.payload.get('content', '')}" + for d in doc_list + ]) + return answer, context[:3000], search_time, gen_time + + +def objective(config, seed, questions, dataset_name, false_map, state, answers_dir): + state["trial_count"] += 1 + tid = state["trial_count"] + cfg = dict(config) + logging.info(f"Trial {tid}: {cfg}") + + wcfg = copy.deepcopy(opt_config) + wcfg["top_k"] = cfg["top_k"] + wcfg["chunk_size"] = cfg["chunk_size"] + wcfg["chunk_overlap"] = cfg["chunk_overlap"] + wcfg["prompt"] = PROMPT_MAP[cfg["prompt_template"]] + ucfg = {"file_path": None, "collection_name": dataset_name, + "imported_documents_file_path": None, "llm": None} + + predictions, goldens, falses = [], [], [] + qa_pairs = [] + t_start = time.time() + t_search, t_gen = 0.0, 0.0 + + for idx, q in enumerate(questions): + if not q["question"]: + continue + false_ans = false_map.get(q["question"], "") + if not false_ans: + continue + try: + answer, context, st, gt = run_pipeline(q["question"], ucfg, wcfg) + t_search += st + t_gen += gt + predictions.append(answer) + goldens.append(q["ground_truth"]) + falses.append(false_ans) + qa_pairs.append({ + "id": q["id"], + "question": q["question"], + "golden_answer": q["ground_truth"], + "generated_answer": answer, + "retrieved_context": context, + }) + except Exception as e: + logging.warning(f"Trial {tid}, q{idx} failed: {e}") + predictions.append("") + goldens.append(q["ground_truth"]) + falses.append(false_ans) + qa_pairs.append({ + "id": q["id"], + "question": q["question"], + "golden_answer": q["ground_truth"], + "generated_answer": "", + "retrieved_context": "", + }) + + if not predictions: + return 1.0 + + t_score = time.time() + _, _, F1_gold = bert_score(predictions, goldens, lang="en", verbose=False, rescale_with_baseline=True) + _, _, F1_false = bert_score(predictions, falses, lang="en", verbose=False, rescale_with_baseline=True) + scoring_time = time.time() - t_score + + bert_gold = [max(0.0, f.item()) for f in F1_gold] + bert_false = [max(0.0, f.item()) for f in F1_false] + + ratios = [] + # objective function + for bg, bf in zip(bert_gold, bert_false): + denom = bg + bf + ratios.append(bg / denom if denom > 0 else 0.5) + + avg_ratio = np.mean(ratios) + avg_bert_gold = np.mean(bert_gold) + avg_bert_false = np.mean(bert_false) + cost = 1.0 - avg_ratio + total_time = time.time() - t_start + + trial_answers = { + "trial_id": tid, + "config": cfg, + "cost": float(cost), + "avg_ratio": float(avg_ratio), + "qa_pairs": qa_pairs, + } + answers_file = answers_dir / f"trial_{tid}_answers.json" + with open(answers_file, "w") as f: + json.dump(trial_answers, f, indent=2, default=str) + + state["best_cost"] = min(state["best_cost"], cost) + state["convergence"].append({"trial": tid, "cost": float(cost), "best_cost": float(state["best_cost"])}) + state["history"].append({ + "trial_id": tid, "config": cfg, + "avg_ratio": float(avg_ratio), + "avg_bertscore_golden": float(avg_bert_gold), + "avg_bertscore_false": float(avg_bert_false), + "cost": float(cost), "time_s": round(total_time, 2), + "search_s": round(t_search, 2), "gen_s": round(t_gen, 2), + "scoring_s": round(scoring_time, 2), + }) + + logging.info( + f"Trial {tid}: ratio={avg_ratio:.4f} [gold={avg_bert_gold:.4f} false={avg_bert_false:.4f}] " + f"time={total_time:.1f}s (search={t_search:.1f} gen={t_gen:.1f} score={scoring_time:.1f})" + ) + return float(cost) + + +def param_importance(smac, output_path): + params = list(smac.scenario.configspace.keys()) + configs, costs = [], [] + for key, val in smac.runhistory.items(): + configs.append(dict(smac.runhistory.get_config(key.config_id))) + costs.append(val.cost) + if len(configs) < 3: + return {} + + raw = {} + for p in params: + groups = {} + for c, cost in zip(configs, np.array(costs)): + groups.setdefault(str(c[p]), []).append(cost) + means = [np.mean(g) for g in groups.values()] + raw[p] = float(np.var(means)) if len(means) > 1 else 0.0 + + total = sum(raw.values()) + imp = {p: round(v / total, 4) for p, v in raw.items()} if total > 0 else raw + ranking = sorted(imp, key=imp.get, reverse=True) + result = {"method": "variance_based", "ranking": ranking, "individual": imp} + with open(output_path / "parameter_importance.json", "w") as f: + json.dump(result, f, indent=2) + return result + + +def run(dataset_name, max_questions, n_trials, output_dir, contrastive_dir): + if dataset_name not in DATASET_CONFIG: + raise ValueError( + f"Unknown dataset: {dataset_name}. " + f"Available: {list(DATASET_CONFIG.keys())}" + ) + + dcfg = DATASET_CONFIG[dataset_name] + contrastive_file = pathlib.Path(contrastive_dir) / f"contrastive_answers_{dataset_name}.json" + out = pathlib.Path(output_dir) / dataset_name + out.mkdir(parents=True, exist_ok=True) + + answers_dir = out / "trial_answers" + answers_dir.mkdir(parents=True, exist_ok=True) + + false_map = load_false_answers(contrastive_file) + logging.info(f"Loaded {len(false_map)} false answers from {contrastive_file}") + + qa = read_dataset_qa(dataset_name, dcfg["subdirectory"], dcfg["split"]) + if max_questions: + qa = qa.select(range(min(max_questions, len(qa)))) + + questions = [] + for i, r in enumerate(qa): + questions.append({ + "question": r.get(dcfg["question_field"], ""), + "ground_truth": r.get(dcfg["answer_field"], ""), + "id": r.get(dcfg["id_field"], str(i)), + }) + logging.info(f"Loaded {len(questions)} questions from {dataset_name}") + + cs = ConfigurationSpace(seed=42) + cs.add([Integer("top_k", (1, 20), default=4), + Integer("chunk_size", (200, 4000), default=2000), + Integer("chunk_overlap", (0, 500), default=200), + Categorical("prompt_template", ["default", "concise", "detailed"], default="default")]) + cs.add(ForbiddenGreaterThanRelation(cs["chunk_overlap"], cs["chunk_size"])) + + scenario = Scenario(configspace=cs, deterministic=True, n_trials=n_trials, + walltime_limit=7200, seed=42, output_directory=out / "smac_output") + + state = {"trial_count": 0, "best_cost": 1.0, "convergence": [], "history": []} + smac = HyperparameterOptimizationFacade( + scenario=scenario, + target_function=lambda config, seed=0: objective( + config, seed, questions, dataset_name, false_map, state, answers_dir + ), + ) + + t0 = time.time() + incumbent = smac.optimize() + total_time = time.time() - t0 + + importance = param_importance(smac, out) + + with open(out / "optimization_results.json", "w") as f: + json.dump({ + "best_config": dict(incumbent), + "run_history": state["history"], + "convergence": state["convergence"], + "parameter_importance": importance, + "total_time_s": round(total_time, 2), + "dataset": dataset_name, + "metric": "bertscore_ratio(golden, false)", + "answers_dir": str(answers_dir), + }, f, indent=2, default=str) + + logging.info(f"Done in {total_time:.0f}s") + logging.info(f"Trial answers saved to {answers_dir}") + return incumbent, state["history"], importance + + +if __name__ == "__main__": + parser = argparse.ArgumentParser() + parser.add_argument("--dataset", type=str, default="WikiEval", + choices=list(DATASET_CONFIG.keys())) + parser.add_argument("--max_questions", type=int, default=50) + parser.add_argument("--n_trials", type=int, default=10) + parser.add_argument("--output_dir", type=str, default="optimization_results_contrastive") + parser.add_argument("--contrastive_dir", type=str, default="contrastive_answers") + args = parser.parse_args() + + logging.basicConfig( + level=logging.INFO, + format="%(asctime)s %(levelname)s %(message)s", + force=True, + ) + incumbent, history, importance = run( + args.dataset, args.max_questions, args.n_trials, + args.output_dir, args.contrastive_dir, + ) + + best = min(history, key=lambda x: x["cost"]) + print(f"\nBest config: {dict(incumbent)}") + print(f"Ratio score: {best['avg_ratio']:.4f}") + print(f" BERTScore vs golden: {best['avg_bertscore_golden']:.4f}") + print(f" BERTScore vs false: {best['avg_bertscore_false']:.4f}") + if importance: + print(f"\nParameter importance:") + for i, p in enumerate(importance["ranking"], 1): + print(f" {i}. {p}: {importance['individual'][p]:.4f}") \ No newline at end of file diff --git a/learn2rag/optimization/generate_contrastive_answers.py b/learn2rag/optimization/generate_contrastive_answers.py new file mode 100644 index 0000000..feb233f --- /dev/null +++ b/learn2rag/optimization/generate_contrastive_answers.py @@ -0,0 +1,125 @@ +""" +Generate contrastive (false) answers for RAG evaluation. +""" + +import argparse +import json +import logging +import pathlib +import time + +from learn2rag.pipeline.llm import llm as learn2rag_llm +from learn2rag.evaluation.tools import read_dataset_qa +from langchain_core.messages import HumanMessage + + +DATASET_CONFIG = { + "WikiEval": { + "subdirectory": "", + "split": "train", + "question_field": "question", + "answer_field": "answer", + "id_field": "id", + }, + "rag-mini-bioasq": { + "subdirectory": "question-answer-passages", + "split": "test", + "question_field": "question", + "answer_field": "answer", + "id_field": "id", + }, + "hotpot_qa": { # Not being used + "subdirectory": "distractor", + "split": "validation", + "question_field": "question", + "answer_field": "answer", + "id_field": "id", + }, + "repliqa": { # Not being used + "subdirectory": "repliqa_4", + "split": None, + "question_field": "question", + "answer_field": "long_answer", + "id_field": "question_id", + }, +} + + +def generate(prompt): + response = learn2rag_llm.invoke([HumanMessage(content=prompt)]) + return response.content.strip() + + +def generate_false_answer(question): + return generate( + f"Answer the given question in an incorrect manner.\n\n" + f"question: {question}" + ) + +def run(dataset_name, max_questions=50, output_dir="contrastive_answers"): + if dataset_name not in DATASET_CONFIG: + raise ValueError( + f"Unknown dataset: {dataset_name}. " + f"Available: {list(DATASET_CONFIG.keys())}" + ) + + cfg = DATASET_CONFIG[dataset_name] + output_path = pathlib.Path(output_dir) + output_path.mkdir(parents=True, exist_ok=True) + + qa = read_dataset_qa(dataset_name, cfg["subdirectory"], cfg["split"]) + if max_questions: + qa = qa.select(range(min(max_questions, len(qa)))) + + logging.info(f"Dataset: {dataset_name}, questions: {len(qa)}") + + results = [] + total_start = time.time() + + for idx, item in enumerate(qa): + question = item.get(cfg["question_field"], "") + golden = item.get(cfg["answer_field"], "") + qid = item.get(cfg["id_field"], str(idx)) + + if not question: + continue + + print(f"[{idx+1}/{len(qa)}] {question[:60]}...") + + t0 = time.time() + false_answer = generate_false_answer(question) + elapsed = time.time() - t0 + + results.append({ + "id": qid, + "question": question, + "golden_answer": golden, + "false_answer": false_answer, + "generation_time_s": round(elapsed, 2), + }) + + total_time = time.time() - total_start + + out_file = output_path / f"contrastive_answers_{dataset_name}.json" + with open(out_file, "w") as f: + json.dump(results, f, indent=2) + + print(f"\nGenerated false answers for {len(results)} questions in {total_time:.0f}s") + print(f"Saved to {out_file}") + return results + + +if __name__ == "__main__": + parser = argparse.ArgumentParser() + parser.add_argument("--dataset", type=str, default="WikiEval", + choices=list(DATASET_CONFIG.keys())) + parser.add_argument("--max_questions", type=int, default=50) + parser.add_argument("--output_dir", type=str, default="contrastive_answers") + args = parser.parse_args() + + logging.basicConfig( + level=logging.INFO, + format="%(asctime)s %(levelname)s %(message)s", + force=True, + ) + run(args.dataset, args.max_questions, args.output_dir) \ No newline at end of file diff --git a/learn2rag/optimization/readme.md b/learn2rag/optimization/readme.md new file mode 100644 index 0000000..e69de29 diff --git a/learn2rag/optimization/self_judge_optimization.py b/learn2rag/optimization/self_judge_optimization.py new file mode 100644 index 0000000..93a9dc0 --- /dev/null +++ b/learn2rag/optimization/self_judge_optimization.py @@ -0,0 +1,340 @@ +""" +RAG pipeline optimization with self-judge using answer relevance only. +""" + +import argparse +import json +import logging +import pathlib +import time +import copy +import re + +import numpy as np +from sentence_transformers import SentenceTransformer +from ConfigSpace import ConfigurationSpace, Integer, Categorical, ForbiddenGreaterThanRelation +from smac import HyperparameterOptimizationFacade, Scenario + +from learn2rag.evaluation.tools import read_dataset_qa +from learn2rag.pipeline.config import opt_config +from learn2rag.pipeline.llm import llm as learn2rag_llm +from langchain_core.messages import HumanMessage +import learn2rag.pipeline.search +import learn2rag.pipeline.generate + + +DATASET_CONFIG = { + "WikiEval": { + "subdirectory": "", + "split": "train", + "question_field": "question", + "answer_field": "answer", + "id_field": "id", + }, + "rag-mini-bioasq": { + "subdirectory": "question-answer-passages", + "split": "test", + "question_field": "question", + "answer_field": "answer", + "id_field": "id", + }, + "hotpot_qa": { # Not being used + "subdirectory": "distractor", + "split": "validation", + "question_field": "question", + "answer_field": "answer", + "id_field": "id", + }, + "repliqa": { # Not being used + "subdirectory": "repliqa_4", + "split": None, + "question_field": "question", + "answer_field": "long_answer", + "id_field": "question_id", + }, +} + +PROMPT_MAP = { + "default": ( + "# Role and Objective\nYou will act as a smart AI chatbot that answers " + "questions only by using the content from the provided information list.\n\n" + "# Instructions\n- Respond in the language of the question.\n" + "- Answer clear and concise.\n- Only use the provided information.\n" + "- NEVER use your general knowledge.\n\n" + "# Information:\n{context}" + ), + "concise": ( + "Answer the question using ONLY the provided information. " + "Be concise and direct. If the information does not contain the answer, say so.\n\n" + "Information:\n{context}" + ), + "detailed": ( + "You are a knowledgeable assistant. Using ONLY the provided information below, " + "answer the question thoroughly. Cite your sources. " + "If the information is insufficient, state that clearly.\n\n" + "Information:\n{context}" + ), +} + +encoder = SentenceTransformer("all-MiniLM-L6-v2") + + +def call_llm(prompt, max_tokens=512): + response = learn2rag_llm.invoke([HumanMessage(content=prompt)], max_tokens=max_tokens) + return response.content.strip() + + +def answer_relevance(question, answer): + if not question or not answer: + return 0.0 + + generated_qs = [] + for _ in range(3): + text = call_llm( + f"Generate a question for the given answer.\n\nanswer: {answer}", + max_tokens=128, + ) + first_line = text.split("\n")[0].strip() + first_line = re.sub(r"^\d+[\.\)]\s*", "", first_line).strip() + if len(first_line) > 10: + generated_qs.append(first_line) + + if not generated_qs: + return 0.0 + + q_emb = encoder.encode([question])[0] + gen_embs = encoder.encode(generated_qs) + sims = [] + for ge in gen_embs: + cos = np.dot(q_emb, ge) / (np.linalg.norm(q_emb) * np.linalg.norm(ge) + 1e-8) + sims.append(max(0.0, float(cos))) + + return np.mean(sims) + + +def run_pipeline(question, user_config, working_config): + t0 = time.time() + docs = learn2rag.pipeline.search.search(question, user_config, working_config) + search_time = time.time() - t0 + + t0 = time.time() + answer = learn2rag.pipeline.generate.generate(question, docs, working_config) + gen_time = time.time() - t0 + + doc_list = docs.points if hasattr(docs, "points") else docs + context = "" + if doc_list: + context = "\n\n".join([ + f"Source: {d.payload.get('path', 'unknown')}\nContent: {d.payload.get('content', '')}" + for d in doc_list + ]) + return answer, context[:3000], search_time, gen_time + + +def objective(config, seed, questions, dataset_name, state, answers_dir): + state["trial_count"] += 1 + tid = state["trial_count"] + cfg = dict(config) + logging.info(f"Trial {tid}: {cfg}") + + wcfg = copy.deepcopy(opt_config) + wcfg["top_k"] = cfg["top_k"] + wcfg["chunk_size"] = cfg["chunk_size"] + wcfg["chunk_overlap"] = cfg["chunk_overlap"] + wcfg["prompt"] = PROMPT_MAP[cfg["prompt_template"]] + ucfg = {"file_path": None, "collection_name": dataset_name, + "imported_documents_file_path": None, "llm": None} + + rel_scores = [] + qa_pairs = [] + t_start = time.time() + t_search, t_gen, t_judge = 0.0, 0.0, 0.0 + + for idx, q in enumerate(questions): + if not q["question"]: + continue + try: + answer, context, st, gt = run_pipeline(q["question"], ucfg, wcfg) + t_search += st + t_gen += gt + + tj = time.time() + rel = answer_relevance(q["question"], answer) + rel_scores.append(rel) + t_judge += time.time() - tj + + qa_pairs.append({ + "id": q["id"], + "question": q["question"], + "ground_truth": q["ground_truth"], + "generated_answer": answer, + "retrieved_context": context, + "answer_relevance": float(rel), + }) + except Exception as e: + logging.warning(f"Trial {tid}, q{idx} failed: {e}") + rel_scores.append(0.0) + qa_pairs.append({ + "id": q["id"], + "question": q["question"], + "ground_truth": q["ground_truth"], + "generated_answer": "", + "retrieved_context": "", + "answer_relevance": 0.0, + }) + + if not rel_scores: + return 1.0 + + # Objective function + avg_rel = float(np.mean(rel_scores)) + cost = 1.0 - avg_rel + total_time = time.time() - t_start + + trial_data = { + "trial_id": tid, + "config": cfg, + "avg_answer_relevance": avg_rel, + "cost": float(cost), + "time_s": round(total_time, 2), + "qa_pairs": qa_pairs, + } + with open(answers_dir / f"trial_{tid}_answers.json", "w") as f: + json.dump(trial_data, f, indent=2) + + state["best_cost"] = min(state["best_cost"], cost) + state["convergence"].append({"trial": tid, "cost": float(cost), "best_cost": float(state["best_cost"])}) + state["history"].append({ + "trial_id": tid, "config": cfg, + "avg_answer_relevance": avg_rel, + "cost": float(cost), + "time_s": round(total_time, 2), + "search_s": round(t_search, 2), "gen_s": round(t_gen, 2), "judge_s": round(t_judge, 2), + }) + + logging.info( + f"Trial {tid}: answer_relevance={avg_rel:.4f} cost={cost:.4f} " + f"time={total_time:.1f}s (search={t_search:.1f} gen={t_gen:.1f} judge={t_judge:.1f})" + ) + return float(cost) + + +def param_importance(smac, output_path): + params = list(smac.scenario.configspace.keys()) + configs, costs = [], [] + for key, val in smac.runhistory.items(): + configs.append(dict(smac.runhistory.get_config(key.config_id))) + costs.append(val.cost) + if len(configs) < 3: + return {} + + raw = {} + for p in params: + groups = {} + for c, cost in zip(configs, np.array(costs)): + groups.setdefault(str(c[p]), []).append(cost) + means = [np.mean(g) for g in groups.values()] + raw[p] = float(np.var(means)) if len(means) > 1 else 0.0 + + total = sum(raw.values()) + imp = {p: round(v / total, 4) for p, v in raw.items()} if total > 0 else raw + ranking = sorted(imp, key=imp.get, reverse=True) + result = {"method": "variance_based", "ranking": ranking, "individual": imp} + with open(output_path / "parameter_importance.json", "w") as f: + json.dump(result, f, indent=2) + return result + + +def run(dataset_name, max_questions, n_trials, output_dir): + if dataset_name not in DATASET_CONFIG: + raise ValueError( + f"Unknown dataset: {dataset_name}. " + f"Available: {list(DATASET_CONFIG.keys())}" + ) + + dcfg = DATASET_CONFIG[dataset_name] + out = pathlib.Path(output_dir) / dataset_name + out.mkdir(parents=True, exist_ok=True) + answers_dir = out / "trial_answers" + answers_dir.mkdir(parents=True, exist_ok=True) + + qa = read_dataset_qa(dataset_name, dcfg["subdirectory"], dcfg["split"]) + if max_questions: + qa = qa.select(range(min(max_questions, len(qa)))) + + questions = [] + for i, r in enumerate(qa): + questions.append({ + "question": r.get(dcfg["question_field"], ""), + "ground_truth": r.get(dcfg["answer_field"], ""), + "id": r.get(dcfg["id_field"], str(i)), + }) + logging.info(f"Loaded {len(questions)} questions from {dataset_name}") + + cs = ConfigurationSpace(seed=42) + cs.add([Integer("top_k", (1, 20), default=4), + Integer("chunk_size", (200, 4000), default=2000), + Integer("chunk_overlap", (0, 500), default=200), + Categorical("prompt_template", ["default", "concise", "detailed"], default="default")]) + cs.add(ForbiddenGreaterThanRelation(cs["chunk_overlap"], cs["chunk_size"])) + + scenario = Scenario(configspace=cs, deterministic=True, n_trials=n_trials, + walltime_limit=36000, seed=42, output_directory=out / "smac_output") + + state = {"trial_count": 0, "best_cost": 1.0, "convergence": [], "history": []} + smac = HyperparameterOptimizationFacade( + scenario=scenario, + target_function=lambda config, seed=0: objective( + config, seed, questions, dataset_name, state, answers_dir + ), + ) + + t0 = time.time() + incumbent = smac.optimize() + total_time = time.time() - t0 + + importance = param_importance(smac, out) + + with open(out / "optimization_results.json", "w") as f: + json.dump({ + "best_config": dict(incumbent), + "run_history": state["history"], + "convergence": state["convergence"], + "parameter_importance": importance, + "total_time_s": round(total_time, 2), + "dataset": dataset_name, + "generator": "gemma-3-27b-it", + "judge": "gemma-3-27b-it (self-judge)", + "metrics": ["answer_relevance"], + "metric_source": "Es et al. (2023) RAGAS arXiv:2309.15217v2", + }, f, indent=2, default=str) + + logging.info(f"Done in {total_time:.0f}s") + return incumbent, state["history"], importance + + +if __name__ == "__main__": + parser = argparse.ArgumentParser() + parser.add_argument("--dataset", type=str, default="WikiEval", + choices=list(DATASET_CONFIG.keys())) + parser.add_argument("--max_questions", type=int, default=50) + parser.add_argument("--n_trials", type=int, default=10) + parser.add_argument("--output_dir", type=str, default="optimization_results_selfjudge") + args = parser.parse_args() + + logging.basicConfig( + level=logging.INFO, + format="%(asctime)s %(levelname)s %(message)s", + force=True, + ) + incumbent, history, importance = run( + args.dataset, args.max_questions, args.n_trials, args.output_dir, + ) + + best = min(history, key=lambda x: x["cost"]) + print(f"\nBest config: {dict(incumbent)}") + print(f"Answer Relevance: {best['avg_answer_relevance']:.4f}") + if importance: + print(f"\nParameter importance:") + for i, p in enumerate(importance["ranking"], 1): + print(f" {i}. {p}: {importance['individual'][p]:.4f}") \ No newline at end of file From 0f8f87f504a72d53e90247b6b0f66a1518bff64c Mon Sep 17 00:00:00 2001 From: farshad68 Date: Fri, 24 Apr 2026 11:46:54 +0200 Subject: [PATCH 02/47] first integrated version , RAG throw an exception --- learn2rag/evaluation/tools.py | 1 + learn2rag/pipeline/config.py | 53 +++++++++++++++++++++++++++++++++-- learn2rag/ui/__init__.py | 6 ++-- 3 files changed, 55 insertions(+), 5 deletions(-) diff --git a/learn2rag/evaluation/tools.py b/learn2rag/evaluation/tools.py index b91d0d7..3da8ffe 100644 --- a/learn2rag/evaluation/tools.py +++ b/learn2rag/evaluation/tools.py @@ -80,6 +80,7 @@ def ingest_dataset_documents(dataset_name: str) -> None: def read_dataset_qa(dataset_name: str, subdirectory: str, split: str | None=None) -> Any: logging.debug(f'{dataset_name=}') dataset_work_dir = pathlib.Path('./datasets') / dataset_name + dataset_work_dir = dataset_work_dir.resolve() dataset_dict = datasets.load_from_disk(dataset_work_dir / 'source' / subdirectory) return dataset_dict[split] if split is not None else dataset_dict diff --git a/learn2rag/pipeline/config.py b/learn2rag/pipeline/config.py index 1433172..772f351 100644 --- a/learn2rag/pipeline/config.py +++ b/learn2rag/pipeline/config.py @@ -1,5 +1,12 @@ import json import os +import logging +import collections.abc +from typing import Any + + + +opt_config: dict[str, Any] = {} with open(os.environ.get("PIPELINE_USER_CONFIG", "learn2rag/pipeline/user_config.json"), "r") as file: user_config = json.load(file) @@ -7,5 +14,47 @@ with open(os.environ.get("IMPORTER_CONFIG", "learn2rag/importer/config/config.json"), "r") as file: importer_config = json.load(file) -with open(os.environ.get("PIPELINE_OPT_CONFIG", "learn2rag/pipeline/opt_config.json"), "r") as file: - opt_config = json.load(file) +def refresh_configs(): + global opt_config + logging.info(f"Refreshing configs...") + with open(os.environ.get("PIPELINE_OPT_CONFIG", "learn2rag/pipeline/opt_config.json"), "r") as file: + base_data = json.load(file) + + final_data = base_data + + patch_path = os.environ.get("PIPELINE_OPT_PATCH_CONFIG", "learn2rag/pipeline/opt_patch_config.json") + if os.path.exists(patch_path): + logging.info(f"Patch found! Layering {patch_path} onto defaults.") + try: + with open(patch_path, "r") as f: + patch_data = json.load(f) + # Overlay the patch onto our final_data + final_data = deep_update(base_data, patch_data) + except json.JSONDecodeError: + logging.error(f"Patch file at {patch_path} is corrupted. Skipping overlay.") + else: + # This is the "Fallback" behavior + logging.warning(f"No patch file found at {patch_path}. System will run on default settings.") + logging.info(f"Refreshing configs done {final_data}") + opt_config.clear() + opt_config.update(final_data) + + logging.info(f"FINAL OPT_CONFIG STRUCTURE: {json.dumps(opt_config, indent=2)}") + + +def deep_update(base_dict, overrides): + """Recursively merges overrides into base_dict.""" + for key, value in overrides.items(): + if isinstance(value, collections.abc.Mapping): + if key in base_dict and not isinstance(base_dict[key], collections.abc.Mapping): + logging.error(f"Type Mismatch at '{key}': expected dict, got {type(base_dict[key])}") + base_dict[key] = {} + base_dict[key] = deep_update(base_dict.get(key, {}), value) + else: + logging.info(f"Overriding '{key}': {base_dict.get(key)} -> {value}") + base_dict[key] = value + return base_dict + + +# Initial load on module import +refresh_configs() \ No newline at end of file diff --git a/learn2rag/ui/__init__.py b/learn2rag/ui/__init__.py index 0678800..c63fb05 100644 --- a/learn2rag/ui/__init__.py +++ b/learn2rag/ui/__init__.py @@ -28,8 +28,8 @@ from learn2rag.compose import Project import learn2rag.data import learn2rag.pipeline.llm - -from datetime import datetime # <-- ADD THIS +from learn2rag.pipeline.config import refresh_configs +from datetime import datetime logging.getLogger().addHandler(flask.logging.default_handler) @@ -388,7 +388,7 @@ def pipeline_create() -> 'str | werkzeug.wrappers.response.Response': def start_pipeline(name: str, pipeline: dict[str, Any], template_name: str) -> None: has_ssl = bool(app.config.get("TLS")) - + refresh_configs() url = urllib.parse.urlparse(request.base_url) assert url.scheme From 1f1a562224aff93c54b61eaeccb5c0c101e235bb Mon Sep 17 00:00:00 2001 From: farshad68 Date: Fri, 24 Apr 2026 12:06:28 +0200 Subject: [PATCH 03/47] add new dependencies --- pyproject.toml | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/pyproject.toml b/pyproject.toml index feb8e7f..e53ed41 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -188,6 +188,10 @@ dependencies = [ "python-pptx (>=1.0.2,<2.0.0)", "msoffcrypto-tool (>=6.0.0,<7.0.0)", "ebooklib (>=0.20,<0.21)", + "bert-score==0.3.13", + "ConfigSpace==1.2.2", + "scikit-learn==1.8.0", + "smac (>=2.3.1)" ] description = "" license = "MIT" From 4f9a4a0e78f4f5c0253f2941dc71e83e3497f7b9 Mon Sep 17 00:00:00 2001 From: farshad68 Date: Wed, 29 Apr 2026 10:53:09 +0200 Subject: [PATCH 04/47] add more logs and fallback --- learn2rag/pipeline/config.py | 28 ++++++++++++++++++++++------ 1 file changed, 22 insertions(+), 6 deletions(-) diff --git a/learn2rag/pipeline/config.py b/learn2rag/pipeline/config.py index 772f351..1bb9a9e 100644 --- a/learn2rag/pipeline/config.py +++ b/learn2rag/pipeline/config.py @@ -8,17 +8,33 @@ opt_config: dict[str, Any] = {} -with open(os.environ.get("PIPELINE_USER_CONFIG", "learn2rag/pipeline/user_config.json"), "r") as file: - user_config = json.load(file) +user_config_path = os.environ.get("PIPELINE_USER_CONFIG", "learn2rag/pipeline/user_config.json") +try: + with open(user_config_path , "r") as file: + user_config = json.load(file) +except: + logging.error(f"User Config file not found at {user_config_path}. Using default settings.") + user_config = {} -with open(os.environ.get("IMPORTER_CONFIG", "learn2rag/importer/config/config.json"), "r") as file: - importer_config = json.load(file) + +importer_config_path = os.environ.get("IMPORTER_CONFIG", "learn2rag/importer/config/config.json") +try: + with open(importer_config_path, "r") as file: + importer_config = json.load(file) +except: + logging.error(f"Importer Config file not found at {importer_config_path}. Using default settings.") + importer_config = {} def refresh_configs(): global opt_config logging.info(f"Refreshing configs...") - with open(os.environ.get("PIPELINE_OPT_CONFIG", "learn2rag/pipeline/opt_config.json"), "r") as file: - base_data = json.load(file) + pipeline_config_path = os.environ.get("PIPELINE_OPT_CONFIG", "learn2rag/pipeline/opt_config.json") + try: + with open(pipeline_config_path, "r") as file: + base_data = json.load(file) + except: + logging.error(f"Pipeline Config file not found at {pipeline_config_path}. Using default settings.") + base_data = {} final_data = base_data From bb37d532dbae2ca25841b66b196c1bb93d73bb2e Mon Sep 17 00:00:00 2001 From: farshad68 Date: Wed, 29 Apr 2026 16:28:37 +0200 Subject: [PATCH 05/47] make config simple - now we just rewrite the base config - no patching --- learn2rag/evaluation/tools.py | 2 - learn2rag/optimization/__init__.py | 62 ++++++++++ learn2rag/pipeline/config.py | 77 ++---------- learn2rag/ui/__init__.py | 3 +- .../compose/pipelines/optimization.yml | 114 ++++++++++++++++++ 5 files changed, 184 insertions(+), 74 deletions(-) create mode 100644 learn2rag/optimization/__init__.py create mode 100644 learn2rag/ui/templates/compose/pipelines/optimization.yml diff --git a/learn2rag/evaluation/tools.py b/learn2rag/evaluation/tools.py index 3da8ffe..d221fa5 100644 --- a/learn2rag/evaluation/tools.py +++ b/learn2rag/evaluation/tools.py @@ -78,9 +78,7 @@ def ingest_dataset_documents(dataset_name: str) -> None: def read_dataset_qa(dataset_name: str, subdirectory: str, split: str | None=None) -> Any: - logging.debug(f'{dataset_name=}') dataset_work_dir = pathlib.Path('./datasets') / dataset_name - dataset_work_dir = dataset_work_dir.resolve() dataset_dict = datasets.load_from_disk(dataset_work_dir / 'source' / subdirectory) return dataset_dict[split] if split is not None else dataset_dict diff --git a/learn2rag/optimization/__init__.py b/learn2rag/optimization/__init__.py new file mode 100644 index 0000000..24703c2 --- /dev/null +++ b/learn2rag/optimization/__init__.py @@ -0,0 +1,62 @@ +import logging +import pathlib +import os +import json +import collections.abc +import copy +from os import mkdir + +from . import baseline_optimization +#TODO : now we need to copy the dataset to here manually it should consider in installation maybe ! +# {storage_path}/datasets/WikiEval/ +def main() -> None: + logging.error("optimization is started") + dataset_name = "WikiEval" + + output_dir = pathlib.Path("./optimization/output/") + output_dir.mkdir(parents=True, exist_ok=True) + + baseline_optimization.run(dataset_name,10,10,output_dir) + logging.error("optimization is done") + results_path = output_dir /dataset_name/ "optimization_results.json" + logging.info(f"save optimized results here : {results_path}") + if not results_path.exists(): + logging.error(f"Optimization results not found at {results_path}") + return + + with open(results_path, "r") as f: + full_results = json.load(f) + + best_config = full_results.get("best_config", {}) + + target_config_path = os.environ.get("PIPELINE_OPT_CONFIG", "learn2rag/pipeline/opt_config.json") + + existing_config = {} + if os.path.exists(target_config_path): + try: + with open(target_config_path, "r", encoding="utf-8") as f: + existing_config = json.load(f) + except json.JSONDecodeError: + logging.error(f"Existing config at {target_config_path} is corrupted. It will be overwritten.") + + updated_config = deep_update(existing_config, best_config) + + pathlib.Path(target_config_path).parent.mkdir(parents=True, exist_ok=True) + with open(target_config_path, "w", encoding="utf-8") as f: + json.dump(updated_config, f, indent=4) + + logging.info(f"Successfully updated opt_config at: {target_config_path}") + +def deep_update(base_dict, overrides): + """Recursively merges overrides into a copy of base_dict, returning the new dict.""" + result = copy.deepcopy(base_dict) + for key, value in overrides.items(): + if isinstance(value, collections.abc.Mapping): + if key in result and not isinstance(result[key], collections.abc.Mapping): + logging.error(f"Type Mismatch at '{key}': expected dict, got {type(result[key])}") + result[key] = {} + result[key] = deep_update(result.get(key, {}), value) + else: + logging.info(f"Overriding '{key}': {result.get(key)} -> {value}") + result[key] = value + return result diff --git a/learn2rag/pipeline/config.py b/learn2rag/pipeline/config.py index 1bb9a9e..b0677fb 100644 --- a/learn2rag/pipeline/config.py +++ b/learn2rag/pipeline/config.py @@ -1,76 +1,13 @@ import json import os import logging -import collections.abc -from typing import Any +with open(os.environ.get("PIPELINE_USER_CONFIG", "learn2rag/pipeline/user_config.json"), "r") as file: + user_config = json.load(file) +with open(os.environ.get("IMPORTER_CONFIG", "learn2rag/importer/config/config.json"), "r") as file: + importer_config = json.load(file) -opt_config: dict[str, Any] = {} - -user_config_path = os.environ.get("PIPELINE_USER_CONFIG", "learn2rag/pipeline/user_config.json") -try: - with open(user_config_path , "r") as file: - user_config = json.load(file) -except: - logging.error(f"User Config file not found at {user_config_path}. Using default settings.") - user_config = {} - - -importer_config_path = os.environ.get("IMPORTER_CONFIG", "learn2rag/importer/config/config.json") -try: - with open(importer_config_path, "r") as file: - importer_config = json.load(file) -except: - logging.error(f"Importer Config file not found at {importer_config_path}. Using default settings.") - importer_config = {} - -def refresh_configs(): - global opt_config - logging.info(f"Refreshing configs...") - pipeline_config_path = os.environ.get("PIPELINE_OPT_CONFIG", "learn2rag/pipeline/opt_config.json") - try: - with open(pipeline_config_path, "r") as file: - base_data = json.load(file) - except: - logging.error(f"Pipeline Config file not found at {pipeline_config_path}. Using default settings.") - base_data = {} - - final_data = base_data - - patch_path = os.environ.get("PIPELINE_OPT_PATCH_CONFIG", "learn2rag/pipeline/opt_patch_config.json") - if os.path.exists(patch_path): - logging.info(f"Patch found! Layering {patch_path} onto defaults.") - try: - with open(patch_path, "r") as f: - patch_data = json.load(f) - # Overlay the patch onto our final_data - final_data = deep_update(base_data, patch_data) - except json.JSONDecodeError: - logging.error(f"Patch file at {patch_path} is corrupted. Skipping overlay.") - else: - # This is the "Fallback" behavior - logging.warning(f"No patch file found at {patch_path}. System will run on default settings.") - logging.info(f"Refreshing configs done {final_data}") - opt_config.clear() - opt_config.update(final_data) - - logging.info(f"FINAL OPT_CONFIG STRUCTURE: {json.dumps(opt_config, indent=2)}") - - -def deep_update(base_dict, overrides): - """Recursively merges overrides into base_dict.""" - for key, value in overrides.items(): - if isinstance(value, collections.abc.Mapping): - if key in base_dict and not isinstance(base_dict[key], collections.abc.Mapping): - logging.error(f"Type Mismatch at '{key}': expected dict, got {type(base_dict[key])}") - base_dict[key] = {} - base_dict[key] = deep_update(base_dict.get(key, {}), value) - else: - logging.info(f"Overriding '{key}': {base_dict.get(key)} -> {value}") - base_dict[key] = value - return base_dict - - -# Initial load on module import -refresh_configs() \ No newline at end of file +with open(os.environ.get("PIPELINE_OPT_CONFIG", "learn2rag/pipeline/opt_config.json"), "r") as file: + opt_config = json.load(file) + logging.info(f"Loaded opt_config:\n{json.dumps(opt_config, indent=4)}") diff --git a/learn2rag/ui/__init__.py b/learn2rag/ui/__init__.py index 2d9739b..068190e 100644 --- a/learn2rag/ui/__init__.py +++ b/learn2rag/ui/__init__.py @@ -29,7 +29,7 @@ from learn2rag.compose import Project import learn2rag.data import learn2rag.pipeline.llm -from learn2rag.pipeline.config import refresh_configs + from datetime import datetime @@ -410,7 +410,6 @@ def pipeline_create() -> 'str | werkzeug.wrappers.response.Response': def start_pipeline(name: str, pipeline: dict[str, Any], template_name: str) -> None: has_ssl = bool(app.config.get("TLS")) - refresh_configs() url = urllib.parse.urlparse(request.base_url) assert url.scheme diff --git a/learn2rag/ui/templates/compose/pipelines/optimization.yml b/learn2rag/ui/templates/compose/pipelines/optimization.yml new file mode 100644 index 0000000..c721f88 --- /dev/null +++ b/learn2rag/ui/templates/compose/pipelines/optimization.yml @@ -0,0 +1,114 @@ +name: optimization +label: Optimize +ports: + # TODO: labels in the interface currently assume a specific port order + - ui + - qdrant_http +files: + - path: '{{storage_path}}/basic_user_config.json' + content: | + { + "collection_name": "learn2rag", + "imported_documents_file_path": "loaded_documents.json", + "llm": "{{language_model.model}}" + } + - path: '{{storage_path}}/qdrant_config.yml' + content: | + log_level: INFO + service: + api_key: '{{qdrant_api_key}}' + grpc_port: null + http_port: '{{ports.qdrant_http}}' + host: '127.0.0.1' + telemetry_disabled: true + - path: '{{storage_path}}/logging_config.yml' + content: | + version: 1 + formatters: + simple: + format: "%(asctime)s %(levelname)-8s %(name)s %(message)s" + colored: + class: colorlog.ColoredFormatter + format: "%(log_color)s%(asctime)s %(levelname)-8s %(name)s %(message)s" + profiling: + format: "%(created)f %(request_id)s %(activity)s %(message)s" + handlers: + display: + class: logging.StreamHandler + level: INFO + formatter: colored + stream: ext://sys.stderr + profiling_display: + class: logging.StreamHandler + formatter: profiling + stream: ext://sys.stderr + profiling_file: + class: logging.FileHandler + formatter: profiling + filename: '{{storage_path}}/logs/profiling.log' + encoding: utf-8 + errors_file: + class: logging.FileHandler + level: ERROR + formatter: simple + filename: '{{storage_path}}/logs/error.log' + encoding: utf-8 + {% if debug_logging %} + debug_file: + class: logging.FileHandler + level: DEBUG + formatter: simple + filename: '{{storage_path}}/logs/debug.log' + encoding: utf-8 + {% endif %} + loggers: + profiling: + handlers: + - profiling_display + - profiling_file + propagate: no + root: + level: DEBUG + handlers: + - display + - errors_file + {% if debug_logging %} + - debug_file + {% endif %} + + - path: '{{storage_path}}/logs/.keep' + content: '' + +services: + qdrant: + working_dir: '{{storage_path}}' + command: + - '{{learn2rag_path}}/services/qdrant/qdrant{% if is_windows %}.exe{% endif %}' + - '--config-path' + - '{{storage_path}}/qdrant_config.yml' + # https://qdrant.tech/documentation/guides/configuration/ + environment: + QDRANT__LOG_LEVEL: 'ERROR' + QDRANT__SERVICE__HOST: '127.0.0.1' + QDRANT__SERVICE__HTTP_PORT: '{{ports.qdrant_http}}' + QDRANT__TELEMETRY_DISABLED: 'true' + main: + working_dir: '{{storage_path}}' + command: + - '{{learn2rag_path}}/configurator{% if is_windows %}.exe{% endif %}' + - 'learn2rag.optimization' + - '--logging-config' + - '{{storage_path}}/logging_config.yml' + environment: + LEARN2RAG_PATH: '{{learn2rag_path}}' + QDRANT__SERVICE__HTTP_PORT: '{{ports.qdrant_http}}' + QDRANT__SERVICE__API_KEY: '{{qdrant_api_key}}' + PIPELINE_USER_CONFIG: '{{storage_path}}/basic_user_config.json' + IMPORTER_CONFIG: '{{storage_path}}/importer_config.json' + PIPELINE_OPT_CONFIG: '{{learn2rag_path}}/learn2rag/pipeline/opt_config.json' + LANGCHAIN_API_KEY: '1' + LANGCHAIN_TRACING_V2: 'false' + LLM_API_TYPE: '{{language_model.api}}' + LLM_API_URL: '{{language_model.url}}' + LLM_API_TOKEN: '{{language_model.token}}' + LLM_API_MODEL: '{{language_model.model}}' From 78bb9aff8f06c063403fb2a9e004a83973decc93 Mon Sep 17 00:00:00 2001 From: farshad68 Date: Mon, 4 May 2026 11:57:50 +0200 Subject: [PATCH 06/47] make dataset names and args not hardcoded in optimization __init__ --- learn2rag/evaluation/tools.py | 1 + learn2rag/optimization/__init__.py | 54 +++++++++++++++++++----------- 2 files changed, 36 insertions(+), 19 deletions(-) diff --git a/learn2rag/evaluation/tools.py b/learn2rag/evaluation/tools.py index d221fa5..b91d0d7 100644 --- a/learn2rag/evaluation/tools.py +++ b/learn2rag/evaluation/tools.py @@ -78,6 +78,7 @@ def ingest_dataset_documents(dataset_name: str) -> None: def read_dataset_qa(dataset_name: str, subdirectory: str, split: str | None=None) -> Any: + logging.debug(f'{dataset_name=}') dataset_work_dir = pathlib.Path('./datasets') / dataset_name dataset_dict = datasets.load_from_disk(dataset_work_dir / 'source' / subdirectory) return dataset_dict[split] if split is not None else dataset_dict diff --git a/learn2rag/optimization/__init__.py b/learn2rag/optimization/__init__.py index 24703c2..84a6ef1 100644 --- a/learn2rag/optimization/__init__.py +++ b/learn2rag/optimization/__init__.py @@ -4,24 +4,42 @@ import json import collections.abc import copy -from os import mkdir +import yaml +import argparse from . import baseline_optimization #TODO : now we need to copy the dataset to here manually it should consider in installation maybe ! # {storage_path}/datasets/WikiEval/ def main() -> None: - logging.error("optimization is started") - dataset_name = "WikiEval" + parser = argparse.ArgumentParser(description="Run RAG baseline optimization.") + parser.add_argument("task", help="Module task name (e.g., learn2rag.optimization)") + parser.add_argument("--logging-config", type=str, help="Path to logging config yml") + parser.add_argument("--dataset", type=str, default="WikiEval") + parser.add_argument("--questions", type=int, default=10) + parser.add_argument("--trials", type=int, default=10) + args, unknown = parser.parse_known_args() + + if args.logging_config and pathlib.Path(args.logging_config).exists(): + with open(args.logging_config, 'r') as f: + config = yaml.safe_load(f) + logging.config.dictConfig(config) + + logger = logging.getLogger(__name__) + logger.info(f"Running task: {args.task}") + + + logging.info(f"Optimization started for {args.dataset}") + #TODO : read or get dataset_name and maxquestions and n_trails output_dir = pathlib.Path("./optimization/output/") output_dir.mkdir(parents=True, exist_ok=True) - baseline_optimization.run(dataset_name,10,10,output_dir) - logging.error("optimization is done") - results_path = output_dir /dataset_name/ "optimization_results.json" + baseline_optimization.run(args.dataset,args.questions,args.trials,output_dir) + logging.info("optimization is done") + results_path = output_dir /args.dataset/ "optimization_results.json" logging.info(f"save optimized results here : {results_path}") if not results_path.exists(): - logging.error(f"Optimization results not found at {results_path}") + logging.warning(f"Optimization results not found at {results_path}") return with open(results_path, "r") as f: @@ -39,7 +57,7 @@ def main() -> None: except json.JSONDecodeError: logging.error(f"Existing config at {target_config_path} is corrupted. It will be overwritten.") - updated_config = deep_update(existing_config, best_config) + updated_config = deep_update(copy.deepcopy(existing_config), best_config) pathlib.Path(target_config_path).parent.mkdir(parents=True, exist_ok=True) with open(target_config_path, "w", encoding="utf-8") as f: @@ -47,16 +65,14 @@ def main() -> None: logging.info(f"Successfully updated opt_config at: {target_config_path}") -def deep_update(base_dict, overrides): - """Recursively merges overrides into a copy of base_dict, returning the new dict.""" - result = copy.deepcopy(base_dict) +def deep_update(source, overrides): + """Recursively updates a dictionary.""" for key, value in overrides.items(): - if isinstance(value, collections.abc.Mapping): - if key in result and not isinstance(result[key], collections.abc.Mapping): - logging.error(f"Type Mismatch at '{key}': expected dict, got {type(result[key])}") - result[key] = {} - result[key] = deep_update(result.get(key, {}), value) + if isinstance(value, collections.abc.Mapping) and key in source: + deep_update(source.get(key, {}), value) else: - logging.info(f"Overriding '{key}': {result.get(key)} -> {value}") - result[key] = value - return result + source[key] = value + return source + +if __name__ == "__main__": + main() \ No newline at end of file From a5ee3507dfdb4613bf2ed6255f750da614a6579e Mon Sep 17 00:00:00 2001 From: farshad68 Date: Mon, 4 May 2026 12:00:25 +0200 Subject: [PATCH 07/47] chore: update uv.lock after dependency changes --- uv.lock | 243 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 243 insertions(+) diff --git a/uv.lock b/uv.lock index ba2dd60..1244a31 100644 --- a/uv.lock +++ b/uv.lock @@ -208,6 +208,25 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/1a/39/47f9197bdd44df24d67ac8893641e16f386c984a0619ef2ee4c51fbbc019/beautifulsoup4-4.14.3-py3-none-any.whl", hash = "sha256:0918bfe44902e6ad8d57732ba310582e98da931428d231a5ecb9e7c703a735bb", size = 107721, upload-time = "2025-11-30T15:08:24.087Z" }, ] +[[package]] +name = "bert-score" +version = "0.3.13" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "matplotlib" }, + { name = "numpy" }, + { name = "packaging" }, + { name = "pandas" }, + { name = "requests" }, + { name = "torch" }, + { name = "tqdm" }, + { name = "transformers" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/1c/93/2c97a85cbb66a8a256a13176e11c9c4508074e2341299fe75ee955c81eff/bert_score-0.3.13.tar.gz", hash = "sha256:8ffe5838eac8cdd988b8b1a896af7f49071188c8c011a1ed160d71a9899a2ba4", size = 48621, upload-time = "2023-02-20T21:07:29.477Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c6/8c/bc5457de4c004b1a623b31f7bc8d0375fb699b7d67df11879098b4b7b7c8/bert_score-0.3.13-py3-none-any.whl", hash = "sha256:bbbb4c7fcdaa46d7681aff49f37f96faa09ed74e1b150e659bdc6b58a66989b9", size = 61135, upload-time = "2023-02-20T21:07:27.226Z" }, +] + [[package]] name = "blinker" version = "1.9.0" @@ -350,6 +369,15 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/ae/8a/c4bb04426d608be4a3171efa2e233d2c59a5c8937850c10d098e126df18e/cloudpathlib-0.23.0-py3-none-any.whl", hash = "sha256:8520b3b01468fee77de37ab5d50b1b524ea6b4a8731c35d1b7407ac0cd716002", size = 62755, upload-time = "2025-10-07T22:47:54.905Z" }, ] +[[package]] +name = "cloudpickle" +version = "3.1.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/27/fb/576f067976d320f5f0114a8d9fa1215425441bb35627b1993e5afd8111e5/cloudpickle-3.1.2.tar.gz", hash = "sha256:7fda9eb655c9c230dab534f1983763de5835249750e85fbcef43aaa30a9a2414", size = 22330, upload-time = "2025-11-03T09:25:26.604Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/88/39/799be3f2f0f38cc727ee3b4f1445fe6d5e4133064ec2e4115069418a5bb6/cloudpickle-3.1.2-py3-none-any.whl", hash = "sha256:9acb47f6afd73f60dc1df93bb801b472f05ff42fa6c84167d25cb206be1fbf4a", size = 22228, upload-time = "2025-11-03T09:25:25.534Z" }, +] + [[package]] name = "colorama" version = "0.4.6" @@ -401,6 +429,22 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/8d/e4/d66708bdf0d92fb4d49b22cdff4b10cec38aca5dcd7e81d909bb55c65cd7/confection-1.3.3-py3-none-any.whl", hash = "sha256:b9fef9ee84b237ef4611ec3eb5797b70e13063e6310ad9f15536373f5e313c82", size = 35902, upload-time = "2026-03-24T18:45:22.664Z" }, ] +[[package]] +name = "configspace" +version = "1.2.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "more-itertools" }, + { name = "numpy" }, + { name = "pyparsing" }, + { name = "scipy" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/ae/51/7a63132fdc3a71eea66d9f81b451a61a38631af0a73bdcda1ec784cea32e/configspace-1.2.2.tar.gz", hash = "sha256:b5cc981c145ef9632104d230acf963c2f68fe5a375983946e941c2eec5dd08e4", size = 134158, upload-time = "2025-12-19T12:52:39.628Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/56/67/01bf8795064d2132d7244341908f75bb2ea87dc114364cd8c5b20c606a8f/configspace-1.2.2-py3-none-any.whl", hash = "sha256:9dd5090fab08fbfc0fa8a66affb53e991e9df65ae20959fcee8e544bb3c0a09d", size = 117584, upload-time = "2025-12-19T12:52:37.545Z" }, +] + [[package]] name = "contourpy" version = "1.3.3" @@ -502,6 +546,42 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/54/3f/35701c13e1fc7b0895198c8b20068c569a841e0daf8e0b14d1dc0816b28f/cymem-2.0.13-cp313-cp313t-win_arm64.whl", hash = "sha256:042e8611ef862c34a97b13241f5d0da86d58aca3cecc45c533496678e75c5a1f", size = 38964, upload-time = "2025-11-14T14:58:02.87Z" }, ] +[[package]] +name = "dask" +version = "2026.3.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "click" }, + { name = "cloudpickle" }, + { name = "fsspec" }, + { name = "packaging" }, + { name = "partd" }, + { name = "pyyaml" }, + { name = "toolz" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/d7/2a/5d8cc1579590af86576dde890254440e478c7174b93a02095ecfc2e6ba38/dask-2026.3.0.tar.gz", hash = "sha256:f7d96c8274e8a900d217c1ff6ea8d1bbf0b4c2c21e74a409644498d925eb8f85", size = 11000710, upload-time = "2026-03-18T07:10:14.945Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/4a/f3/00bb1e867fba351e2d784170955713bee200c43ea306c59f30bd7e748192/dask-2026.3.0-py3-none-any.whl", hash = "sha256:be614b9242b0b38288060fb2d7696125946469c98a1c30e174883fd199e0428d", size = 1485630, upload-time = "2026-03-18T07:10:12.832Z" }, +] + +[package.optional-dependencies] +distributed = [ + { name = "distributed" }, +] + +[[package]] +name = "dask-jobqueue" +version = "0.9.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "dask" }, + { name = "distributed" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/32/2a/751bb5ba28533476b1c667eac158e5aa1840c416fd61d425328ef48a894a/dask_jobqueue-0.9.0.tar.gz", hash = "sha256:494ef64b7bb3848c7d72ed334c288030caca6a09dca54cfaa3f395f4ba7f5c47", size = 56475, upload-time = "2024-08-22T09:25:21.56Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/57/77/606f138bf70b14865842b3ec9a58dc1ba97153f466e5876fe4ced980f91f/dask_jobqueue-0.9.0-py2.py3-none-any.whl", hash = "sha256:253dfc4f0b8722201a08e05b841859dfeea1f6698ff21eff0d9370e5aa8ae20f", size = 52037, upload-time = "2024-08-22T09:25:20.106Z" }, +] + [[package]] name = "dataclasses-json" version = "0.6.7" @@ -583,6 +663,32 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/1e/77/dc8c558f7593132cf8fefec57c4f60c83b16941c574ac5f619abb3ae7933/dill-0.4.1-py3-none-any.whl", hash = "sha256:1e1ce33e978ae97fcfcff5638477032b801c46c7c65cf717f95fbc2248f79a9d", size = 120019, upload-time = "2026-01-19T02:36:55.663Z" }, ] +[[package]] +name = "distributed" +version = "2026.3.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "click" }, + { name = "cloudpickle" }, + { name = "dask" }, + { name = "jinja2" }, + { name = "locket" }, + { name = "msgpack" }, + { name = "packaging" }, + { name = "psutil" }, + { name = "pyyaml" }, + { name = "sortedcontainers" }, + { name = "tblib" }, + { name = "toolz" }, + { name = "tornado" }, + { name = "urllib3" }, + { name = "zict" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/e7/84/3e98a2d61493d201f253743091cbd4f099f502f957a9a33bb9ce5b8d5416/distributed-2026.3.0.tar.gz", hash = "sha256:4a8fc6102fededfbaae45288501276da2297a054d74eb6589f01b087c7f95c26", size = 2103970, upload-time = "2026-03-18T07:10:23.555Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b9/77/2ff7aefc09cf1306a81cd7a46af34f80ebefef81a2e8329b94b58ad813ae/distributed-2026.3.0-py3-none-any.whl", hash = "sha256:52518f4b3e6795e87b442e8f57788ba1ddc750c62d0835669c85927280d38f07", size = 1009769, upload-time = "2026-03-18T07:10:21.241Z" }, +] + [[package]] name = "distro" version = "1.9.0" @@ -621,6 +727,18 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/9c/13/563119fe0af82aca5a3b89399c435953072c39515c2e818eb82793955c3b/effdet-0.4.1-py3-none-any.whl", hash = "sha256:10889a226228d515c948e3fcf811e64c0d78d7aa94823a300045653b9c284cb7", size = 112513, upload-time = "2023-05-21T22:17:58.47Z" }, ] +[[package]] +name = "emcee" +version = "3.1.6" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "numpy" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/cb/53/1045ee878cb24281387079f8ee4f0ade1622c6aae1ed1fd91a53e4fa5b19/emcee-3.1.6.tar.gz", hash = "sha256:11af4daf6ab8f9ca69681e3c29054665db7bbd87fd4eb8e437d2c3a1248c637d", size = 2871117, upload-time = "2024-04-19T10:03:19.555Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f9/ef/2196b9bf88ffa1bde45853c72df021fbd07a8fa91a0f59a22d14a050dc04/emcee-3.1.6-py2.py3-none-any.whl", hash = "sha256:f2d63752023bdccf744461450e512a5b417ae7d28f18e12acd76a33de87580cb", size = 47351, upload-time = "2024-04-19T10:03:17.522Z" }, +] + [[package]] name = "emoji" version = "2.15.0" @@ -1675,6 +1793,7 @@ dependencies = [ { name = "azure-identity" }, { name = "backoff" }, { name = "beautifulsoup4" }, + { name = "bert-score" }, { name = "build" }, { name = "cachetools" }, { name = "certifi" }, @@ -1684,6 +1803,7 @@ dependencies = [ { name = "colorama" }, { name = "coloredlogs" }, { name = "colorlog" }, + { name = "configspace" }, { name = "contourpy" }, { name = "cryptography" }, { name = "cycler" }, @@ -1808,11 +1928,13 @@ dependencies = [ { name = "requests-toolbelt" }, { name = "rsa" }, { name = "safetensors" }, + { name = "scikit-learn" }, { name = "scipy" }, { name = "sentence-transformers" }, { name = "setuptools" }, { name = "simsimd" }, { name = "six" }, + { name = "smac" }, { name = "sniffio" }, { name = "soupsieve" }, { name = "sqlalchemy" }, @@ -1863,6 +1985,7 @@ requires-dist = [ { name = "azure-identity", specifier = ">=1.25.1,<2.0.0" }, { name = "backoff", specifier = "==2.2.1" }, { name = "beautifulsoup4", specifier = ">=4.14.3,<5.0.0" }, + { name = "bert-score", specifier = "==0.3.13" }, { name = "build", specifier = "==1.3.0" }, { name = "cachetools", specifier = "==5.5.2" }, { name = "certifi", specifier = "==2025.8.3" }, @@ -1872,6 +1995,7 @@ requires-dist = [ { name = "colorama", specifier = "==0.4.6" }, { name = "coloredlogs", specifier = "==15.0.1" }, { name = "colorlog", specifier = ">=6.9.0,<7.0.0" }, + { name = "configspace", specifier = "==1.2.2" }, { name = "contourpy", specifier = "==1.3.3" }, { name = "cryptography", specifier = "==45.0.6" }, { name = "cycler", specifier = "==0.12.1" }, @@ -1997,11 +2121,13 @@ requires-dist = [ { name = "requests-toolbelt", specifier = "==1.0.0" }, { name = "rsa", specifier = "==4.9.1" }, { name = "safetensors", specifier = "==0.6.2" }, + { name = "scikit-learn", specifier = "==1.8.0" }, { name = "scipy", specifier = "==1.16.1" }, { name = "sentence-transformers", specifier = ">=5.0.0,<6.0.0" }, { name = "setuptools", specifier = "==80.9.0" }, { name = "simsimd", specifier = ">=6.5.0,<7.0.0" }, { name = "six", specifier = "==1.17.0" }, + { name = "smac", specifier = ">=2.3.1" }, { name = "sniffio", specifier = "==1.3.1" }, { name = "soupsieve", specifier = "==2.7" }, { name = "sqlalchemy", specifier = "==2.0.42" }, @@ -2074,6 +2200,15 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/4a/a7/d526ae86708cea531935ae777b6dbcabe7db52718e6401e0fb9c5edea80e/llvmlite-0.46.0-cp313-cp313-win_amd64.whl", hash = "sha256:67438fd30e12349ebb054d86a5a1a57fd5e87d264d2451bcfafbbbaa25b82a35", size = 38138941, upload-time = "2025-12-08T18:15:22.536Z" }, ] +[[package]] +name = "locket" +version = "1.0.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/2f/83/97b29fe05cb6ae28d2dbd30b81e2e402a3eed5f460c26e9eaa5895ceacf5/locket-1.0.0.tar.gz", hash = "sha256:5c0d4c052a8bbbf750e056a8e65ccd309086f4f0f18a2eac306a8dfa4112a632", size = 4350, upload-time = "2022-04-20T22:04:44.312Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/db/bc/83e112abc66cd466c6b83f99118035867cecd41802f8d044638aa78a106e/locket-1.0.0-py2.py3-none-any.whl", hash = "sha256:b6c819a722f7b6bd955b80781788e4a66a55628b858d347536b7e81325a3a5e3", size = 4398, upload-time = "2022-04-20T22:04:42.23Z" }, +] + [[package]] name = "lxml" version = "6.0.2" @@ -2341,6 +2476,15 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/dd/bf/dd36e4a6d1cff3f2d30f03e2479cd38210e32d4715bb6a9f0e2737f13604/microsoft_kiota_serialization_text-1.9.10-py3-none-any.whl", hash = "sha256:742890cfd4450d12f58d42da7cfa474fe1ee5d6442e016bf70ab76e5c876c0ea", size = 8896, upload-time = "2026-03-12T17:28:02.328Z" }, ] +[[package]] +name = "more-itertools" +version = "11.0.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/a2/f7/139d22fef48ac78127d18e01d80cf1be40236ae489769d17f35c3d425293/more_itertools-11.0.2.tar.gz", hash = "sha256:392a9e1e362cbc106a2457d37cabf9b36e5e12efd4ebff1654630e76597df804", size = 144659, upload-time = "2026-04-09T15:01:33.297Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/cb/98/6af411189d9413534c3eb691182bff1f5c6d44ed2f93f2edfe52a1bbceb8/more_itertools-11.0.2-py3-none-any.whl", hash = "sha256:6e35b35f818b01f691643c6c611bc0902f2e92b46c18fffa77ae1e7c46e912e4", size = 71939, upload-time = "2026-04-09T15:01:32.21Z" }, +] + [[package]] name = "mpmath" version = "1.3.0" @@ -2376,6 +2520,23 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/5e/75/bd9b7bb966668920f06b200e84454c8f3566b102183bc55c5473d96cb2b9/msal_extensions-1.3.1-py3-none-any.whl", hash = "sha256:96d3de4d034504e969ac5e85bae8106c8373b5c6568e4c8fa7af2eca9dbe6bca", size = 20583, upload-time = "2025-03-14T23:51:03.016Z" }, ] +[[package]] +name = "msgpack" +version = "1.1.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/4d/f2/bfb55a6236ed8725a96b0aa3acbd0ec17588e6a2c3b62a93eb513ed8783f/msgpack-1.1.2.tar.gz", hash = "sha256:3b60763c1373dd60f398488069bcdc703cd08a711477b5d480eecc9f9626f47e", size = 173581, upload-time = "2025-10-08T09:15:56.596Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/6b/31/b46518ecc604d7edf3a4f94cb3bf021fc62aa301f0cb849936968164ef23/msgpack-1.1.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:4efd7b5979ccb539c221a4c4e16aac1a533efc97f3b759bb5a5ac9f6d10383bf", size = 81212, upload-time = "2025-10-08T09:15:14.552Z" }, + { url = "https://files.pythonhosted.org/packages/92/dc/c385f38f2c2433333345a82926c6bfa5ecfff3ef787201614317b58dd8be/msgpack-1.1.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:42eefe2c3e2af97ed470eec850facbe1b5ad1d6eacdbadc42ec98e7dcf68b4b7", size = 84315, upload-time = "2025-10-08T09:15:15.543Z" }, + { url = "https://files.pythonhosted.org/packages/d3/68/93180dce57f684a61a88a45ed13047558ded2be46f03acb8dec6d7c513af/msgpack-1.1.2-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1fdf7d83102bf09e7ce3357de96c59b627395352a4024f6e2458501f158bf999", size = 412721, upload-time = "2025-10-08T09:15:16.567Z" }, + { url = "https://files.pythonhosted.org/packages/5d/ba/459f18c16f2b3fc1a1ca871f72f07d70c07bf768ad0a507a698b8052ac58/msgpack-1.1.2-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:fac4be746328f90caa3cd4bc67e6fe36ca2bf61d5c6eb6d895b6527e3f05071e", size = 424657, upload-time = "2025-10-08T09:15:17.825Z" }, + { url = "https://files.pythonhosted.org/packages/38/f8/4398c46863b093252fe67368b44edc6c13b17f4e6b0e4929dbf0bdb13f23/msgpack-1.1.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:fffee09044073e69f2bad787071aeec727183e7580443dfeb8556cbf1978d162", size = 402668, upload-time = "2025-10-08T09:15:19.003Z" }, + { url = "https://files.pythonhosted.org/packages/28/ce/698c1eff75626e4124b4d78e21cca0b4cc90043afb80a507626ea354ab52/msgpack-1.1.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:5928604de9b032bc17f5099496417f113c45bc6bc21b5c6920caf34b3c428794", size = 419040, upload-time = "2025-10-08T09:15:20.183Z" }, + { url = "https://files.pythonhosted.org/packages/67/32/f3cd1667028424fa7001d82e10ee35386eea1408b93d399b09fb0aa7875f/msgpack-1.1.2-cp313-cp313-win32.whl", hash = "sha256:a7787d353595c7c7e145e2331abf8b7ff1e6673a6b974ded96e6d4ec09f00c8c", size = 65037, upload-time = "2025-10-08T09:15:21.416Z" }, + { url = "https://files.pythonhosted.org/packages/74/07/1ed8277f8653c40ebc65985180b007879f6a836c525b3885dcc6448ae6cb/msgpack-1.1.2-cp313-cp313-win_amd64.whl", hash = "sha256:a465f0dceb8e13a487e54c07d04ae3ba131c7c5b95e2612596eafde1dccf64a9", size = 72631, upload-time = "2025-10-08T09:15:22.431Z" }, + { url = "https://files.pythonhosted.org/packages/e5/db/0314e4e2db56ebcf450f277904ffd84a7988b9e5da8d0d61ab2d057df2b6/msgpack-1.1.2-cp313-cp313-win_arm64.whl", hash = "sha256:e69b39f8c0aa5ec24b57737ebee40be647035158f14ed4b40e6f150077e21a84", size = 64118, upload-time = "2025-10-08T09:15:23.402Z" }, +] + [[package]] name = "msgraph-core" version = "1.3.8" @@ -3018,6 +3179,19 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/b6/61/fae042894f4296ec49e3f193aff5d7c18440da9e48102c3315e1bc4519a7/parso-0.8.6-py2.py3-none-any.whl", hash = "sha256:2c549f800b70a5c4952197248825584cb00f033b29c692671d3bf08bf380baff", size = 106894, upload-time = "2026-02-09T15:45:21.391Z" }, ] +[[package]] +name = "partd" +version = "1.4.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "locket" }, + { name = "toolz" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/b2/3a/3f06f34820a31257ddcabdfafc2672c5816be79c7e353b02c1f318daa7d4/partd-1.4.2.tar.gz", hash = "sha256:d022c33afbdc8405c226621b015e8067888173d85f7f5ecebb3cafed9a20f02c", size = 21029, upload-time = "2024-05-06T19:51:41.945Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/71/e7/40fb618334dcdf7c5a316c0e7343c5cd82d3d866edc100d98e29bc945ecd/partd-1.4.2-py3-none-any.whl", hash = "sha256:978e4ac767ec4ba5b86c6eaa52e5a2a3bc748a2ca839e8cc798f1cc6ce6efb0f", size = 18905, upload-time = "2024-05-06T19:51:39.271Z" }, +] + [[package]] name = "pathspec" version = "1.0.4" @@ -3483,6 +3657,17 @@ crypto = [ { name = "cryptography" }, ] +[[package]] +name = "pynisher" +version = "1.0.10" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "psutil" }, + { name = "pywin32", marker = "sys_platform == 'win32'" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/eb/56/1d5ed36041e11c943833a93137ff2562db97da48851d68431f1feaa8f82f/pynisher-1.0.10.tar.gz", hash = "sha256:2722b795d22129ddd5247038bba727ae06ecdb3a5942070817be7c8d4a680e31", size = 30841, upload-time = "2023-11-13T17:58:47.159Z" } + [[package]] name = "pyobjc" version = "12.1" @@ -6461,6 +6646,28 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/b7/ce/149a00dd41f10bc29e5921b496af8b574d8413afcd5e30dfa0ed46c2cc5e/six-1.17.0-py2.py3-none-any.whl", hash = "sha256:4721f391ed90541fddacab5acf947aa0d3dc7d27b2e1e8eda2be8970586c3274", size = 11050, upload-time = "2024-12-04T17:35:26.475Z" }, ] +[[package]] +name = "smac" +version = "2.4.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "configspace" }, + { name = "dask", extra = ["distributed"] }, + { name = "dask-jobqueue" }, + { name = "emcee" }, + { name = "joblib" }, + { name = "numpy" }, + { name = "psutil" }, + { name = "pynisher" }, + { name = "pyyaml" }, + { name = "regex" }, + { name = "scikit-learn" }, + { name = "scipy" }, +] +wheels = [ + { url = "https://files.pythonhosted.org/packages/01/3f/1154b649c899f134006b8fb1e79e1a7cccafde7e2ee6b6064023773c4dab/smac-2.4.0-py3-none-any.whl", hash = "sha256:670fb21b812f2130fc5b07d31a9da51821685c5edcccacc9720a199291273b2c", size = 278108, upload-time = "2026-04-22T19:25:23.114Z" }, +] + [[package]] name = "smart-open" version = "7.5.1" @@ -6491,6 +6698,15 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/37/c3/6eeb6034408dac0fa653d126c9204ade96b819c936e136c5e8a6897eee9c/socksio-1.0.0-py3-none-any.whl", hash = "sha256:95dc1f15f9b34e8d7b16f06d74b8ccf48f609af32ab33c608d08761c5dcbb1f3", size = 12763, upload-time = "2020-04-17T15:50:31.878Z" }, ] +[[package]] +name = "sortedcontainers" +version = "2.4.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/e8/c4/ba2f8066cceb6f23394729afe52f3bf7adec04bf9ed2c820b39e19299111/sortedcontainers-2.4.0.tar.gz", hash = "sha256:25caa5a06cc30b6b83d11423433f65d1f9d76c4c6a0c90e3379eaa43b9bfdb88", size = 30594, upload-time = "2021-05-16T22:03:42.897Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/32/46/9cb0e58b2deb7f82b84065f37f3bffeb12413f947f9388e4cac22c4621ce/sortedcontainers-2.4.0-py2.py3-none-any.whl", hash = "sha256:a163dcaede0f1c021485e957a39245190e74249897e2ae4b2aa38595db237ee0", size = 29575, upload-time = "2021-05-16T22:03:41.177Z" }, +] + [[package]] name = "soupsieve" version = "2.7" @@ -6642,6 +6858,15 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/a2/09/77d55d46fd61b4a135c444fc97158ef34a095e5681d0a6c10b75bf356191/sympy-1.14.0-py3-none-any.whl", hash = "sha256:e091cc3e99d2141a0ba2847328f5479b05d94a6635cb96148ccb3f34671bd8f5", size = 6299353, upload-time = "2025-04-27T18:04:59.103Z" }, ] +[[package]] +name = "tblib" +version = "3.2.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f4/8a/14c15ae154895cc131174f858c707790d416c444fc69f93918adfd8c4c0b/tblib-3.2.2.tar.gz", hash = "sha256:e9a652692d91bf4f743d4a15bc174c0b76afc750fe8c7b6d195cc1c1d6d2ccec", size = 35046, upload-time = "2025-11-12T12:21:16.572Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/02/be/5d2d47b1fb58943194fb59dcf222f7c4e35122ec0ffe8c36e18b5d728f0b/tblib-3.2.2-py3-none-any.whl", hash = "sha256:26bdccf339bcce6a88b2b5432c988b266ebbe63a4e593f6b578b1d2e723d2b76", size = 12893, upload-time = "2025-11-12T12:21:14.407Z" }, +] + [[package]] name = "tenacity" version = "9.1.2" @@ -6757,6 +6982,15 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/41/f2/fd673d979185f5dcbac4be7d09461cbb99751554ffb6718d0013af8604cb/tokenizers-0.21.4-cp39-abi3-win_amd64.whl", hash = "sha256:475d807a5c3eb72c59ad9b5fcdb254f6e17f53dfcbb9903233b0dfa9c943b597", size = 2507568, upload-time = "2025-07-28T15:48:55.456Z" }, ] +[[package]] +name = "toolz" +version = "1.1.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/11/d6/114b492226588d6ff54579d95847662fc69196bdeec318eb45393b24c192/toolz-1.1.0.tar.gz", hash = "sha256:27a5c770d068c110d9ed9323f24f1543e83b2f300a687b7891c1a6d56b697b5b", size = 52613, upload-time = "2025-10-17T04:03:21.661Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/fb/12/5911ae3eeec47800503a238d971e51722ccea5feb8569b735184d5fcdbc0/toolz-1.1.0-py3-none-any.whl", hash = "sha256:15ccc861ac51c53696de0a5d6d4607f99c210739caf987b5d2054f3efed429d8", size = 58093, upload-time = "2025-10-17T04:03:20.435Z" }, +] + [[package]] name = "torch" version = "2.8.0" @@ -7372,6 +7606,15 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/b4/2d/2345fce04cfd4bee161bf1e7d9cdc702e3e16109021035dbb24db654a622/yarl-1.20.1-py3-none-any.whl", hash = "sha256:83b8eb083fe4683c6115795d9fc1cfaf2cbbefb19b3a1cb68f6527460f483a77", size = 46542, upload-time = "2025-06-10T00:46:07.521Z" }, ] +[[package]] +name = "zict" +version = "3.0.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/d1/ac/3c494dd7ec5122cff8252c1a209b282c0867af029f805ae9befd73ae37eb/zict-3.0.0.tar.gz", hash = "sha256:e321e263b6a97aafc0790c3cfb3c04656b7066e6738c37fffcca95d803c9fba5", size = 33238, upload-time = "2023-04-17T21:41:16.041Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/80/ab/11a76c1e2126084fde2639514f24e6111b789b0bfa4fc6264a8975c7e1f1/zict-3.0.0-py2.py3-none-any.whl", hash = "sha256:5796e36bd0e0cc8cf0fbc1ace6a68912611c1dbd74750a3f3026b9b9d6a327ae", size = 43332, upload-time = "2023-04-17T21:41:13.444Z" }, +] + [[package]] name = "zipp" version = "3.23.0" From 1f02723c2cd7845e69a9ebe696482a0b44aa824a Mon Sep 17 00:00:00 2001 From: farshad68 Date: Wed, 6 May 2026 10:41:58 +0200 Subject: [PATCH 08/47] refactor code --- .../optimization/baseline_optimization.py | 92 ++++++------------- 1 file changed, 27 insertions(+), 65 deletions(-) diff --git a/learn2rag/optimization/baseline_optimization.py b/learn2rag/optimization/baseline_optimization.py index ea5b0c4..337a81e 100644 --- a/learn2rag/optimization/baseline_optimization.py +++ b/learn2rag/optimization/baseline_optimization.py @@ -1,5 +1,5 @@ """ -RAG Pipeline Optimization with BERTScore evaluation. +RAG Pipeline Optimization with BERTScore evaluation. """ import argparse @@ -8,6 +8,7 @@ import pathlib import time import copy +import os import numpy as np from bert_score import score as bert_score @@ -19,60 +20,19 @@ import learn2rag.pipeline.search import learn2rag.pipeline.generate +def load_registry(registry_path: pathlib.Path): + if not registry_path.exists(): + logging.warning("no registry found !") + return {"datasets": {}, "prompts": {"default": "Context: {context}\nQ: {question}"}} + return json.loads(registry_path.read_text()) -DATASET_CONFIG = { - "WikiEval": { - "subdirectory": "", - "split": "train", - "question_field": "question", - "answer_field": "answer", - "id_field": "id", - }, - "rag-mini-bioasq": { - "subdirectory": "question-answer-passages", - "split": "test", - "question_field": "question", - "answer_field": "answer", - "id_field": "id", - }, - "hotpot_qa": { # Not being used - "subdirectory": "distractor", - "split": "validation", - "question_field": "question", - "answer_field": "answer", - "id_field": "id", - }, - "repliqa": { # Not being used - "subdirectory": "repliqa_4", - "split": None, - "question_field": "question", - "answer_field": "long_answer", - "id_field": "question_id", - }, -} - -PROMPT_MAP = { - "default": ( - "# Role and Objective\nYou will act as a smart AI chatbot that answers " - "questions only by using the content from the provided information list.\n\n" - "# Instructions\n- Respond in the language of the question.\n" - "- Answer clear and concise.\n- Only use the provided information.\n" - "- NEVER use your general knowledge.\n\n" - "# Information:\n{context}" - ), - "concise": ( - "Answer the question using ONLY the provided information. " - "Be concise and direct. If the information does not contain the answer, say so.\n\n" - "Information:\n{context}" - ), - "detailed": ( - "You are a knowledgeable assistant. Using ONLY the provided information below, " - "answer the question thoroughly. Cite your sources. " - "If the information is insufficient, state that clearly.\n\n" - "Information:\n{context}" - ), -} - +def get_base_user_config(): + """Loads the base config provided by the orchestrator env var.""" + path = os.environ.get("PIPELINE_USER_CONFIG") + if path and pathlib.Path(path).exists(): + return json.loads(pathlib.Path(path).read_text()) + logging.warning("no user config found !") + return {} def run_pipeline(question, user_config, working_config): t0 = time.time() @@ -92,20 +52,21 @@ def run_pipeline(question, user_config, working_config): ]) return answer, context[:3000], search_time, gen_time - -def objective(config, seed, questions, dataset_name, state, answers_dir): +#I removed seed because there are no use for it +# removed dataset_name becuase it just use in yser config and now we inject it +def objective(config, questions, state, answers_dir, prompts_repo, base_user_cfg): state["trial_count"] += 1 tid = state["trial_count"] cfg = dict(config) logging.info(f"Trial {tid}: {cfg}") - wcfg = copy.deepcopy(opt_config) - wcfg["top_k"] = cfg["top_k"] - wcfg["chunk_size"] = cfg["chunk_size"] - wcfg["chunk_overlap"] = cfg["chunk_overlap"] - wcfg["prompt"] = PROMPT_MAP[cfg["prompt_template"]] - ucfg = {"file_path": None, "collection_name": dataset_name, - "imported_documents_file_path": None, "llm": None} + working_cfg = copy.deepcopy(opt_config) + working_cfg.update({ + "top_k": cfg["top_k"], + "chunk_size": cfg["chunk_size"], + "chunk_overlap": cfg["chunk_overlap"], + "prompt": prompts_repo.get(cfg["prompt_template"], prompts_repo["default"]) + }) predictions, goldens = [], [] qa_pairs = [] @@ -116,7 +77,7 @@ def objective(config, seed, questions, dataset_name, state, answers_dir): if not q["question"]: continue try: - answer, context, st, gt = run_pipeline(q["question"], ucfg, wcfg) + answer, context, st, gt = run_pipeline(q["question"], base_user_cfg, working_cfg) t_search += st t_gen += gt predictions.append(answer) @@ -130,6 +91,7 @@ def objective(config, seed, questions, dataset_name, state, answers_dir): }) except Exception as e: logging.warning(f"Trial {tid}, q{idx} failed: {e}") + # do we need to add this :/ predictions.append("") goldens.append(q["ground_truth"]) qa_pairs.append({ @@ -207,7 +169,7 @@ def param_importance(smac, output_path): return result -def run(dataset_name, max_questions, n_trials, output_dir): +def run(dataset_name: str, max_questions: int, n_trials, output_dir: int): if dataset_name not in DATASET_CONFIG: raise ValueError( f"Unknown dataset: {dataset_name}. " From c40629c6068c2cb9d8a3708ac1a9c93126bdf594 Mon Sep 17 00:00:00 2001 From: farshad68 Date: Thu, 7 May 2026 15:09:35 +0200 Subject: [PATCH 09/47] =?UTF-8?q?The=20original=20script=20worked,=20but?= =?UTF-8?q?=20it=20was=20hard=E2=80=91coded=20(datasets,=20prompts,=20user?= =?UTF-8?q?=E2=80=91config=20keys,=20result=20JSON=20schema)=20and=20there?= =?UTF-8?q?fore=20difficult=20to=20extend=20or=20reuse=20in=20different=20?= =?UTF-8?q?environments.=20The=20new=20version=20aimed=20to:?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Load configuration dynamically from a registry.json file. --- learn2rag/optimization/__init__.py | 3 +- .../optimization/baseline_optimization.py | 201 +++++++++--------- 2 files changed, 105 insertions(+), 99 deletions(-) diff --git a/learn2rag/optimization/__init__.py b/learn2rag/optimization/__init__.py index 84a6ef1..86410e8 100644 --- a/learn2rag/optimization/__init__.py +++ b/learn2rag/optimization/__init__.py @@ -14,6 +14,7 @@ def main() -> None: parser = argparse.ArgumentParser(description="Run RAG baseline optimization.") parser.add_argument("task", help="Module task name (e.g., learn2rag.optimization)") parser.add_argument("--logging-config", type=str, help="Path to logging config yml") + parser.add_argument("--registry-path", type=str, help="Path to registry.json") parser.add_argument("--dataset", type=str, default="WikiEval") parser.add_argument("--questions", type=int, default=10) parser.add_argument("--trials", type=int, default=10) @@ -34,7 +35,7 @@ def main() -> None: output_dir = pathlib.Path("./optimization/output/") output_dir.mkdir(parents=True, exist_ok=True) - baseline_optimization.run(args.dataset,args.questions,args.trials,output_dir) + baseline_optimization.run(args.dataset,args.questions,args.trials,output_dir,args.registry_path) logging.info("optimization is done") results_path = output_dir /args.dataset/ "optimization_results.json" logging.info(f"save optimized results here : {results_path}") diff --git a/learn2rag/optimization/baseline_optimization.py b/learn2rag/optimization/baseline_optimization.py index 337a81e..be02a12 100644 --- a/learn2rag/optimization/baseline_optimization.py +++ b/learn2rag/optimization/baseline_optimization.py @@ -9,10 +9,11 @@ import time import copy import os +from typing import Dict, Any, List, Union, Tuple import numpy as np from bert_score import score as bert_score -from ConfigSpace import ConfigurationSpace, Integer, Categorical, ForbiddenGreaterThanRelation +from ConfigSpace import ConfigurationSpace, Integer, Categorical, ForbiddenGreaterThanRelation, Configuration from smac import HyperparameterOptimizationFacade, Scenario from learn2rag.evaluation.tools import read_dataset_qa @@ -20,21 +21,14 @@ import learn2rag.pipeline.search import learn2rag.pipeline.generate -def load_registry(registry_path: pathlib.Path): - if not registry_path.exists(): - logging.warning("no registry found !") - return {"datasets": {}, "prompts": {"default": "Context: {context}\nQ: {question}"}} - return json.loads(registry_path.read_text()) - -def get_base_user_config(): - """Loads the base config provided by the orchestrator env var.""" - path = os.environ.get("PIPELINE_USER_CONFIG") - if path and pathlib.Path(path).exists(): - return json.loads(pathlib.Path(path).read_text()) - logging.warning("no user config found !") - return {} - -def run_pipeline(question, user_config, working_config): +def load_registry(path: str = "registry.json") -> dict: + p = pathlib.Path(path) + if not p.is_file(): + logging.error("registry file not found") + with p.open() as f: + return json.load(f) + +def run_pipeline(question: str, user_config: Dict[str, Any], working_config: Dict[str, Any]) -> Tuple[str, str, float, float]: t0 = time.time() docs = learn2rag.pipeline.search.search(question, user_config, working_config) search_time = time.time() - t0 @@ -54,7 +48,13 @@ def run_pipeline(question, user_config, working_config): #I removed seed because there are no use for it # removed dataset_name becuase it just use in yser config and now we inject it -def objective(config, questions, state, answers_dir, prompts_repo, base_user_cfg): +def objective(config: Configuration, + questions: List[Dict[str, Any]], + dataset_name: str, + state: Dict[str, Any], + answers_dir: pathlib.Path + ,prompt_map +) -> float: state["trial_count"] += 1 tid = state["trial_count"] cfg = dict(config) @@ -65,42 +65,41 @@ def objective(config, questions, state, answers_dir, prompts_repo, base_user_cfg "top_k": cfg["top_k"], "chunk_size": cfg["chunk_size"], "chunk_overlap": cfg["chunk_overlap"], - "prompt": prompts_repo.get(cfg["prompt_template"], prompts_repo["default"]) + "prompt": prompt_map[cfg["prompt_template"]], }) + ucfg = { + "file_path": None, + "collection_name": dataset_name, + "imported_documents_file_path": None, + "llm": None, + } + env_user_cfg = os.environ.get("PIPELINE_USER_CONFIG") + if env_user_cfg and pathlib.Path(env_user_cfg).exists(): + ucfg.update(json.loads(pathlib.Path(env_user_cfg).read_text())) + predictions, goldens = [], [] qa_pairs = [] t_start = time.time() t_search, t_gen = 0.0, 0.0 - for idx, q in enumerate(questions): - if not q["question"]: + for q in questions: + # Preserve the original “skip empty question” guard + if not q.get("question"): continue try: - answer, context, st, gt = run_pipeline(q["question"], base_user_cfg, working_cfg) - t_search += st - t_gen += gt + answer, context, t_s, t_g = run_pipeline(q["question"], ucfg, working_cfg) + t_search += t_s + t_gen += t_g predictions.append(answer) goldens.append(q["ground_truth"]) - qa_pairs.append({ - "id": q["id"], - "question": q["question"], - "golden_answer": q["ground_truth"], - "generated_answer": answer, - "retrieved_context": context, - }) + qa_pairs.append({**q, "generated_answer": answer, "retrieved_context": context}) except Exception as e: - logging.warning(f"Trial {tid}, q{idx} failed: {e}") - # do we need to add this :/ + # Same behaviour as the old version: record a blank answer. TODO : check if we need this + logging.warning(f"Trial {tid}, q{q.get('id','?')} failed: {e}") predictions.append("") goldens.append(q["ground_truth"]) - qa_pairs.append({ - "id": q["id"], - "question": q["question"], - "golden_answer": q["ground_truth"], - "generated_answer": "", - "retrieved_context": "", - }) + qa_pairs.append({**q, "generated_answer": "", "retrieved_context": ""}) if not predictions: return 1.0 @@ -143,7 +142,7 @@ def objective(config, questions, state, answers_dir, prompts_repo, base_user_cfg return float(cost) -def param_importance(smac, output_path): +def param_importance(smac: HyperparameterOptimizationFacade, output_path: pathlib.Path) -> Dict[str, Any]: params = list(smac.scenario.configspace.keys()) configs, costs = [], [] for key, val in smac.runhistory.items(): @@ -169,17 +168,17 @@ def param_importance(smac, output_path): return result -def run(dataset_name: str, max_questions: int, n_trials, output_dir: int): - if dataset_name not in DATASET_CONFIG: - raise ValueError( - f"Unknown dataset: {dataset_name}. " - f"Available: {list(DATASET_CONFIG.keys())}" - ) +def run(dataset_name: str, max_questions: int, n_trials: int, output_dir: Union[str, pathlib.Path],registry_path:str) -> Tuple[ + Dict[str, Any], List[Any], Dict[str, Any]]: + registry = load_registry(registry_path) + datasets = registry["datasets"] + if dataset_name not in datasets: + raise ValueError(f"Unknown dataset: {dataset_name}. Available: {list(datasets.keys())}") + dcfg = datasets[dataset_name] + fields = dcfg["fields"] - dcfg = DATASET_CONFIG[dataset_name] out = pathlib.Path(output_dir) / dataset_name out.mkdir(parents=True, exist_ok=True) - answers_dir = out / "trial_answers" answers_dir.mkdir(parents=True, exist_ok=True) @@ -187,73 +186,79 @@ def run(dataset_name: str, max_questions: int, n_trials, output_dir: int): if max_questions: qa = qa.select(range(min(max_questions, len(qa)))) - questions = [] - for i, r in enumerate(qa): - questions.append({ - "question": r.get(dcfg["question_field"], ""), - "ground_truth": r.get(dcfg["answer_field"], ""), - "id": r.get(dcfg["id_field"], str(i)), - }) - logging.info(f"Loaded {len(questions)} questions from {dataset_name}") + questions = [ + { + "question": r[fields["q"]], + "ground_truth": r[fields["a"]], + "id": r.get(fields["id"], str(i)), + } + for i, r in enumerate(qa) + ] + prompt_map = registry["prompts"] cs = ConfigurationSpace(seed=42) - cs.add([Integer("top_k", (1, 20), default=4), - Integer("chunk_size", (200, 4000), default=2000), - Integer("chunk_overlap", (0, 500), default=200), - Categorical("prompt_template", ["default", "concise", "detailed"], default="default")]) + cs.add([ + Integer("top_k", (1, 20), default=4), + Integer("chunk_size", (200, 4000), default=2000), + Integer("chunk_overlap", (0, 500), default=200), + Categorical("prompt_template", list(prompt_map.keys()), default="default"), + ]) cs.add(ForbiddenGreaterThanRelation(cs["chunk_overlap"], cs["chunk_size"])) + scenario = Scenario( + cs, + deterministic=True, + n_trials=n_trials, + walltime_limit=7200, + seed=42, + output_directory=out / "smac_output", + ) + state: Dict[str, Any] = {"trial_count": 0, "best_cost": 1.0, "convergence": [], "history": []} - scenario = Scenario(configspace=cs, deterministic=True, n_trials=n_trials, - walltime_limit=7200, seed=42, output_directory=out / "smac_output") - - state = {"trial_count": 0, "best_cost": 1.0, "convergence": [], "history": []} smac = HyperparameterOptimizationFacade( scenario=scenario, - target_function=lambda config, seed=0: objective( - config, seed, questions, dataset_name, state, answers_dir - ), + target_function=lambda config, seed=0: objective(config, questions, dataset_name, state, answers_dir,prompt_map) ) - t0 = time.time() incumbent = smac.optimize() - total_time = time.time() - t0 - importance = param_importance(smac, out) - - with open(out / "optimization_results.json", "w") as f: - json.dump({ - "best_config": dict(incumbent), - "run_history": state["history"], - "convergence": state["convergence"], - "parameter_importance": importance, - "total_time_s": round(total_time, 2), - "dataset": dataset_name, - "metric": "bertscore_golden", - "answers_dir": str(answers_dir), - }, f, indent=2, default=str) - - logging.info(f"Done in {total_time:.0f}s") - logging.info(f"Trial answers saved to {answers_dir}") - return incumbent, state["history"], importance - + total_time = time.time() - t0 + best_cfg = incumbent.get_dictionary() + results_path = out / "optimization_results.json" + results_path.write_text(json.dumps({ + "best_config": best_cfg, + "run_history": state["history"], + "convergence": state["convergence"], + "parameter_importance": importance, + "total_time_s": round(total_time, 2), + "dataset": dataset_name, + "metric": "bertscore_golden", + "answers_dir":str(answers_dir), + }, indent=2, default = str)) + + return best_cfg, state["history"], importance if __name__ == "__main__": parser = argparse.ArgumentParser() - parser.add_argument("--dataset", type=str, default="WikiEval", - choices=list(DATASET_CONFIG.keys())) + parser.add_argument("task", nargs='?', default="learn2rag.optimization") + parser.add_argument("--dataset", type=str, default="WikiEval") parser.add_argument("--max_questions", type=int, default=50) parser.add_argument("--n_trials", type=int, default=10) + parser.add_argument("--logging-config", type=str) + parser.add_argument("--registry", type=str, default="registry.json") parser.add_argument("--output_dir", type=str, default="optimization_results_baseline") - args = parser.parse_args() + args, _ = parser.parse_known_args() - logging.basicConfig( - level=logging.INFO, - format="%(asctime)s %(levelname)s %(message)s", - force=True, - ) - incumbent, history, importance = run( - args.dataset, args.max_questions, args.n_trials, args.output_dir, - ) + final_output_dir = pathlib.Path(args.output_dir) + + env_out = os.environ.get("PIPELINE_OPT_CONFIG") + if not final_output_dir.exists() and env_out: + final_output_dir = pathlib.Path(env_out).parent + + incumbent, history, importance = run(args.dataset, args.max_questions, args.n_trials, final_output_dir, args.registry) + + # incumbent, history, importance = run( + # args.dataset, args.max_questions, args.n_trials, args.output_dir, + # ) best = min(history, key=lambda x: x["cost"]) print(f"\nBest config: {dict(incumbent)}") From c9568cf00f3694f35d354b87ada00785fcaf3ae9 Mon Sep 17 00:00:00 2001 From: Carolin Walter Date: Tue, 26 May 2026 14:17:20 +0000 Subject: [PATCH 10/47] improve ingestion performance --- learn2rag/pipeline/embeddings.py | 51 +++++++--- learn2rag/pipeline/ingestion.py | 157 ++++++++++++++++------------- learn2rag/pipeline/opt_config.json | 1 + 3 files changed, 123 insertions(+), 86 deletions(-) diff --git a/learn2rag/pipeline/embeddings.py b/learn2rag/pipeline/embeddings.py index 75423ae..f45e87f 100644 --- a/learn2rag/pipeline/embeddings.py +++ b/learn2rag/pipeline/embeddings.py @@ -1,12 +1,29 @@ +from functools import lru_cache from FlagEmbedding import BGEM3FlagModel # type: ignore[import-untyped] from sentence_transformers import SentenceTransformer -from typing import List, Union, Any, cast, Literal +from typing import List, Any, Literal import numpy as np import warnings -def create_embeddings(input_sample: List[str], model_name: str = "BAAI/bge-m3", embedding_mode: str = "dense") -> dict[Literal['dense_vecs', 'lexical_weights', 'colbert_vecs'], np.ndarray[Any, Any] | list[dict[str, float]] | list[np.ndarray[Any, Any]]]: + +@lru_cache(maxsize=4) +def _get_bge_m3_model() -> BGEM3FlagModel: + return BGEM3FlagModel("BAAI/bge-m3", use_fp16=True) + + +@lru_cache(maxsize=4) +def _get_sentence_transformer_model(model_name: str) -> SentenceTransformer: + return SentenceTransformer(model_name) + + +def create_embeddings( + input_sample: List[str], + model_name: str = "BAAI/bge-m3", + embedding_mode: str = "dense", +) -> dict[Literal['dense_vecs', 'lexical_weights', 'colbert_vecs'], np.ndarray[Any, Any] | list[dict[str, float]] | list[np.ndarray[Any, Any]]] | np.ndarray[Any, Any]: if model_name == "BAAI/bge-m3": - model = BGEM3FlagModel("BAAI/bge-m3", use_fp16=True) + model = _get_bge_m3_model() + if embedding_mode == "dense": return model.encode( # type: ignore[no-any-return] input_sample, @@ -16,7 +33,7 @@ def create_embeddings(input_sample: List[str], model_name: str = "BAAI/bge-m3", return_colbert_vecs=False, ) elif embedding_mode == "sparse": - return model.encode( # type: ignore[no-any-return] + return model.encode( # type: ignore[no-any-return] input_sample, batch_size=512, return_dense=False, @@ -31,25 +48,25 @@ def create_embeddings(input_sample: List[str], model_name: str = "BAAI/bge-m3", return_sparse=True, return_colbert_vecs=False, ) - elif embedding_mode == "dense_sparse_colbert": + elif embedding_mode == "colbert": return model.encode( # type: ignore[no-any-return] input_sample, - batch_size=512, - return_dense=True, - return_sparse=True, + batch_size=32, + return_dense=False, + return_sparse=False, return_colbert_vecs=True, ) - elif embedding_mode == "colbert": + elif embedding_mode == "dense_sparse_colbert": return model.encode( # type: ignore[no-any-return] input_sample, - batch_size=512, - return_dense=False, - return_sparse=False, + batch_size=8, + return_dense=True, + return_sparse=True, return_colbert_vecs=True, ) else: warnings.warn( - f"Embedding mode unknown or not provided. Using dense embeddings" + "Embedding mode unknown or not provided. Using dense embeddings" ) return model.encode( # type: ignore[no-any-return] input_sample, @@ -58,12 +75,14 @@ def create_embeddings(input_sample: List[str], model_name: str = "BAAI/bge-m3", return_sparse=False, return_colbert_vecs=False, ) + elif model_name == "sentence-transformers/all-mpnet-base-v2": - model = SentenceTransformer("sentence-transformers/all-mpnet-base-v2") + model = _get_sentence_transformer_model("sentence-transformers/all-mpnet-base-v2") return model.encode(input_sample) # type: ignore[return-value] + else: - warnings.warn(f"Embedding model unknown or not provided. Using dense embeddings of default model: BAAI/bge-m3") - model = BGEM3FlagModel("BAAI/bge-m3", use_fp16=True) + warnings.warn("Embedding model unknown or not provided. Using dense embeddings of default model: BAAI/bge-m3") + model = _get_bge_m3_model() return model.encode( # type: ignore[no-any-return] input_sample, batch_size=512, diff --git a/learn2rag/pipeline/ingestion.py b/learn2rag/pipeline/ingestion.py index d4f5cfa..9690a28 100644 --- a/learn2rag/pipeline/ingestion.py +++ b/learn2rag/pipeline/ingestion.py @@ -8,7 +8,7 @@ from collections.abc import Iterator from langchain.text_splitter import RecursiveCharacterTextSplitter -from langchain_core.documents.base import Document +from langchain_core.documents import Document from .qdrant import Qdrant from qdrant_client.models import PointStruct, Filter, FieldCondition, MatchValue, SparseVector, VectorParams, MultiVectorConfig, MultiVectorComparator, Distance @@ -128,85 +128,102 @@ def ingest_batch(docs: list[Document], qdrant: Qdrant, user_config: dict[str, An ``embedding_model``, and ``search_mode``). """ collection_name = user_config["collection_name"] - all_documents = docs logging.info('Splitting documents into chunks') text_splitter = RecursiveCharacterTextSplitter( chunk_size=opt_config["chunk_size"], chunk_overlap=opt_config["chunk_overlap"] ) - chunks = text_splitter.split_documents(all_documents) - - chunks_content = [chunk.page_content for chunk in chunks] - if len(opt_config["multi_search"]) > 0 and opt_config["query_mode"] == "multi": - chunks_metadata: dict[str, list[str]] = {} - embeddings_metadata: dict[str, Any] = {} - for item in opt_config["multi_search"]: - chunks_metadata[item] = list(get_chunks_metadata(chunks, item)) - embeddings_metadata[item] = create_embeddings(chunks_metadata[item], opt_config["embedding_model"], opt_config["search_mode"]) - dense_vecs = embeddings_metadata[item]["dense_vecs"] - if isinstance(dense_vecs, np.ndarray): - assert dense_vecs.ndim == 2, dense_vecs.shape + chunks = text_splitter.split_documents(docs) + + ingestion_batch_size = opt_config["ingestion_batch_size"] + logging.info('Creating embeddings and ingesting in batches...') + for batch_start in range(0, len(chunks), ingestion_batch_size): + batch_chunks = chunks[batch_start:batch_start + ingestion_batch_size] + batch_content = [chunk.page_content for chunk in batch_chunks] + batch_chunk_hash = [hashlib.md5(chunk.page_content.encode()).hexdigest() for chunk in batch_chunks] + + embeddings = create_embeddings( + batch_content, + opt_config["embedding_model"], + opt_config["search_mode"], + ) + + if len(opt_config["multi_search"]) > 0 and opt_config["query_mode"] == "multi": + if not isinstance(embeddings, dict) or "dense_vecs" not in embeddings: + raise TypeError("Expected dense_vecs in embeddings for multi query mode") + + embeddings_metadata: dict[str, Any] = {} + for item in opt_config["multi_search"]: + item_values = list(get_chunks_metadata(batch_chunks, item)) + embeddings_metadata[item] = create_embeddings( + item_values, + opt_config["embedding_model"], + opt_config["search_mode"], + ) + dense_vecs = embeddings_metadata[item]["dense_vecs"] + if isinstance(dense_vecs, np.ndarray): + assert dense_vecs.ndim == 2, dense_vecs.shape + else: + raise TypeError(f"dense_vecs must be np.ndarray, got {type(dense_vecs)}") + + mmembeddings: list[np.ndarray[Any, Any]] = [] + for i in range(len(embeddings['dense_vecs'])): + vecs_to_concat: list[np.ndarray[Any, Any]] = [cast(np.ndarray[Any, Any], embeddings['dense_vecs'][i])] + for item in embeddings_metadata.keys(): + vecs_to_concat.append(cast(np.ndarray[Any, Any], embeddings_metadata[item]['dense_vecs'][i])) + mmembeddings.append(np.concatenate(vecs_to_concat, axis=0)) + embeddings['dense_vecs'] = mmembeddings + + if isinstance(embeddings, dict) and "dense_vecs" in embeddings: + if opt_config["search_mode"] == "dense": + chunks_with_embeddings = [ + dict(chunk) | {"dense_vec": dense, "chunk_hash": c_hash} + for chunk, dense, c_hash in zip(batch_chunks, embeddings["dense_vecs"], batch_chunk_hash) + ] + elif opt_config["search_mode"] == "dense_sparse": + chunks_with_embeddings = [ + dict(chunk) + | {"dense_vec": dense, "lexical_weights": sparse, "chunk_hash": c_hash} + for chunk, dense, sparse, c_hash in zip( + batch_chunks, + list(embeddings["dense_vecs"]), + list(embeddings["lexical_weights"]), + batch_chunk_hash + ) + ] + elif opt_config["search_mode"] == "dense_sparse_colbert": + chunks_with_embeddings = [ + dict(chunk) + | {"dense_vec": dense, "lexical_weights": sparse, "colbert_vecs": colbert, "chunk_hash": c_hash} + for chunk, dense, sparse, colbert, c_hash in zip( + batch_chunks, + list(embeddings["dense_vecs"]), + list(embeddings["lexical_weights"]), + list(embeddings["colbert_vecs"]), + batch_chunk_hash + ) + ] else: - raise TypeError(f"dense_vecs must be np.ndarray, got {type(dense_vecs)}") - - chunk_hash = [hashlib.md5(chunk.page_content.encode()).hexdigest() for chunk in chunks] - - logging.info('Creating embeddings...') - embeddings = create_embeddings(chunks_content, opt_config["embedding_model"], opt_config["search_mode"]) - if len(opt_config["multi_search"]) > 0 and opt_config["query_mode"] == "multi": - mmembeddings: list[np.ndarray[Any, Any]] = [] - for i in range(len(embeddings['dense_vecs'])): - vecs_to_concat: list[np.ndarray[Any, Any]] = [cast(np.ndarray[Any, Any], embeddings['dense_vecs'][i])] - for item in embeddings_metadata.keys(): - vecs_to_concat.append(cast(np.ndarray[Any, Any], embeddings_metadata[item]['dense_vecs'][i])) - mmembeddings.append(np.concatenate(vecs_to_concat, axis=0)) - embeddings['dense_vecs'] = mmembeddings - - if isinstance(embeddings, dict) and "dense_vecs" in embeddings: - if opt_config["search_mode"] == "dense": + chunks_with_embeddings = [ + dict(chunk) | {"dense_vec": dense, "chunk_hash": c_hash} + for chunk, dense, c_hash in zip(batch_chunks, embeddings["dense_vecs"], batch_chunk_hash) + ] + else: chunks_with_embeddings = [ dict(chunk) | {"dense_vec": dense, "chunk_hash": c_hash} - for chunk, dense, c_hash in zip(chunks, embeddings["dense_vecs"], chunk_hash) - ] - if opt_config["search_mode"] == "dense_sparse": - chunks_with_embeddings = [ - dict(chunk) - | {"dense_vec": dense, "lexical_weights": sparse, "chunk_hash": c_hash} - for chunk, dense, sparse, c_hash in zip( - chunks, - list(embeddings["dense_vecs"]), - list(embeddings["lexical_weights"]), - chunk_hash - ) + for chunk, dense, c_hash in zip(batch_chunks, embeddings, batch_chunk_hash) ] - if opt_config["search_mode"] == "dense_sparse_colbert": - chunks_with_embeddings = [ - dict(chunk) - | {"dense_vec": dense, "lexical_weights": sparse, "colbert_vecs": colbert, "chunk_hash": c_hash} - for chunk, dense, sparse, colbert, c_hash in zip( - chunks, - list(embeddings["dense_vecs"]), - list(embeddings["lexical_weights"]), - list(embeddings['colbert_vecs']), - chunk_hash - ) - ] - else: - chunks_with_embeddings = [ - dict(chunk) | {"dense_vec": dense, "chunk_hash": c_hash} - for chunk, dense, c_hash in zip(chunks, embeddings, chunk_hash) - ] - for sample in chunks_with_embeddings: - if not point_exists(qdrant, collection_name, sample['metadata']['loader_id'], sample['metadata']['source'], sample['metadata']['content_hash'], sample['chunk_hash']): - if opt_config["search_mode"] == "dense_sparse": - insert_dense_sparse(qdrant, collection_name, sample) - elif opt_config["search_mode"] == "dense_sparse_colbert": - insert_dense_sparse_colbert(qdrant, collection_name, sample) - elif opt_config["query_mode"] == "multi": - insert_multi(qdrant, collection_name, sample) - else: - insert(qdrant, collection_name, sample) + for sample in chunks_with_embeddings: + if not point_exists(qdrant, collection_name, sample['metadata']['loader_id'], sample['metadata']['source'], sample['metadata']['content_hash'], sample['chunk_hash']): + if opt_config["search_mode"] == "dense_sparse": + insert_dense_sparse(qdrant, collection_name, sample) + elif opt_config["search_mode"] == "dense_sparse_colbert": + insert_dense_sparse_colbert(qdrant, collection_name, sample) + elif opt_config["query_mode"] == "multi": + insert_multi(qdrant, collection_name, sample) + else: + insert(qdrant, collection_name, sample) def index(documents: list[Document], user_config: dict[str, Any], opt_config: dict[str, Any]) -> None: diff --git a/learn2rag/pipeline/opt_config.json b/learn2rag/pipeline/opt_config.json index f376bdb..2f5738b 100644 --- a/learn2rag/pipeline/opt_config.json +++ b/learn2rag/pipeline/opt_config.json @@ -1,6 +1,7 @@ { "chunk_size": 2000, "chunk_overlap": 200, + "ingestion_batch_size": 32, "embedding_model": "BAAI/bge-m3", "vector_size": { "sentence-transformers/all-mpnet-base-v2": 768, From 14e9f7bc226fadebc74a89b8082745c0a51af1b9 Mon Sep 17 00:00:00 2001 From: Carolin Walter Date: Tue, 26 May 2026 15:08:08 +0000 Subject: [PATCH 11/47] fix mypy error --- learn2rag/pipeline/embeddings.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/learn2rag/pipeline/embeddings.py b/learn2rag/pipeline/embeddings.py index f45e87f..acf9818 100644 --- a/learn2rag/pipeline/embeddings.py +++ b/learn2rag/pipeline/embeddings.py @@ -78,7 +78,7 @@ def create_embeddings( elif model_name == "sentence-transformers/all-mpnet-base-v2": model = _get_sentence_transformer_model("sentence-transformers/all-mpnet-base-v2") - return model.encode(input_sample) # type: ignore[return-value] + return model.encode(input_sample) else: warnings.warn("Embedding model unknown or not provided. Using dense embeddings of default model: BAAI/bge-m3") From eb21b9f1545abe4d25f5a49b405f9bc8613f3fee Mon Sep 17 00:00:00 2001 From: Hanna Reder Date: Wed, 27 May 2026 07:16:38 +0000 Subject: [PATCH 12/47] WIP: retrieval optimisation --- learn2rag/evaluation/tools.py | 23 +- .../optimization/retrieval_optimization.py | 325 ++++++++++++++++++ 2 files changed, 345 insertions(+), 3 deletions(-) create mode 100644 learn2rag/optimization/retrieval_optimization.py diff --git a/learn2rag/evaluation/tools.py b/learn2rag/evaluation/tools.py index b927bc1..ea1e351 100644 --- a/learn2rag/evaluation/tools.py +++ b/learn2rag/evaluation/tools.py @@ -7,6 +7,7 @@ import datasets import json_stream # type: ignore[import-untyped] from typing import Any, Callable +import pandas as pd import learn2rag.pipeline.ingestion from learn2rag.pipeline.config import opt_config @@ -81,9 +82,25 @@ def ingest_dataset_documents(dataset_name: str) -> None: def read_dataset_qa(dataset_name: str, subdirectory: str, split: str | None=None) -> Any: logging.debug(f'{dataset_name=}') - dataset_work_dir = pathlib.Path('./datasets') / dataset_name - dataset_dict = datasets.load_from_disk(dataset_work_dir / 'source' / subdirectory) - return dataset_dict[split] if split is not None else dataset_dict + + if subdirectory.endswith('.csv'): + df = pd.read_csv(subdirectory, sep=';') + # wrap in object that behaves like HuggingFace dataset + class CSVDataset: + def __init__(self, df): + self.data = df + def __len__(self): + return len(self.data) + def __getitem__(self, idx): + return self.data.iloc[idx].to_dict() + def select(self, indices): + return CSVDataset(self.data.iloc[list(indices)]) + return CSVDataset(df) + + else: + dataset_work_dir = pathlib.Path('./datasets') / dataset_name + dataset_dict = datasets.load_from_disk(dataset_work_dir / 'source' / subdirectory) + return dataset_dict[split] if split is not None else dataset_dict def basic_pipeline(dataset_name: str, question: str) -> dict[str, Any]: diff --git a/learn2rag/optimization/retrieval_optimization.py b/learn2rag/optimization/retrieval_optimization.py new file mode 100644 index 0000000..71502ea --- /dev/null +++ b/learn2rag/optimization/retrieval_optimization.py @@ -0,0 +1,325 @@ +""" +RAG Retrieval Optimization. +""" + +import argparse +import json +import logging +import pathlib +import time +import copy +import os +import asyncio +from typing import Dict, Any, List, Union, Tuple + +import numpy as np +from bert_score import score as bert_score +from ConfigSpace import ConfigurationSpace, Integer, Categorical, ForbiddenGreaterThanRelation, Configuration, \ + ForbiddenAndConjunction, ForbiddenEqualsClause +from smac import HyperparameterOptimizationFacade, Scenario + +from learn2rag.evaluation.tools import read_dataset_qa +from learn2rag.pipeline.config import opt_config +import learn2rag.pipeline.search +import learn2rag.pipeline.generate + + + + +def load_registry(path: str = "registry.json") -> dict: + p = pathlib.Path(path) + if not p.is_file(): + logging.error("registry file not found") + with p.open() as f: + return json.load(f) + +def run_search(question: str, user_config: Dict[str, Any], working_config: Dict[str, Any]) -> Tuple[List[Any], float]: + t0 = time.time() + # docs = learn2rag.pipeline.search.search(question, user_config, working_config) + # TODO user config/opt config + docs = asyncio.run(learn2rag.pipeline.search.search_authorized(question, user="anonymous", request_id=None, user_config=user_config, opt_config=working_config)) + search_time = time.time() - t0 + source_list = [point.payload['source'] for point in docs] + return source_list, search_time + + +def recall(search_results, labels): + count = 0 + top_k = opt_config["top_k"] + for q in range(len(search_results)): + label = str(labels[q]) + hits = [str(h) for h in search_results[q]] + print('label ',label, ' hits: ', hits) + if label in hits[:top_k]: + count += 1 + return count / len(labels) if labels else 0.0 + + +#I removed seed because there are no use for it +# removed dataset_name because it just use in user config and now we inject it +def objective(config: Configuration, + questions: List[Dict[str, Any]], + dataset_name: str, + state: Dict[str, Any], + answers_dir: pathlib.Path + ,prompt_map +) -> float: + state["trial_count"] += 1 + tid = state["trial_count"] + cfg = dict(config) + logging.info(f"Trial {tid}: {cfg}") + + if cfg["rewrite"] == "False" and cfg["rewrite_mode"] in {"keywords", "subqueries", "subqueries_keywords"}: + logging.warning(f"Skip invalid cfg: {cfg}") + return 1.0 + + if cfg["reranking"] == "False" and cfg["reranking_mode"] in {"reranking_with_flagreranker", "reranking_with_sentence_transformers", "reranking_with_colbert"}: + logging.warning(f"Skip invalid cfg: {cfg}") + return 1.0 + + if cfg["search_mode"] in {"dense", "sparse"} and cfg["fusion_mode"] in {"DBSF", "RRF"}: + logging.warning(f"Skip invalid cfg: {cfg}") + return 1.0 + + +# TODO + working_cfg = copy.deepcopy(opt_config) + working_cfg.update({ + "chunk_size": cfg["chunk_size"], + "chunk_overlap": cfg["chunk_overlap"], + "search_mode": cfg["search_mode"], + "reranking_mode": cfg["reranking_mode"], + "rewrite_mode": cfg["rewrite_mode"], + "fusion_mode": cfg["fusion_mode"], + "reranking": cfg["reranking"], + "rewrite": cfg["rewrite"] + }) + +# TODO + ucfg = { + "file_path": None, + "collection_name": dataset_name, # TODO get collection name depending on hyperparameters + "imported_documents_file_path": None, + "llm": None, + } + env_user_cfg = os.environ.get("PIPELINE_USER_CONFIG") + if env_user_cfg and pathlib.Path(env_user_cfg).exists(): + ucfg.update(json.loads(pathlib.Path(env_user_cfg).read_text())) + + predictions, goldens = [], [] + qa_pairs = [] + t_start = time.time() + t_search = 0.0 + + for q in questions: + # Preserve the original “skip empty question” guard + if not q.get("question"): + continue + try: + source_list, t_s = run_search(q["question"], ucfg, working_cfg) + print("SOURCE_LIST: ", source_list) + t_search += t_s + predictions.append(source_list) + goldens.append(q["ground_truth"]) + qa_pairs.append({**q, "retrieved_sources": source_list}) + except Exception as e: + # Same behaviour as the old version: record a blank answer. TODO : check if we need this + logging.warning(f"Trial {tid}, q{q.get('id','?')} failed: {e}") + predictions.append([]) + goldens.append(q["ground_truth"]) + qa_pairs.append({**q, "generated_answer": "", "retrieved_context": ""}) + + if not predictions: + return 1.0 + + t_score = time.time() + recall_score = recall(predictions, goldens) + scoring_time = time.time() - t_score + + # objective function + cost = 1.0 - recall_score + total_time = time.time() - t_start + + trial_answers = { + "trial_id": tid, + "config": cfg, + "cost": float(cost), + "avg_recall": float(recall_score), + "qa_pairs": qa_pairs, + } + answers_file = answers_dir / f"trial_{tid}_answers.json" + with open(answers_file, "w") as f: + json.dump(trial_answers, f, indent=2, default=str) + + state["best_cost"] = min(state["best_cost"], cost) + state["convergence"].append({"trial": tid, "cost": float(cost), "best_cost": float(state["best_cost"])}) + state["history"].append({ + "trial_id": tid, "config": cfg, + "avg_recall": float(recall_score), + "cost": float(cost), "time_s": round(total_time, 2), + "search_s": round(t_search, 2), + "scoring_s": round(scoring_time, 2), + }) + + logging.info( + f"Trial {tid}: recall={recall_score:.4f} cost={cost:.4f} " + f"time={total_time:.1f}s (search={t_search:.1f} score={scoring_time:.1f})" + ) + return float(cost) + + +def param_importance(smac: HyperparameterOptimizationFacade, output_path: pathlib.Path) -> Dict[str, Any]: + params = list(smac.scenario.configspace.keys()) + configs, costs = [], [] + for key, val in smac.runhistory.items(): + configs.append(dict(smac.runhistory.get_config(key.config_id))) + costs.append(val.cost) + if len(configs) < 3: + return {} + + raw = {} + for p in params: + groups = {} + for c, cost in zip(configs, np.array(costs)): + groups.setdefault(str(c[p]), []).append(cost) + means = [np.mean(g) for g in groups.values()] + raw[p] = float(np.var(means)) if len(means) > 1 else 0.0 + + total = sum(raw.values()) + imp = {p: round(v / total, 4) for p, v in raw.items()} if total > 0 else raw + ranking = sorted(imp, key=imp.get, reverse=True) + result = {"method": "variance_based", "ranking": ranking, "individual": imp} + with open(output_path / "parameter_importance.json", "w") as f: + json.dump(result, f, indent=2) + return result + + +def run(dataset_name: str, max_questions: int, n_trials: int, output_dir: Union[str, pathlib.Path], registry_path:str) -> Tuple[ + Dict[str, Any], List[Any], Dict[str, Any]]: + registry = load_registry(registry_path) + datasets = registry["datasets"] + if dataset_name not in datasets: + raise ValueError(f"Unknown dataset: {dataset_name}. Available: {list(datasets.keys())}") + dcfg = datasets[dataset_name] + fields = dcfg["fields"] + + out = pathlib.Path(output_dir) / dataset_name + out.mkdir(parents=True, exist_ok=True) + answers_dir = out / "trial_answers" + answers_dir.mkdir(parents=True, exist_ok=True) + + qa = read_dataset_qa(dataset_name, dcfg["subdirectory"], dcfg["split"]) + if max_questions: + qa = qa.select(range(min(max_questions, len(qa)))) + + questions = [ + { + "question": r[fields["q"]], + "ground_truth": r[fields["a"]], + "id": r.get(fields["id"], str(i)), + } + for i, r in enumerate(qa) + ] + prompt_map = registry["prompts"] + + cs = ConfigurationSpace(seed=42) + cs.add([ + # Categorical("chunk_size", [250, 1000, 2000], default=1000), + # Categorical("chunk_overlap", [50, 200], default=50), + Categorical("chunk_size", [2000], default=2000), + Categorical("chunk_overlap", [50], default=50), + Categorical("search_mode", ["dense", "sparse", "dense_sparse", "dense_sparse_colbert"], default="dense"), + Categorical("reranking_mode", ["none", "reranking_with_flagreranker", "reranking_with_sentence_transformers", "reranking_with_colbert"], default="reranking_with_sentence_transformers"), + Categorical("rewrite_mode", ["none", "subqueries", "keywords", "subqueries_keywords"], default="subqueries_keywords"), + Categorical("fusion_mode", ["none", "DBSF", "RRF"], default="DBSF"), + Categorical("reranking", ["True", "False"], default="False"), + Categorical("rewrite", ["True", "False"], default="False"), + ]) + cs.add(ForbiddenGreaterThanRelation(cs["chunk_overlap"], cs["chunk_size"])) + # for sm in ["dense", "sparse"]: + # for fm in ["DBSF", "RRF"]: + # cs.add( + # ForbiddenAndConjunction( + # ForbiddenEqualsClause(cs["search_mode"], sm), + # ForbiddenEqualsClause(cs["fusion_mode"], fm), + # ) + # ) + # for rrm in ["reranking_with_flagreranker", "reranking_with_sentence_transformers", "reranking_with_colbert"]: + # cs.add( + # ForbiddenAndConjunction( + # ForbiddenEqualsClause(cs["reranking"], "False"), + # ForbiddenEqualsClause(cs["reranking_mode"], rrm), + # ) + # ) + # + # for rwm in ["keywords", "subqueries", "subqueries_keywords"]: + # cs.add( + # ForbiddenAndConjunction( + # ForbiddenEqualsClause(cs["rewrite"], "False"), + # ForbiddenEqualsClause(cs["rewrite_mode"], rwm), + # ) + # ) + + scenario = Scenario( + cs, + deterministic=True, + n_trials=n_trials, + walltime_limit=7200, + seed=42, + output_directory=out / "smac_output", + ) + state: Dict[str, Any] = {"trial_count": 0, "best_cost": 1.0, "convergence": [], "history": []} + + smac = HyperparameterOptimizationFacade( + scenario=scenario, + target_function=lambda config, seed=0: objective(config, questions, dataset_name, state, answers_dir,prompt_map) + ) + t0 = time.time() + incumbent = smac.optimize() + importance = param_importance(smac, out) + total_time = time.time() - t0 + best_cfg = incumbent.get_dictionary() + results_path = out / "optimization_results.json" + results_path.write_text(json.dumps({ + "best_config": best_cfg, + "run_history": state["history"], + "convergence": state["convergence"], + "parameter_importance": importance, + "total_time_s": round(total_time, 2), + "dataset": dataset_name, + "metric": "recall", + "answers_dir":str(answers_dir), + }, indent=2, default = str)) + + return best_cfg, state["history"], importance + +if __name__ == "__main__": + parser = argparse.ArgumentParser() + parser.add_argument("task", nargs='?', default="learn2rag.optimization") + parser.add_argument("--dataset", type=str, default="WikiEval") + parser.add_argument("--max_questions", type=int, default=50) + parser.add_argument("--n_trials", type=int, default=10) + parser.add_argument("--logging-config", type=str) + parser.add_argument("--registry", type=str, default="registry.json") + parser.add_argument("--output_dir", type=str, default="optimization_results_baseline") + args, _ = parser.parse_known_args() + + final_output_dir = pathlib.Path(args.output_dir) + + env_out = os.environ.get("PIPELINE_OPT_CONFIG") + if not final_output_dir.exists() and env_out: + final_output_dir = pathlib.Path(env_out).parent + + incumbent, history, importance = run(args.dataset, args.max_questions, args.n_trials, final_output_dir, args.registry) + + # incumbent, history, importance = run( + # args.dataset, args.max_questions, args.n_trials, args.output_dir, + # ) + + best = min(history, key=lambda x: x["cost"]) + print(f"\nBest config: {dict(incumbent)}") + # print(f"BERTScore (golden): {best['avg_bertscore_golden']:.4f}") + if importance: + print(f"\nParameter importance:") + for i, p in enumerate(importance["ranking"], 1): + print(f" {i}. {p}: {importance['individual'][p]:.4f}") \ No newline at end of file From eb844b8edd20892b0daf2920d2740511e8504a53 Mon Sep 17 00:00:00 2001 From: Hanna Reder Date: Wed, 27 May 2026 12:54:30 +0000 Subject: [PATCH 13/47] WIP: improve parameter handling --- .../optimization/retrieval_optimization.py | 69 +++++++++++-------- learn2rag/pipeline/search.py | 2 +- 2 files changed, 42 insertions(+), 29 deletions(-) diff --git a/learn2rag/optimization/retrieval_optimization.py b/learn2rag/optimization/retrieval_optimization.py index 71502ea..77095b5 100644 --- a/learn2rag/optimization/retrieval_optimization.py +++ b/learn2rag/optimization/retrieval_optimization.py @@ -98,7 +98,7 @@ def objective(config: Configuration, # TODO ucfg = { "file_path": None, - "collection_name": dataset_name, # TODO get collection name depending on hyperparameters + "collection_name": "CSC-CS_2000-CO_50", # TODO get collection name depending on hyperparameters "imported_documents_file_path": None, "llm": None, } @@ -117,7 +117,6 @@ def objective(config: Configuration, continue try: source_list, t_s = run_search(q["question"], ucfg, working_cfg) - print("SOURCE_LIST: ", source_list) t_search += t_s predictions.append(source_list) goldens.append(q["ground_truth"]) @@ -229,36 +228,50 @@ def run(dataset_name: str, max_questions: int, n_trials: int, output_dir: Union[ Categorical("chunk_size", [2000], default=2000), Categorical("chunk_overlap", [50], default=50), Categorical("search_mode", ["dense", "sparse", "dense_sparse", "dense_sparse_colbert"], default="dense"), - Categorical("reranking_mode", ["none", "reranking_with_flagreranker", "reranking_with_sentence_transformers", "reranking_with_colbert"], default="reranking_with_sentence_transformers"), - Categorical("rewrite_mode", ["none", "subqueries", "keywords", "subqueries_keywords"], default="subqueries_keywords"), - Categorical("fusion_mode", ["none", "DBSF", "RRF"], default="DBSF"), + Categorical("reranking_mode", ["none", "reranking_with_flagreranker", "reranking_with_sentence_transformers", "reranking_with_colbert"], default="none"), + Categorical("rewrite_mode", ["none", "subqueries", "keywords", "subqueries_keywords"], default="none"), + Categorical("fusion_mode", ["none", "DBSF", "RRF"], default="none"), Categorical("reranking", ["True", "False"], default="False"), Categorical("rewrite", ["True", "False"], default="False"), ]) cs.add(ForbiddenGreaterThanRelation(cs["chunk_overlap"], cs["chunk_size"])) - # for sm in ["dense", "sparse"]: - # for fm in ["DBSF", "RRF"]: - # cs.add( - # ForbiddenAndConjunction( - # ForbiddenEqualsClause(cs["search_mode"], sm), - # ForbiddenEqualsClause(cs["fusion_mode"], fm), - # ) - # ) - # for rrm in ["reranking_with_flagreranker", "reranking_with_sentence_transformers", "reranking_with_colbert"]: - # cs.add( - # ForbiddenAndConjunction( - # ForbiddenEqualsClause(cs["reranking"], "False"), - # ForbiddenEqualsClause(cs["reranking_mode"], rrm), - # ) - # ) - # - # for rwm in ["keywords", "subqueries", "subqueries_keywords"]: - # cs.add( - # ForbiddenAndConjunction( - # ForbiddenEqualsClause(cs["rewrite"], "False"), - # ForbiddenEqualsClause(cs["rewrite_mode"], rwm), - # ) - # ) + + for sm in ["dense", "sparse"]: + for fm in ["DBSF", "RRF"]: + cs.add(ForbiddenAndConjunction( + ForbiddenEqualsClause(cs["search_mode"], sm), + ForbiddenEqualsClause(cs["fusion_mode"], fm), + )) + + for sm in ["dense_sparse", "dense_sparse_colbert"]: + cs.add(ForbiddenAndConjunction( + ForbiddenEqualsClause(cs["search_mode"], sm), + ForbiddenEqualsClause(cs["fusion_mode"], "none"), + )) + + + for rrm in ["reranking_with_flagreranker", "reranking_with_sentence_transformers", "reranking_with_colbert"]: + cs.add(ForbiddenAndConjunction( + ForbiddenEqualsClause(cs["reranking"], "False"), + ForbiddenEqualsClause(cs["reranking_mode"], rrm), + )) + + cs.add(ForbiddenAndConjunction( + ForbiddenEqualsClause(cs["reranking"], "True"), + ForbiddenEqualsClause(cs["reranking_mode"], "none"), + )) + + for rwm in ["keywords", "subqueries", "subqueries_keywords"]: + cs.add(ForbiddenAndConjunction( + ForbiddenEqualsClause(cs["rewrite"], "False"), + ForbiddenEqualsClause(cs["rewrite_mode"], rwm), + )) + + cs.add(ForbiddenAndConjunction( + ForbiddenEqualsClause(cs["rewrite"], "True"), + ForbiddenEqualsClause(cs["rewrite_mode"], "none"), + )) + scenario = Scenario( cs, diff --git a/learn2rag/pipeline/search.py b/learn2rag/pipeline/search.py index f791605..ca7e97b 100644 --- a/learn2rag/pipeline/search.py +++ b/learn2rag/pipeline/search.py @@ -409,7 +409,7 @@ def search_multi(multi_query: dict[str, str], user_config: dict[str, Any], opt_c return results -async def search_authorized(question: str, user: str, *, request_id: str | None = None) -> List[ScoredPoint]: +async def search_authorized(question: str, user: str, *, request_id: str | None = None, user_config = user_config, opt_config = opt_config) -> List[ScoredPoint]: points = _collect_query_points(question, user_config, opt_config, request_id=request_id) query_response = QueryResponse(points=points) authorized_points = await filter_authorized(user, query_response) From 4cae5d776c0f2fa3cf7c4fc137832d2fdbca2e62 Mon Sep 17 00:00:00 2001 From: Carolin Walter Date: Wed, 27 May 2026 13:40:15 +0000 Subject: [PATCH 14/47] make search faster --- learn2rag/pipeline/app.py | 6 ++ learn2rag/pipeline/ingestion.py | 1 + learn2rag/pipeline/qdrant.py | 103 ++++++++++++++++---------------- learn2rag/pipeline/search.py | 15 ++++- 4 files changed, 73 insertions(+), 52 deletions(-) diff --git a/learn2rag/pipeline/app.py b/learn2rag/pipeline/app.py index 44ac781..2bfedf4 100644 --- a/learn2rag/pipeline/app.py +++ b/learn2rag/pipeline/app.py @@ -15,6 +15,7 @@ from . import generate from . import ingestion from .config import user_config, opt_config +from .qdrant import Qdrant from .search import search_authorized @@ -58,6 +59,11 @@ async def simple_chatbot_response(input: QuestionInput) -> Any: app = FastAPI() +@app.on_event("startup") +async def startup_event() -> None: + Qdrant.ensure_collection(user_config["collection_name"], opt_config) + + @app.exception_handler(RequestValidationError) async def validation_exception_handler(request: Request, exc: RequestValidationError) -> JSONResponse: message = str(exc) diff --git a/learn2rag/pipeline/ingestion.py b/learn2rag/pipeline/ingestion.py index 9690a28..35b2f4d 100644 --- a/learn2rag/pipeline/ingestion.py +++ b/learn2rag/pipeline/ingestion.py @@ -246,5 +246,6 @@ def index(documents: list[Document], user_config: dict[str, Any], opt_config: di opt_config (dict[str, Any]): Optimisation configuration dict. """ collection_name = user_config["collection_name"] + Qdrant.ensure_collection(collection_name=collection_name, opt_config=opt_config) qdrant = Qdrant(collection_name=collection_name, opt_config=opt_config) ingest_batch(documents, qdrant, user_config, opt_config) \ No newline at end of file diff --git a/learn2rag/pipeline/qdrant.py b/learn2rag/pipeline/qdrant.py index 3c1acb4..4939d4a 100644 --- a/learn2rag/pipeline/qdrant.py +++ b/learn2rag/pipeline/qdrant.py @@ -22,56 +22,59 @@ def __init__(self, collection_name: str, opt_config: dict[str, Any]) -> None: self.query_mode = opt_config["query_mode"] self.multi_search = opt_config["multi_search"] - if self.search_mode == "dense_sparse": - if not Qdrant.client.collection_exists(self.collection_name): - Qdrant.client.create_collection( - collection_name=self.collection_name, - vectors_config={ - "dense": VectorParams(size=self.vector_size, distance=Distance.COSINE) - }, - sparse_vectors_config={ - "sparse": SparseVectorParams( - index=SparseIndexParams(on_disk=False) - ), - }, - ) - elif self.search_mode == "dense_sparse_colbert": - if not Qdrant.client.collection_exists(self.collection_name): - Qdrant.client.create_collection( - collection_name=self.collection_name, - vectors_config={ - "dense": VectorParams(size=self.vector_size, distance=Distance.COSINE), - "colbert": VectorParams( - size=self.vector_size, - distance=Distance.COSINE, - multivector_config=MultiVectorConfig( - comparator=MultiVectorComparator.MAX_SIM, - ) - ), - }, - sparse_vectors_config={ - "sparse": SparseVectorParams( - index=SparseIndexParams(on_disk=False) - ), - }, - - ) - elif self.query_mode == "multi": - if not Qdrant.client.collection_exists(self.collection_name): - vector_size = (len(self.multi_search)+1)*self.vector_size - Qdrant.client.create_collection( - collection_name=self.collection_name, - vectors_config={ - "multi": VectorParams(size=vector_size, distance=Distance.COSINE) - } - ) + @classmethod + def ensure_collection(cls, collection_name: str, opt_config: dict[str, Any]) -> None: + if cls.client.collection_exists(collection_name): + return + vector_size = opt_config["vector_size"][opt_config["embedding_model"]] + search_mode = opt_config["search_mode"] + query_mode = opt_config["query_mode"] + multi_search = opt_config["multi_search"] + if search_mode == "dense_sparse": + cls.client.create_collection( + collection_name=collection_name, + vectors_config={ + "dense": VectorParams(size=vector_size, distance=Distance.COSINE) + }, + sparse_vectors_config={ + "sparse": SparseVectorParams( + index=SparseIndexParams(on_disk=False) + ), + }, + ) + elif search_mode == "dense_sparse_colbert": + cls.client.create_collection( + collection_name=collection_name, + vectors_config={ + "dense": VectorParams(size=vector_size, distance=Distance.COSINE), + "colbert": VectorParams( + size=vector_size, + distance=Distance.COSINE, + multivector_config=MultiVectorConfig( + comparator=MultiVectorComparator.MAX_SIM, + ) + ), + }, + sparse_vectors_config={ + "sparse": SparseVectorParams( + index=SparseIndexParams(on_disk=False) + ), + }, + ) + elif query_mode == "multi": + multi_vector_size = (len(multi_search) + 1) * vector_size + cls.client.create_collection( + collection_name=collection_name, + vectors_config={ + "multi": VectorParams(size=multi_vector_size, distance=Distance.COSINE) + } + ) else: - if not Qdrant.client.collection_exists(self.collection_name): - Qdrant.client.create_collection( - collection_name=self.collection_name, - vectors_config={ - "dense": VectorParams(size=self.vector_size, distance=Distance.COSINE) - } - ) + cls.client.create_collection( + collection_name=collection_name, + vectors_config={ + "dense": VectorParams(size=vector_size, distance=Distance.COSINE) + } + ) diff --git a/learn2rag/pipeline/search.py b/learn2rag/pipeline/search.py index ca7e97b..934affc 100644 --- a/learn2rag/pipeline/search.py +++ b/learn2rag/pipeline/search.py @@ -2,6 +2,7 @@ from typing import List, Any, cast import logging import copy +from functools import lru_cache import numpy as np from FlagEmbedding import FlagReranker # type: ignore[import-untyped] @@ -19,6 +20,16 @@ profilingLogger = logging.getLogger('profiling') +@lru_cache(maxsize=4) +def _get_flag_reranker(model_name: str, use_fp16: bool) -> FlagReranker: + return FlagReranker(model_name, use_fp16=use_fp16) + + +@lru_cache(maxsize=4) +def _get_cross_encoder(model_name: str) -> CrossEncoder: + return CrossEncoder(model_name) + + def _sort_and_deduplicate(points: list[ScoredPoint]) -> list[ScoredPoint]: best_by_id: dict[str, ScoredPoint] = {} fallback_points: list[ScoredPoint] = [] @@ -48,7 +59,7 @@ def _rerank_points_with_flagreranker( model_name: str = "BAAI/bge-reranker-v2-m3", use_fp16: bool = True, ) -> list[ScoredPoint]: - reranker = FlagReranker(model_name, use_fp16=use_fp16) + reranker = _get_flag_reranker(model_name, use_fp16) valid_points = [p for p in points if p.payload and isinstance(p.payload.get("content"), str)] if len(valid_points) != len(points): @@ -78,7 +89,7 @@ def _rerank_points_with_sentence_transformers( model_name: str = "cross-encoder/ms-marco-MiniLM-L6-v2", ) -> list[ScoredPoint]: - model = CrossEncoder(model_name) + model = _get_cross_encoder(model_name) valid_points = [p for p in points if p.payload and isinstance(p.payload.get("content"), str)] if len(valid_points) != len(points): From 38d090b2b5ab0dd07a258cbe2858b61196e9c921 Mon Sep 17 00:00:00 2001 From: Carolin Walter Date: Wed, 27 May 2026 13:42:49 +0000 Subject: [PATCH 15/47] hack to ingest kcenter dump with new updater mechanism --- learn2rag/pipeline/main.py | 60 ++++++++-------- learn2rag/pipeline/old_loaders.py | 109 ++++++++++++++++++++++++++++++ 2 files changed, 142 insertions(+), 27 deletions(-) create mode 100644 learn2rag/pipeline/old_loaders.py diff --git a/learn2rag/pipeline/main.py b/learn2rag/pipeline/main.py index ca7a199..03b6aae 100755 --- a/learn2rag/pipeline/main.py +++ b/learn2rag/pipeline/main.py @@ -4,6 +4,8 @@ from langchain_core.documents.base import Document +from . import old_loaders + from . import ingestion from . import search from . import generate @@ -19,7 +21,7 @@ from .config import user_config, opt_config #delete_collection(loader_id="json_test_file", user_config=user_config, opt_config=opt_config) - results = get_documents(loader_id="json_test_file", user_config=user_config, opt_config=opt_config) + #results = get_documents(loader_id="json_test_file", user_config=user_config, opt_config=opt_config) documents = [ Document(page_content=d["content"], metadata=d["metadata"]) @@ -33,7 +35,7 @@ "process_date": "2025-07-28", "process_time": "14:42:02", "loader_type": "DirectoryLoader", - "loader_id": "json_test_file", + "loader_id": "local_docs", "title": "The title of a real document", "summary": "This document is awesome" }, @@ -48,36 +50,40 @@ "process_date": "2025-07-28", "process_time": "14:42:02", "loader_type": "DirectoryLoader", - "loader_id": "json_test_file", + "loader_id": "local_docs", "title": "The title of a real document", "summary": "This document is awesome" }, - "content": "Qdrant ist eine Open-Source-Vektordatenbank..." + "content": "ein fortlaufender Text ohne Absätze, der sehr deutlich über 4000 Token liegen sollte: In einer weit entfernten Region, in der die Landschaft aus sanften Hügeln, dichten Wäldern, breiten Flüssen und alten Steinen bestand, lag eine Stadt, die von den Bewohnern seit Generationen als Ort des Wissens, der Geduld und der sorgfältigen Beobachtung beschrieben wurde, denn dort hatte man gelernt, dass alles, was Bestand haben soll, nicht nur gebaut, sondern auch verstanden werden muss, und so begann jeder Tag mit einem stillen Blick auf das, was sich verändert hatte, sei es das Licht auf den Dächern, der Wind in den Gassen, das Wasser an den Kaimauern oder die Art, wie Menschen miteinander sprachen, wenn sie glaubten, ungehört zu sein; in dieser Stadt lebte ein Archivarin namens Mara, die jeden Morgen vor Sonnenaufgang durch die schmalen Straßen zum Haus der Aufzeichnungen ging, einem Gebäude aus dunklem Holz und hellem Stein, dessen Fenster so hoch waren, dass sie den Himmel wie schmale Streifen einfassten, und während andere noch schliefen, ordnete Mara Pergamente, Karten, Briefe, Berichte, Listen und Fragmente von Erzählungen, weil sie überzeugt war, dass eine Gesellschaft nur dann ihre Zukunft verstehen konnte, wenn sie ihre Vergangenheit nicht als Last, sondern als Werkzeug betrachtete, und jedes Dokument, das durch ihre Hände ging, war für sie nicht nur Papier oder Tinte, sondern ein Hinweis auf Entscheidungen, Zweifel, Hoffnungen und Versprechen, die irgendwann einmal in die Welt gesetzt worden waren; an den Tagen, an denen der Markt besonders belebt war, hörte sie vom offenen Fenster ihres Arbeitsraums das Rufen der Händler, das Klappern der Wagenräder und das leise Murmeln der Kunden, die Obst, Stoffe, Werkzeuge, Gewürze oder Bücher kauften, und obwohl sie selten selbst hinunterging, kannte sie die Händler nach ihren Stimmen, ihren Gewohnheiten und den kleinen Geschichten, die sie beim Liefern erzählten, etwa von einem Fischer, der behauptete, ein silberner Fisch habe ihm den Weg durch dichten Nebel gezeigt, oder von einer Schneiderin, die aus Stoffresten Karten nähte, um Kinder auf spielerische Weise geographische Zusammenhänge verstehen zu lassen; Mara notierte solche Geschichten nicht, weil sie sie für wahr oder unwahr im einfachen Sinn hielt, sondern weil sie darin eine Art menschliche Logik erkannte, denn selbst Fantasie folgt Regeln, und selbst Irrtum verrät, worauf jemand gehofft oder wovor er sich gefürchtet hat, und so lernte sie, zwischen offenkundigen Fakten und inneren Wahrheiten zu unterscheiden, ohne eines von beiden geringzuschätzen; eines Tages brachte der Bote des Stadtrats eine Mappe mit roten Schnüren, versiegelt mit dem Zeichen der sechs Türme, und darin befand sich eine Nachricht, die den ganzen Rhythmus der Stadt verändern sollte, weil sie ankündigte, dass der alte Wasserkanal, der seit Jahrhunderten die Gärten versorgte und die Mühlen antrieb, in den kommenden Monaten neu vermessen werden müsse, da sein Lauf sich an mehreren Stellen verschoben habe und die Gefahr bestehe, dass nach starkem Regen Teile des Ufers brechen könnten, wodurch nicht nur Felder, sondern auch Wohnviertel bedroht wären; viele sahen in dieser Ankündigung zunächst bloß eine technische Angelegenheit, doch Mara erkannte sofort, dass es in Wahrheit eine Prüfung des kollektiven Gedächtnisses war, denn die letzten vollständigen Karten des Kanals stammten aus einer Zeit, in der andere Messmethoden verwendet worden waren, und manche Namen der Uferabschnitte existierten nur noch in den Erzählungen alter Menschen, die sich an Überschwemmungen, Reparaturen und Umleitungen erinnerten, die nie offiziell verzeichnet worden waren; also begann sie, gemeinsam mit einem kleinen Kreis aus Gelehrten, Handwerkern, Wasserbauern, Schiffern und Anwohnern ein System des Sammelns zu entwerfen, das nicht nur auf amtlichen Dokumenten beruhte, sondern auch auf mündlicher Überlieferung, auf Skizzen, auf Markierungen an Mauern, auf eingeritzten Zeichen an Steinen und auf den Erinnerungen jener, die das Wasser jahrelang beobachtet hatten, und während sie arbeiteten, wurde deutlich, dass die Stadt nicht an Informationsmangel litt, sondern an der Zerstreuung ihres Wissens, denn vieles war vorhanden, aber nichts sprach mit dem anderen, und so mussten Brücken nicht nur über Flüsse, sondern auch zwischen Menschen, Disziplinen und Gewohnheiten gebaut werden; Mara selbst war keine große Rednerin, doch sie stellte die Fragen, die sonst niemand zu stellen wagte, zum Beispiel, warum bestimmte Berichte immer wieder dieselben Formulierungen benutzten, obwohl die Situation vor Ort anders war, oder weshalb eine Entscheidung, die auf einem alten Erlass beruhte, nie an die veränderten Gegebenheiten angepasst worden war, und häufig stellte sich heraus, dass niemand aus Böswilligkeit geschwiegen hatte, sondern aus Routine, aus Respekt vor Zuständigkeiten oder aus der stillen Annahme, jemand anders werde das Problem schon bemerken, bevor es ernst werde; genau darin lag für Mara die größte Gefahr jeder gut organisierten Gemeinschaft, dass nämlich die Annahme von Ordnung dazu verleiten kann, kritische Fragen zu vermeiden, weil man die Existenz von Formularen, Zuständigkeiten und Protokollen bereits mit echter Verständigung verwechselt, und deshalb bestand ihre Arbeit nicht nur aus dem Sammeln von Daten, sondern aus dem Einüben einer Kultur des Nachfragens, des Abgleichs und der gemeinsamen Prüfung; während die Vermessung des Kanals begann, begleitete sie eine Gruppe von Ingenieuren, die lange Stäbe, Messketten, Notiztafeln und kleine Wetterinstrumente trugen, und die ersten Tage waren von Präzision geprägt, von Zahlenreihen, Höhenangaben und Abständen, doch bald stießen sie auf Widersprüche zwischen Karte und Realität, zwischen Bericht und Gelände, zwischen offizieller Bezeichnung und lokalem Sprachgebrauch, denn an einer Stelle sprach der eine vom „alten Knick“, der nächste vom „Fischgrund“, ein dritter von der „Schattenbiegung“, und jedes Mal war es dieselbe Stelle, nur aus einer anderen Erinnerung heraus benannt, sodass Mara vorschlug, nicht einen Namen zu wählen und die übrigen zu verwerfen, sondern alle Namen nebeneinander zu führen, weil jeder von ihnen einen Blickwinkel enthielt, der für andere Zwecke nützlich sein konnte; diese Entscheidung erwies sich später als entscheidend, als ein Regenband aus dem Norden kam und die Wasserstände rascher stiegen als erwartet, denn die Menschen entlang des Kanals erkannten an den verschiedenen Namen sofort, welche Abschnitte jeweils gemeint waren, obwohl in früheren amtlichen Listen nur eine einzige Bezeichnung gestanden hatte, die für manche Bewohner kaum etwas sagte; so zeigte sich, dass Sprache nicht bloß etikettiert, sondern Orientierung schafft, und je genauer eine Gemeinschaft hinsieht, desto eher versteht sie, dass Mehrdeutigkeit nicht immer ein Problem ist, sondern manchmal ein Speicher von Erfahrung; in den Wochen danach wuchs Maras Arbeit über den Kanal hinaus, denn aus der anfänglichen Vermessung entwickelte sich ein umfassenderes Vorhaben, das die Stadt selbst betraf, ihre Lagerhäuser, ihre Straßen, ihre Werkstätten, ihre Schulen und ihre Archive, weil alle erkannten, dass die Frage, wie man Wissen ordnet, eng mit der Frage verknüpft ist, wie man Verantwortung verteilt, und so bildeten sich kleine Gruppen, die Themen wie Wartung, Beschaffung, Kommunikation, Dokumentation und Krisenreaktion neu organisierten, wobei jede Gruppe darauf achten sollte, nicht nur Berichte zu produzieren, sondern auch Rückmeldungen zu erhalten, Fehler offen zu benennen und Zuständigkeiten so zu formulieren, dass andere sie verstehen konnten; es war kein leichter Prozess, denn Menschen fürchten oft nicht die Arbeit selbst, sondern die Veränderung ihrer Gewohnheiten, und manche Beamte empfanden es als Angriff, wenn man sie bat, ihre alten Abläufe zu erklären, während einige Handwerker misstrauisch wurden, wenn ihre praktischen Kenntnisse plötzlich in Tabellen auftauchten, doch Mara vermittelte stets, dass Sichtbarkeit nicht Kontrolle bedeute, sondern Zusammenarbeit, und dass ein guter Prozess nicht nur denjenigen nützt, die ihn aufsetzen, sondern allen, die auf seine Ergebnisse angewiesen sind; in einer besonders langen Sitzung, die bis in die Abenddämmerung dauerte, wurde über die Frage gestritten, ob man für jede wichtige Entscheidung eine zentrale Stelle bestimmen solle oder ob es besser sei, mehrere unabhängige Bestätigungen einzuholen, und Mara hörte still zu, bis die Stimmen müde wurden, dann sagte sie, dass Zentralisierung dort sinnvoll sei, wo Zeit knapp und Risiko hoch sei, während Verteilung dort Vorteile biete, wo Vielfalt an Beobachtungen nötig sei, und dass man beides nicht als Gegensätze, sondern als Werkzeuge verstehen müsse, die je nach Lage unterschiedlich einzusetzen seien; dieser Satz wurde später oft wiederholt, nicht weil er besonders poetisch gewesen wäre, sondern weil er eine Haltung zusammenfasste, die viele erst allmählich lernten: dass Systeme nur dann robust werden, wenn sie sowohl klare Verantwortlichkeit als auch Raum für Korrektur besitzen; währenddessen lebte außerhalb der Stadt ein alter Kartograph namens Elian, der einst für den Hof gearbeitet hatte und nun in einem kleinen Haus am Waldrand lebte, umgeben von Kartenrollen, Holzlinealen, Glaslinsen und einem Ofen, der im Winter den Raum trocken hielt, und als er von Maras Arbeit hörte, schickte er ihr eine Nachricht mit der Einladung, seine Sammlung alter Flussverläufe zu prüfen, weil er vermutete, dass darin Hinweise auf frühere Umleitungen verborgen waren, die in offiziellen Dokumenten nicht mehr vorkamen; Mara reiste zu ihm an einem Morgen, an dem dichter Nebel über den Wiesen lag, und fand einen Mann, dessen Hände von der jahrelangen Arbeit an Papier und Pergament leicht gefärbt waren, aber dessen Augen noch immer die lebhafte Aufmerksamkeit eines Suchenden hatten, und er zeigte ihr Karten aus verschiedenen Jahrzehnten, manche mit feinen Bleistiftlinien, manche mit Tinte, manche mit verblassten Markierungen, die er anhand von Randnotizen, Wasserständen und lokalen Erzählungen datiert hatte, und gemeinsam entdeckten sie, dass mehrere Fehlstellen in den aktuellen Aufzeichnungen nicht auf Zufall beruhten, sondern auf der Praxis früherer Schreiber, störende Ereignisse zu glätten, um ein harmonischeres Bild der Stadt zu hinterlassen; diese Erkenntnis erschütterte Mara nicht, denn sie hatte schon lange geahnt, dass jede Verwaltung dazu neigt, das Unbequeme zu verkleinern, wenn nicht gar zu verschweigen, doch sie war dankbar für den Beleg, weil er ihr half, andere davon zu überzeugen, dass Offenheit kein Zeichen von Schwäche ist, sondern die Voraussetzung für belastbare Entscheidungen; Elian wiederum sagte, dass eine Karte niemals die Welt selbst sei, sondern ein Vertrag zwischen Gedächtnis und Gebrauch, und diese Formulierung schrieb Mara später über ihr Bett, weil sie ihr half, die Grenzen jeder Darstellung zu respektieren, sei es eine Karte, ein Bericht, ein Diagramm, ein Protokoll oder ein Modell; im Verlauf des Sommers wurden die Arbeiten am Kanal vollendet, doch daraus entstand kein Gefühl des Abschlusses, sondern vielmehr ein neues Bewusstsein dafür, dass jede Lösung weitere Fragen eröffnet, denn nun wollte man wissen, wie die Gärten effizienter bewässert werden könnten, wie die Mühlen ihre Last besser verteilen sollten, wie Schiffe ihre Routen sicherer planen könnten und wie die Bevölkerung im Falle künftiger Unwetter schneller informiert werden könnte, und so begann man, ein Netzwerk aus Signalpunkten aufzubauen, das aus Türmen, Glocken, Flaggen und Boten bestand, ergänzt durch einfache Regeln, welche Meldung welchen Weg nehmen sollte; Mara bestand darauf, dass die Regeln kurz, verständlich und testbar sein müssten, weil lange Anweisungen in Stresssituationen versagen, und sie führte kleine Übungen durch, bei denen absichtlich falsche oder unvollständige Nachrichten in Umlauf gebracht wurden, um zu sehen, wo das System brüchig war, und jedes Mal, wenn ein Fehler erkannt wurde, schrieb sie nicht nur die Ursache auf, sondern auch die Beobachtung, die dazu geführt hatte, denn sie wollte nicht allein wissen, was scheiterte, sondern auch, wie man das Scheitern bemerkte; nach einigen Monaten hatten sich diese Übungen zu einer Art städtischer Gewohnheit entwickelt, und selbst Kinder spielten in den Höfen, dass sie Meldungen weitergeben, prüfen und bestätigen müssten, wobei sie lachten, wenn jemand die falsche Reihenfolge wählte, aber auch lernten, dass jede Information eine Quelle und einen Zweck hat; in dieser Zeit erkrankte Elian schwer, und Mara besuchte ihn mehrfach, brachte ihm Suppe, sauberes Wasser und Abschriften seiner besten Karten, damit er trotz Schwäche weiter mitdenken konnte, und in den Gesprächen am Bett wurde deutlich, dass seine größte Sorge nicht sein eigener Zustand war, sondern die Frage, ob sein Wissen nach seinem Tod in Vergessenheit geraten würde, weil es über zu viele private Notizen verteilt war, die niemand außer ihm entschlüsseln konnte; also begannen sie gemeinsam, ein übersichtliches Verzeichnis seiner Karten und Notizen anzulegen, mit klaren Titeln, Datierungen, Querverweisen und kurzen Erläuterungen, sodass auch andere damit arbeiten konnten, und als er die ersten Ergebnisse sah, lächelte er und meinte, das sei die freundlichste Form der Unsterblichkeit, nicht als Denkmal, sondern als nutzbares Wissen weiterzuleben; Mara behielt diesen Satz lange im Gedächtnis, weil er ihr vor Augen führte, dass gute Organisation nicht nur Effizienz erzeugt, sondern Würde verleiht, da sie verhindert, dass Erkenntnisse mit ihren Urhebern sterben; als der Herbst kam, färbten sich die Bäume goldbraun, und die Stadt bereitete sich auf die kälteren Monate vor, indem Vorräte geprüft, Dächer geflickt, Leinen verstaut und Brennholz gestapelt wurden, und wieder zeigte sich, wie sehr die Qualität alltäglicher Vorbereitung von verlässlicher Information abhängt, denn wer zu spät erfährt, dass ein Dach undicht ist, verliert mehr als nur Zeit, und wer zu spät erkennt, dass ein Lager knapp wird, handelt unter Druck und macht Fehler; deshalb setzte Mara sich dafür ein, dass alle wichtigen Beobachtungen nicht erst in großen Berichten, sondern unmittelbar und in einfacher Form erfasst wurden, am besten dort, wo die Arbeit stattfand, weil jede zusätzliche Übertragung die Wahrscheinlichkeit von Missverständnissen erhöht; diese Praxis stieß anfangs auf Widerstand, weil einige meinten, es sei unnötig, Handwerker mit Listen zu belasten, doch bald stellte sich heraus, dass gerade die direkte Erfassung viele spätere Rückfragen ersparte, und so entstanden kleine, robuste Abläufe, in denen ein Werkstattmeister, eine Lagerverwalterin oder ein Botenführer sofort melden konnte, was relevant war, ohne erst durch mehrere Hierarchieebenen zu gehen; im Winter, wenn Schnee die Dächer bedeckte und die Straßen leiser wurden, kehrte die Stadt in eine langsamere, nachdenklichere Haltung zurück, und Mara nutzte die Ruhe, um aus den vielen gesammelten Notizen ein Lehrbuch des städtischen Wissens zu erstellen, das nicht nur erklärte, wie man Daten sammelt, sondern auch, wie man Zweifel formuliert, Prioritäten setzt, Fehler erkennt, Rückmeldungen verarbeitet und Entscheidungen anpasst; sie schrieb darin über die Notwendigkeit klarer Begriffe, über die Vorteile mehrfacher Perspektiven, über die Grenzen von Annahmen und über die Kunst, aus unvollständigen Informationen dennoch vernünftig zu handeln, und je weiter sie schrieb, desto mehr merkte sie, dass sie nicht bloß ein Buch zusammenstellte, sondern eine Haltung überlieferte, die vielleicht in künftigen Krisen nützlicher sein würde als jedes einzelne Detail; als das Jahr sich dem Ende näherte, kam der Stadtrat zusammen, um die Ergebnisse zu bewerten, und statt einer feierlichen Rede erwarteten sie Zahlen, Karten, Fallbeispiele und Erfahrungen aus der Praxis, und Mara präsentierte ruhig, was erreicht worden war: weniger widersprüchliche Meldungen, schnellere Reaktionszeiten, klarere Zuständigkeiten, mehr Transparenz bei der Pflege öffentlicher Anlagen und ein wachsendes Vertrauen zwischen Verwaltung und Bevölkerung, weil man gelernt hatte, dass Beteiligung nicht bedeutet, jede Entscheidung endlos zu diskutieren, sondern die richtigen Menschen zur richtigen Zeit mit den richtigen Informationen zu versorgen; die Ratsmitglieder nickten, einige überrascht, andere erleichtert, und einer von ihnen fragte, was die wichtigste Lehre des Jahres sei, worauf Mara antwortete, dass Ordnung nur dann nützlich sei, wenn sie der Wirklichkeit dient, und dass jede Struktur, die nicht regelmäßig überprüft wird, irgendwann zur bloßen Gewohnheit erstarrt; nach dieser Sitzung ging sie spät in der Nacht durch die schneebedeckten Straßen nach Hause, und während der Mond auf den Dächern lag, dachte sie daran, wie seltsam und kostbar menschliche Gemeinschaften sind, wie viel Mühe es kostet, Vertrauen aufzubauen, wie leicht Missverständnisse entstehen und wie viel sich zum Guten wendet, wenn Menschen bereit sind, einander zuzuhören, ihre Aufzeichnungen zu teilen, ihre Annahmen zu prüfen und die Welt nicht nur so zu sehen, wie sie erscheinen möchte, sondern so, wie sie tatsächlich ist; sie öffnete die Tür ihres Hauses, legte den Mantel ab, setzte Wasser auf und blickte noch einmal auf die Schachtel mit Karten, Notizen und Berichten, die auf dem Tisch stand, und empfand keine Erschöpfung, sondern stille Zuversicht, weil sie wusste, dass alles Wichtige nicht in einem einzigen großen Akt geschieht, sondern in vielen kleinen, wiederholten Gesten von Sorgfalt, Klarheit und Respekt, die zusammen etwas schaffen, das größer ist als die Summe seiner Teile, und genau darin, dachte sie, liegt die eigentliche Arbeit jeder Stadt, jeder Institution und jeder Gemeinschaft: das Verstreute zu verbinden, das Unsichere zu prüfen, das Vorläufige zu verbessern und das Vergängliche so aufzuschreiben, dass daraus Orientierung entstehen kann, heute, morgen und in den Jahren, die noch kommen werden." }, ] ] - update_documents(loader_id="json_test_file", documents=documents, user_config=user_config, opt_config=opt_config) - ingestion.index(documents, user_config, opt_config) - - if opt_config["query_mode"] == "multi": - # in query_mode 'multi' different querys for each vector in the multi-vector are allowed - multi_query = {"content": "What is USM AI?", "title": "What is USM AI?", "summary": "What is USM AI?", "source_path":"USU/ITSM/"} - results = search.search_multi(multi_query, user_config, opt_config, request_id=None) - points = results.points - # modify the query for generation part - query = " ".join(f"{k}={v}" for k, v in multi_query.items()) - else: - query = "Was sind A, B und C?" - user = "anonymous" - points = asyncio.run(search.search_authorized(query, user, request_id=None)) - - sources = "\n".join(set(point.payload['path'] for point in points)) # type: ignore[index] - - for point in points: - print(f"ID: {point.id}, Path: {point.payload['path']}, Score: {point.score}") # type: ignore[index] + #update_documents(loader_id="json_test_file", documents=documents, user_config=user_config, opt_config=opt_config) + + all_documents = old_loaders.json_loader(user_config['imported_documents_file_path']) + ingestion.index(all_documents, user_config, opt_config) - answer = generate.generate(query, points, opt_config) + print("finished ingestion") - print(query) - print(answer) - print(sources) + #if opt_config["query_mode"] == "multi": + # # in query_mode 'multi' different querys for each vector in the multi-vector are allowed + # multi_query = {"content": "What is USM AI?", "title": "What is USM AI?", "summary": "What is USM AI?", "source_path":"USU/ITSM/"} + # results = search.search_multi(multi_query, user_config, opt_config, request_id=None) + # points = results.points + # # modify the query for generation part + # query = " ".join(f"{k}={v}" for k, v in multi_query.items()) + #else: + # query = "Was sind A, B und C?" + # user = "anonymous" + # points = asyncio.run(search.search_authorized(query, user, request_id=None)) +# + #sources = set(point.payload['source'] for point in points) # type: ignore[index] +# + #for point in points: + # print(f"ID: {point.id}, Source: {point.payload['source']}, Score: {point.score}") # type: ignore[index] +# + #answer = generate.generate(query, points, opt_config) +# + #print(query) + #print(answer) + #print(sources) diff --git a/learn2rag/pipeline/old_loaders.py b/learn2rag/pipeline/old_loaders.py new file mode 100644 index 0000000..eacaaa7 --- /dev/null +++ b/learn2rag/pipeline/old_loaders.py @@ -0,0 +1,109 @@ +import asyncio +import bz2 +import itertools +import logging +from typing import Iterator, Sequence +import os + +from bs4 import SoupStrainer # type: ignore[attr-defined] +from lxml import etree + +from langchain_community.document_loaders import ( + BSHTMLLoader, + PyPDFLoader, + WebBaseLoader, + JSONLoader, +) +from langchain_core.documents import Document + + +def json_loader(file_path: str) -> list[Document]: + loader = JSONLoader( + file_path, + jq_schema=".[]", + content_key="content", + metadata_func=lambda record, meta: record.get("metadata", {}), + ) + return loader.load() + + +def html_loader(file_path: str) -> list[Document]: + loader = BSHTMLLoader(file_path) + return loader.load() + + +def pdf_loader(file_path: str) -> list[Document]: + loader = PyPDFLoader(file_path) + docs = asyncio.run(loader.aload()) + return docs + + +def sync_pdf_loader(file_path: str) -> list[Document]: + all_documents = [] + for file in os.listdir(file_path): + if file.endswith(".pdf"): + loader = PyPDFLoader( + os.path.join(file_path, file), mode="single" + ) # important: default of mode is page-vise! + docs = loader.load() + all_documents.extend(docs) + return all_documents + + +def web_loader(web_path: Sequence[str]) -> list[Document]: + bs4_strainer = SoupStrainer( + class_=[ + "SP-Content__main", + "section sectionZ sectionArticle", + "page__content", + "post-content", + ] + ) + loader = WebBaseLoader( + web_path=web_path, + bs_kwargs={"parse_only": bs4_strainer}, + ) + docs = loader.load() + return docs + + +def cleanup_etree(elem: etree._Element) -> None: + elem.clear() + while elem.getprevious() is not None: + del elem.getparent()[0] # type:ignore[union-attr] + + +def read_wikibooks_dump(path: str) -> Iterator[tuple[str, str]]: + total = 0 + skipped = 0 + file = bz2.open(path) + for action, elem in etree.iterparse( + file, events=("end",), recover=True, huge_tree=True + ): + localname = etree.QName(elem).localname + if localname == "page": + title = elem.xpath('*[local-name()="title"]') + text = elem.xpath('*//*[local-name()="text"]') + if len(title) == 1 and len(text) == 1 and text[0].text is not None: + yield title[0].text, text[0].text + total += 1 + if total % 10000 == 0: + logging.debug("Pages read from %s: %d", path, total) + else: + skipped += 1 + cleanup_etree(elem) + logging.debug("Pages skipped in %s: %d", path, skipped) + + +def wikibooks_loader(path: str, limit: int | None = None) -> list[Document]: + docs: list[Document] = [] + for title, text in itertools.islice(read_wikibooks_dump(path), limit): + docs.append( + Document( + page_content=text, + metadata={ + "source": f"wikibooks:{title}", + }, + ) + ) + return docs \ No newline at end of file From 2f6e15fb951029babd1c09624f7ba41fa7590745 Mon Sep 17 00:00:00 2001 From: Hanna Reder Date: Fri, 29 May 2026 08:11:08 +0000 Subject: [PATCH 16/47] include time in objective function & minor fixes --- learn2rag/evaluation/tools.py | 18 +++-- .../optimization/retrieval_optimization.py | 72 +++++++++++-------- learn2rag/pipeline/search.py | 9 ++- 3 files changed, 62 insertions(+), 37 deletions(-) diff --git a/learn2rag/evaluation/tools.py b/learn2rag/evaluation/tools.py index ea1e351..307e4df 100644 --- a/learn2rag/evaluation/tools.py +++ b/learn2rag/evaluation/tools.py @@ -80,21 +80,27 @@ def ingest_dataset_documents(dataset_name: str) -> None: # learn2rag.pipeline.ingestion.index(user_config, opt_config) -def read_dataset_qa(dataset_name: str, subdirectory: str, split: str | None=None) -> Any: +def read_dataset_qa(dataset_name: str, subdirectory: str, split: str | None = None) -> Any: logging.debug(f'{dataset_name=}') if subdirectory.endswith('.csv'): df = pd.read_csv(subdirectory, sep=';') # wrap in object that behaves like HuggingFace dataset class CSVDataset: - def __init__(self, df): + data: pd.DataFrame + + def __init__(self, df: pd.DataFrame) -> None: self.data = df - def __len__(self): + + def __len__(self) -> int: return len(self.data) - def __getitem__(self, idx): - return self.data.iloc[idx].to_dict() - def select(self, indices): + + def __getitem__(self, idx: int) -> dict[str, Any]: + return dict(self.data.iloc[idx].to_dict()) + + def select(self, indices: Any) -> "CSVDataset": return CSVDataset(self.data.iloc[list(indices)]) + return CSVDataset(df) else: diff --git a/learn2rag/optimization/retrieval_optimization.py b/learn2rag/optimization/retrieval_optimization.py index 77095b5..6a1184a 100644 --- a/learn2rag/optimization/retrieval_optimization.py +++ b/learn2rag/optimization/retrieval_optimization.py @@ -10,46 +10,44 @@ import copy import os import asyncio -from typing import Dict, Any, List, Union, Tuple +from typing import Dict, Any, List, Union, Tuple, cast import numpy as np -from bert_score import score as bert_score +# from bert_score import score as bert_score # type: ignore[import-not-found] from ConfigSpace import ConfigurationSpace, Integer, Categorical, ForbiddenGreaterThanRelation, Configuration, \ - ForbiddenAndConjunction, ForbiddenEqualsClause -from smac import HyperparameterOptimizationFacade, Scenario + ForbiddenAndConjunction, ForbiddenEqualsClause # type: ignore[import-not-found] +from smac import HyperparameterOptimizationFacade, Scenario # type: ignore[import-not-found] from learn2rag.evaluation.tools import read_dataset_qa from learn2rag.pipeline.config import opt_config import learn2rag.pipeline.search -import learn2rag.pipeline.generate +# import learn2rag.pipeline.generate -def load_registry(path: str = "registry.json") -> dict: +def load_registry(path: str = "registry.json") -> dict[str, Any]: p = pathlib.Path(path) if not p.is_file(): logging.error("registry file not found") with p.open() as f: - return json.load(f) + return cast(dict[str, Any], json.load(f)) def run_search(question: str, user_config: Dict[str, Any], working_config: Dict[str, Any]) -> Tuple[List[Any], float]: t0 = time.time() - # docs = learn2rag.pipeline.search.search(question, user_config, working_config) - # TODO user config/opt config docs = asyncio.run(learn2rag.pipeline.search.search_authorized(question, user="anonymous", request_id=None, user_config=user_config, opt_config=working_config)) search_time = time.time() - t0 - source_list = [point.payload['source'] for point in docs] + source_list = [point.payload['source'] for point in docs if point.payload is not None and "source" in point.payload] return source_list, search_time -def recall(search_results, labels): +def recall(search_results: list[list[Any]], labels: list[Any]) -> float: count = 0 top_k = opt_config["top_k"] for q in range(len(search_results)): label = str(labels[q]) hits = [str(h) for h in search_results[q]] - print('label ',label, ' hits: ', hits) + # print('label ', label, ' hits: ', hits) if label in hits[:top_k]: count += 1 return count / len(labels) if labels else 0.0 @@ -59,10 +57,8 @@ def recall(search_results, labels): # removed dataset_name because it just use in user config and now we inject it def objective(config: Configuration, questions: List[Dict[str, Any]], - dataset_name: str, state: Dict[str, Any], answers_dir: pathlib.Path - ,prompt_map ) -> float: state["trial_count"] += 1 tid = state["trial_count"] @@ -81,8 +77,6 @@ def objective(config: Configuration, logging.warning(f"Skip invalid cfg: {cfg}") return 1.0 - -# TODO working_cfg = copy.deepcopy(opt_config) working_cfg.update({ "chunk_size": cfg["chunk_size"], @@ -95,10 +89,9 @@ def objective(config: Configuration, "rewrite": cfg["rewrite"] }) -# TODO ucfg = { "file_path": None, - "collection_name": "CSC-CS_2000-CO_50", # TODO get collection name depending on hyperparameters + "collection_name": f"CSC-CS_{cfg['chunk_size']}-CO_{cfg['chunk_overlap']}", "imported_documents_file_path": None, "llm": None, } @@ -106,7 +99,7 @@ def objective(config: Configuration, if env_user_cfg and pathlib.Path(env_user_cfg).exists(): ucfg.update(json.loads(pathlib.Path(env_user_cfg).read_text())) - predictions, goldens = [], [] + predictions, goldens = [], [] # type: ignore qa_pairs = [] t_start = time.time() t_search = 0.0 @@ -134,16 +127,23 @@ def objective(config: Configuration, t_score = time.time() recall_score = recall(predictions, goldens) scoring_time = time.time() - t_score + total_time = time.time() - t_start # objective function - cost = 1.0 - recall_score - total_time = time.time() - t_start + w_recall = 0.5 + w_time = 0.5 + t_search_per_sample_upper = 50 + max_time_s = t_search_per_sample_upper*len(predictions) + time_cost = max(0.0, 1.0 - (t_search / max_time_s)) + cost = 1.0 - w_recall*recall_score - w_time*time_cost + avg_t_search = t_search/len(predictions) trial_answers = { "trial_id": tid, "config": cfg, "cost": float(cost), - "avg_recall": float(recall_score), + "recall": float(recall_score), + "avg_t_search": float(avg_t_search), "qa_pairs": qa_pairs, } answers_file = answers_dir / f"trial_{tid}_answers.json" @@ -154,14 +154,16 @@ def objective(config: Configuration, state["convergence"].append({"trial": tid, "cost": float(cost), "best_cost": float(state["best_cost"])}) state["history"].append({ "trial_id": tid, "config": cfg, - "avg_recall": float(recall_score), - "cost": float(cost), "time_s": round(total_time, 2), + "recall": float(recall_score), + "avg_t_search": float(avg_t_search), + "cost": float(cost), + "time_s": round(total_time, 2), "search_s": round(t_search, 2), "scoring_s": round(scoring_time, 2), }) logging.info( - f"Trial {tid}: recall={recall_score:.4f} cost={cost:.4f} " + f"Trial {tid}: recall={recall_score:.4f} avg_t_search={avg_t_search: .4f} cost={cost:.4f} " f"time={total_time:.1f}s (search={t_search:.1f} score={scoring_time:.1f})" ) return float(cost) @@ -186,7 +188,7 @@ def param_importance(smac: HyperparameterOptimizationFacade, output_path: pathli total = sum(raw.values()) imp = {p: round(v / total, 4) for p, v in raw.items()} if total > 0 else raw - ranking = sorted(imp, key=imp.get, reverse=True) + ranking = sorted(imp, key=imp.get, reverse=True) # type: ignore[arg-type] result = {"method": "variance_based", "ranking": ranking, "individual": imp} with open(output_path / "parameter_importance.json", "w") as f: json.dump(result, f, indent=2) @@ -223,10 +225,8 @@ def run(dataset_name: str, max_questions: int, n_trials: int, output_dir: Union[ cs = ConfigurationSpace(seed=42) cs.add([ - # Categorical("chunk_size", [250, 1000, 2000], default=1000), - # Categorical("chunk_overlap", [50, 200], default=50), - Categorical("chunk_size", [2000], default=2000), - Categorical("chunk_overlap", [50], default=50), + Categorical("chunk_size", [250, 1000, 2000], default=1000), + Categorical("chunk_overlap", [50, 200], default=50), Categorical("search_mode", ["dense", "sparse", "dense_sparse", "dense_sparse_colbert"], default="dense"), Categorical("reranking_mode", ["none", "reranking_with_flagreranker", "reranking_with_sentence_transformers", "reranking_with_colbert"], default="none"), Categorical("rewrite_mode", ["none", "subqueries", "keywords", "subqueries_keywords"], default="none"), @@ -236,6 +236,11 @@ def run(dataset_name: str, max_questions: int, n_trials: int, output_dir: Union[ ]) cs.add(ForbiddenGreaterThanRelation(cs["chunk_overlap"], cs["chunk_size"])) + cs.add(ForbiddenAndConjunction( + ForbiddenEqualsClause(cs["chunk_size"], 250), + ForbiddenEqualsClause(cs["chunk_overlap"], 200), + )) + for sm in ["dense", "sparse"]: for fm in ["DBSF", "RRF"]: cs.add(ForbiddenAndConjunction( @@ -292,9 +297,16 @@ def run(dataset_name: str, max_questions: int, n_trials: int, output_dir: Union[ importance = param_importance(smac, out) total_time = time.time() - t0 best_cfg = incumbent.get_dictionary() + best_trial = min( + (h for h in state["history"] if h.get("config") == best_cfg), + key=lambda h: h["cost"], + default=None, + ) + best_trial_id = best_trial["trial_id"] if best_trial else None results_path = out / "optimization_results.json" results_path.write_text(json.dumps({ "best_config": best_cfg, + "best_trial_id": best_trial_id, "run_history": state["history"], "convergence": state["convergence"], "parameter_importance": importance, diff --git a/learn2rag/pipeline/search.py b/learn2rag/pipeline/search.py index 934affc..1ab26b7 100644 --- a/learn2rag/pipeline/search.py +++ b/learn2rag/pipeline/search.py @@ -138,6 +138,7 @@ def _rerank_points_with_colbert( query=colbert_query, # type: ignore[arg-type] using="colbert", limit=top_k, + timeout=100 ) return list(results.points) @@ -318,6 +319,7 @@ def search(query: str, user_config: dict[str, Any], opt_config: dict[str, Any], query=query_embedding, # type: ignore[arg-type, unused-ignore] using="dense", limit=opt_config["top_k"], + timeout=100 ) elif opt_config["search_mode"] == "sparse": indices = [int(k) for k in query_embedding["lexical_weights"].keys()] # type: ignore[union-attr] @@ -327,6 +329,7 @@ def search(query: str, user_config: dict[str, Any], opt_config: dict[str, Any], query=models.SparseVector(indices=indices, values=values), using="sparse", limit=opt_config["top_k"], + timeout=100 ) elif opt_config["search_mode"] == "dense_sparse": indices = [int(k) for k in query_embedding["lexical_weights"].keys()] # type: ignore[union-attr] @@ -347,6 +350,7 @@ def search(query: str, user_config: dict[str, Any], opt_config: dict[str, Any], ], query=models.FusionQuery(fusion=fusion_mode), limit=opt_config["top_k"], + timeout=100 ) elif opt_config["search_mode"] == "dense_sparse_colbert": @@ -373,6 +377,7 @@ def search(query: str, user_config: dict[str, Any], opt_config: dict[str, Any], ], query=models.FusionQuery(fusion=fusion_mode), limit=opt_config["top_k"], + timeout=100 ) elif opt_config["search_mode"] == "multi_search": @@ -381,6 +386,7 @@ def search(query: str, user_config: dict[str, Any], opt_config: dict[str, Any], query=query_embedding, # type: ignore[arg-type, unused-ignore] using="multi", limit=opt_config["top_k"], + timeout=100 ) return results @@ -415,12 +421,13 @@ def search_multi(multi_query: dict[str, str], user_config: dict[str, Any], opt_c query=query_embedding, # type: ignore[arg-type, unused-ignore] using="multi", limit=opt_config["top_k"], + timeout=100 ) profilingLogger.info('end', extra={'activity': 'search', 'request_id': request_id}) return results -async def search_authorized(question: str, user: str, *, request_id: str | None = None, user_config = user_config, opt_config = opt_config) -> List[ScoredPoint]: +async def search_authorized(question: str, user: str, *, request_id: str | None = None, user_config: dict[str, Any] = user_config, opt_config: dict[str, Any] = opt_config) -> List[ScoredPoint]: points = _collect_query_points(question, user_config, opt_config, request_id=request_id) query_response = QueryResponse(points=points) authorized_points = await filter_authorized(user, query_response) From cd22a854d66e0f0a83c28eeeb4cb57b28333251a Mon Sep 17 00:00:00 2001 From: Hanna Reder Date: Fri, 29 May 2026 12:02:56 +0000 Subject: [PATCH 17/47] fix mypy issues --- learn2rag/evaluation/tools.py | 4 +-- .../optimization/retrieval_optimization.py | 30 ++++++++++++------- learn2rag/pipeline/search.py | 2 +- 3 files changed, 23 insertions(+), 13 deletions(-) diff --git a/learn2rag/evaluation/tools.py b/learn2rag/evaluation/tools.py index 307e4df..0bd6558 100644 --- a/learn2rag/evaluation/tools.py +++ b/learn2rag/evaluation/tools.py @@ -6,7 +6,7 @@ import logging import datasets import json_stream # type: ignore[import-untyped] -from typing import Any, Callable +from typing import Any, Callable, cast import pandas as pd import learn2rag.pipeline.ingestion @@ -96,7 +96,7 @@ def __len__(self) -> int: return len(self.data) def __getitem__(self, idx: int) -> dict[str, Any]: - return dict(self.data.iloc[idx].to_dict()) + return cast(dict[str, Any], self.data.iloc[idx].to_dict()) def select(self, indices: Any) -> "CSVDataset": return CSVDataset(self.data.iloc[list(indices)]) diff --git a/learn2rag/optimization/retrieval_optimization.py b/learn2rag/optimization/retrieval_optimization.py index 6a1184a..da50bc8 100644 --- a/learn2rag/optimization/retrieval_optimization.py +++ b/learn2rag/optimization/retrieval_optimization.py @@ -14,9 +14,16 @@ import numpy as np # from bert_score import score as bert_score # type: ignore[import-not-found] -from ConfigSpace import ConfigurationSpace, Integer, Categorical, ForbiddenGreaterThanRelation, Configuration, \ - ForbiddenAndConjunction, ForbiddenEqualsClause # type: ignore[import-not-found] -from smac import HyperparameterOptimizationFacade, Scenario # type: ignore[import-not-found] +from ConfigSpace import ( + ConfigurationSpace, + Integer, + Categorical, + ForbiddenGreaterThanRelation, + Configuration, + ForbiddenAndConjunction, + ForbiddenEqualsClause, +) +from smac import HyperparameterOptimizationFacade, Scenario from learn2rag.evaluation.tools import read_dataset_qa from learn2rag.pipeline.config import opt_config @@ -99,8 +106,10 @@ def objective(config: Configuration, if env_user_cfg and pathlib.Path(env_user_cfg).exists(): ucfg.update(json.loads(pathlib.Path(env_user_cfg).read_text())) - predictions, goldens = [], [] # type: ignore - qa_pairs = [] + predictions: list[list[Any]] = [] + goldens: list[Any] = [] + qa_pairs: list[dict[str, Any]] = [] + t_start = time.time() t_search = 0.0 @@ -178,11 +187,11 @@ def param_importance(smac: HyperparameterOptimizationFacade, output_path: pathli if len(configs) < 3: return {} - raw = {} + raw: dict[str, float] = {} for p in params: - groups = {} + groups: dict[str, list[float]] = {} for c, cost in zip(configs, np.array(costs)): - groups.setdefault(str(c[p]), []).append(cost) + groups.setdefault(str(c[p]), []).append(float(cost)) means = [np.mean(g) for g in groups.values()] raw[p] = float(np.var(means)) if len(means) > 1 else 0.0 @@ -221,7 +230,6 @@ def run(dataset_name: str, max_questions: int, n_trials: int, output_dir: Union[ } for i, r in enumerate(qa) ] - prompt_map = registry["prompts"] cs = ConfigurationSpace(seed=42) cs.add([ @@ -290,10 +298,12 @@ def run(dataset_name: str, max_questions: int, n_trials: int, output_dir: Union[ smac = HyperparameterOptimizationFacade( scenario=scenario, - target_function=lambda config, seed=0: objective(config, questions, dataset_name, state, answers_dir,prompt_map) + target_function=lambda config, seed=0: objective(config, questions, state, answers_dir) ) t0 = time.time() incumbent = smac.optimize() + if isinstance(incumbent, list): + incumbent = incumbent[0] importance = param_importance(smac, out) total_time = time.time() - t0 best_cfg = incumbent.get_dictionary() diff --git a/learn2rag/pipeline/search.py b/learn2rag/pipeline/search.py index 1ab26b7..efdf857 100644 --- a/learn2rag/pipeline/search.py +++ b/learn2rag/pipeline/search.py @@ -27,7 +27,7 @@ def _get_flag_reranker(model_name: str, use_fp16: bool) -> FlagReranker: @lru_cache(maxsize=4) def _get_cross_encoder(model_name: str) -> CrossEncoder: - return CrossEncoder(model_name) + return CrossEncoder(model_name) # type: ignore[no-any-return] def _sort_and_deduplicate(points: list[ScoredPoint]) -> list[ScoredPoint]: From fbb402cb086fa7c59d8ed3cf79cbcd02f9da38c4 Mon Sep 17 00:00:00 2001 From: Hanna Reder Date: Tue, 9 Jun 2026 09:20:24 +0000 Subject: [PATCH 18/47] optimisation adjustments --- .../optimization/retrieval_optimization.py | 15 +++--- learn2rag/pipeline/ingestion.py | 46 ++++++++++++++++++- learn2rag/pipeline/search.py | 17 +++---- 3 files changed, 63 insertions(+), 15 deletions(-) diff --git a/learn2rag/optimization/retrieval_optimization.py b/learn2rag/optimization/retrieval_optimization.py index da50bc8..57fd69c 100644 --- a/learn2rag/optimization/retrieval_optimization.py +++ b/learn2rag/optimization/retrieval_optimization.py @@ -14,7 +14,7 @@ import numpy as np # from bert_score import score as bert_score # type: ignore[import-not-found] -from ConfigSpace import ( +from ConfigSpace import (# type: ignore[import-not-found] ConfigurationSpace, Integer, Categorical, @@ -23,7 +23,7 @@ ForbiddenAndConjunction, ForbiddenEqualsClause, ) -from smac import HyperparameterOptimizationFacade, Scenario +from smac import HyperparameterOptimizationFacade, Scenario# type: ignore[import-not-found] from learn2rag.evaluation.tools import read_dataset_qa from learn2rag.pipeline.config import opt_config @@ -139,8 +139,8 @@ def objective(config: Configuration, total_time = time.time() - t_start # objective function - w_recall = 0.5 - w_time = 0.5 + w_recall = 1 + w_time = 0 t_search_per_sample_upper = 50 max_time_s = t_search_per_sample_upper*len(predictions) time_cost = max(0.0, 1.0 - (t_search / max_time_s)) @@ -153,7 +153,10 @@ def objective(config: Configuration, "cost": float(cost), "recall": float(recall_score), "avg_t_search": float(avg_t_search), - "qa_pairs": qa_pairs, + "w_recall": w_recall, + "w_time": w_time, + "top_k": opt_config["top_k"], + "qa_pairs": qa_pairs } answers_file = answers_dir / f"trial_{tid}_answers.json" with open(answers_file, "w") as f: @@ -290,7 +293,7 @@ def run(dataset_name: str, max_questions: int, n_trials: int, output_dir: Union[ cs, deterministic=True, n_trials=n_trials, - walltime_limit=7200, + walltime_limit=172800, #7200, seed=42, output_directory=out / "smac_output", ) diff --git a/learn2rag/pipeline/ingestion.py b/learn2rag/pipeline/ingestion.py index 35b2f4d..7dea721 100644 --- a/learn2rag/pipeline/ingestion.py +++ b/learn2rag/pipeline/ingestion.py @@ -6,6 +6,8 @@ import numpy as np import warnings from collections.abc import Iterator +from collections import deque +from time import perf_counter from langchain.text_splitter import RecursiveCharacterTextSplitter from langchain_core.documents import Document @@ -15,6 +17,13 @@ from .embeddings import create_embeddings +def _format_hhmmss(total_seconds: float) -> str: + seconds = max(0, int(total_seconds)) + hours, remainder = divmod(seconds, 3600) + minutes, secs = divmod(remainder, 60) + return f"{hours:02d}:{minutes:02d}:{secs:02d}" + + def get_chunks_metadata(chunks: list[Document], item: str) -> Iterator[str]: missing = 0 for chunk in chunks: @@ -136,8 +145,16 @@ def ingest_batch(docs: list[Document], qdrant: Qdrant, user_config: dict[str, An chunks = text_splitter.split_documents(docs) ingestion_batch_size = opt_config["ingestion_batch_size"] + total_batches = (len(chunks) + ingestion_batch_size - 1) // ingestion_batch_size + eta_window_size = 100 + report_every = 100 + recent_batch_durations: deque[float] = deque(maxlen=eta_window_size) + ingest_start = perf_counter() + logging.info('Creating embeddings and ingesting in batches...') - for batch_start in range(0, len(chunks), ingestion_batch_size): + + for batch_idx, batch_start in enumerate(range(0, len(chunks), ingestion_batch_size), start=1): + batch_started_at = perf_counter() batch_chunks = chunks[batch_start:batch_start + ingestion_batch_size] batch_content = [chunk.page_content for chunk in batch_chunks] batch_chunk_hash = [hashlib.md5(chunk.page_content.encode()).hexdigest() for chunk in batch_chunks] @@ -225,7 +242,34 @@ def ingest_batch(docs: list[Document], qdrant: Qdrant, user_config: dict[str, An else: insert(qdrant, collection_name, sample) + batch_duration = perf_counter() - batch_started_at + recent_batch_durations.append(batch_duration) + + if batch_idx % report_every == 0: + elapsed = perf_counter() - ingest_start + avg_batch_duration = sum(recent_batch_durations) / len(recent_batch_durations) + remaining_batches = total_batches - batch_idx + eta_seconds = avg_batch_duration * remaining_batches + progress_percent = (batch_idx / total_batches) * 100 if total_batches > 0 else 100.0 + + logging.info( + "Ingestion progress: %d/%d batches (%.2f%%), elapsed=%s, eta in %s", + batch_idx, + total_batches, + progress_percent, + _format_hhmmss(elapsed), + _format_hhmmss(eta_seconds), + ) + + total_elapsed = perf_counter() - ingest_start + logging.info( + "Ingestion finished: %d/%d batches (100.00%%), total_elapsed=%s", + total_batches, + total_batches, + _format_hhmmss(total_elapsed), + ) + def index(documents: list[Document], user_config: dict[str, Any], opt_config: dict[str, Any]) -> None: """ Ingest a list of documents — entry point for standalone pipeline operation. diff --git a/learn2rag/pipeline/search.py b/learn2rag/pipeline/search.py index efdf857..617eba7 100644 --- a/learn2rag/pipeline/search.py +++ b/learn2rag/pipeline/search.py @@ -138,7 +138,7 @@ def _rerank_points_with_colbert( query=colbert_query, # type: ignore[arg-type] using="colbert", limit=top_k, - timeout=100 + timeout=120 ) return list(results.points) @@ -253,7 +253,8 @@ def _collect_query_points( top_k=opt_config["top_k_reranker"], opt_config=opt_config ) - + else: + points = points[:opt_config["top_k"]] return points @@ -319,7 +320,7 @@ def search(query: str, user_config: dict[str, Any], opt_config: dict[str, Any], query=query_embedding, # type: ignore[arg-type, unused-ignore] using="dense", limit=opt_config["top_k"], - timeout=100 + timeout=120 ) elif opt_config["search_mode"] == "sparse": indices = [int(k) for k in query_embedding["lexical_weights"].keys()] # type: ignore[union-attr] @@ -329,7 +330,7 @@ def search(query: str, user_config: dict[str, Any], opt_config: dict[str, Any], query=models.SparseVector(indices=indices, values=values), using="sparse", limit=opt_config["top_k"], - timeout=100 + timeout=120 ) elif opt_config["search_mode"] == "dense_sparse": indices = [int(k) for k in query_embedding["lexical_weights"].keys()] # type: ignore[union-attr] @@ -350,7 +351,7 @@ def search(query: str, user_config: dict[str, Any], opt_config: dict[str, Any], ], query=models.FusionQuery(fusion=fusion_mode), limit=opt_config["top_k"], - timeout=100 + timeout=120 ) elif opt_config["search_mode"] == "dense_sparse_colbert": @@ -377,7 +378,7 @@ def search(query: str, user_config: dict[str, Any], opt_config: dict[str, Any], ], query=models.FusionQuery(fusion=fusion_mode), limit=opt_config["top_k"], - timeout=100 + timeout=120 ) elif opt_config["search_mode"] == "multi_search": @@ -386,7 +387,7 @@ def search(query: str, user_config: dict[str, Any], opt_config: dict[str, Any], query=query_embedding, # type: ignore[arg-type, unused-ignore] using="multi", limit=opt_config["top_k"], - timeout=100 + timeout=120 ) return results @@ -421,7 +422,7 @@ def search_multi(multi_query: dict[str, str], user_config: dict[str, Any], opt_c query=query_embedding, # type: ignore[arg-type, unused-ignore] using="multi", limit=opt_config["top_k"], - timeout=100 + timeout=120 ) profilingLogger.info('end', extra={'activity': 'search', 'request_id': request_id}) return results From d618c0b1421f149e967d8e082a8161225e98a4c0 Mon Sep 17 00:00:00 2001 From: Hanna Reder Date: Thu, 11 Jun 2026 08:30:09 +0000 Subject: [PATCH 19/47] add resume mechanism for retrieval optimisation --- .../optimization/retrieval_optimization.py | 179 +++++++++++++++--- 1 file changed, 153 insertions(+), 26 deletions(-) diff --git a/learn2rag/optimization/retrieval_optimization.py b/learn2rag/optimization/retrieval_optimization.py index 57fd69c..d456a7c 100644 --- a/learn2rag/optimization/retrieval_optimization.py +++ b/learn2rag/optimization/retrieval_optimization.py @@ -1,6 +1,9 @@ """ RAG Retrieval Optimization. """ +import os +os.environ["CUDA_DEVICE_ORDER"]="PCI_BUS_ID" +os.environ["CUDA_VISIBLE_DEVICES"]="0" #Select GPU number 0 import argparse import json @@ -40,6 +43,80 @@ def load_registry(path: str = "registry.json") -> dict[str, Any]: with p.open() as f: return cast(dict[str, Any], json.load(f)) + +def _load_existing_trial_answers(answers_dir: pathlib.Path) -> list[dict[str, Any]]: + if not answers_dir.exists(): + return [] + trials: list[dict[str, Any]] = [] + for p in sorted(answers_dir.glob("trial_*_answers.json")): + try: + data = json.loads(p.read_text()) + if isinstance(data, dict) and "trial_id" in data: + trials.append(data) + except Exception as e: + logging.warning(f"Could not read {p}: {e}") + return trials + + +def _restore_state_from_existing(out: pathlib.Path, answers_dir: pathlib.Path) -> Dict[str, Any]: + state: Dict[str, Any] = {"trial_count": 0, "best_cost": 1.0, "convergence": [], "history": []} + + results_path = out / "optimization_results.json" + if results_path.exists(): + try: + results = json.loads(results_path.read_text()) + history = results.get("run_history", []) + convergence = results.get("convergence", []) + if isinstance(history, list) and history: + state["history"] = history + state["convergence"] = convergence if isinstance(convergence, list) else [] + state["trial_count"] = max(int(h.get("trial_id", 0)) for h in history) + state["best_cost"] = min(float(h.get("cost", 1.0)) for h in history) + return state + except Exception as e: + logging.warning(f"Could not read {results_path}: {e}") + + trials = _load_existing_trial_answers(answers_dir) + if not trials: + return state + + best_cost = 1.0 + history: list[dict[str, Any]] = [] + convergence: list[dict[str, Any]] = [] + for trial in sorted(trials, key=lambda t: int(t.get("trial_id", 0))): + tid = int(trial.get("trial_id", 0)) + cost = float(trial.get("cost", 1.0)) + best_cost = min(best_cost, cost) + history.append({ + "trial_id": tid, + "config": trial.get("config", {}), + "recall": float(trial.get("recall", 0.0)), + "avg_t_search": float(trial.get("avg_t_search", 0.0)), + "cost": cost, + "time_s": None, + "search_s": None, + "scoring_s": None, + }) + convergence.append({"trial": tid, "cost": cost, "best_cost": best_cost}) + + state["history"] = history + state["convergence"] = convergence + state["trial_count"] = max(int(t.get("trial_id", 0)) for t in trials) + state["best_cost"] = best_cost + return state + + +def _load_existing_importance(out: pathlib.Path) -> Dict[str, Any]: + path = out / "parameter_importance.json" + if not path.exists(): + return {} + try: + data = json.loads(path.read_text()) + return data if isinstance(data, dict) else {} + except Exception as e: + logging.warning(f"Could not read {path}: {e}") + return {} + def run_search(question: str, user_config: Dict[str, Any], working_config: Dict[str, Any]) -> Tuple[List[Any], float]: t0 = time.time() docs = asyncio.run(learn2rag.pipeline.search.search_authorized(question, user="anonymous", request_id=None, user_config=user_config, opt_config=working_config)) @@ -128,7 +205,7 @@ def objective(config: Configuration, logging.warning(f"Trial {tid}, q{q.get('id','?')} failed: {e}") predictions.append([]) goldens.append(q["ground_truth"]) - qa_pairs.append({**q, "generated_answer": "", "retrieved_context": ""}) + qa_pairs.append({**q, "retrieved_sources": ""}) if not predictions: return 1.0 @@ -139,8 +216,8 @@ def objective(config: Configuration, total_time = time.time() - t_start # objective function - w_recall = 1 - w_time = 0 + w_recall = 0.5 + w_time = 0.5 t_search_per_sample_upper = 50 max_time_s = t_search_per_sample_upper*len(predictions) time_cost = max(0.0, 1.0 - (t_search / max_time_s)) @@ -159,6 +236,12 @@ def objective(config: Configuration, "qa_pairs": qa_pairs } answers_file = answers_dir / f"trial_{tid}_answers.json" + while answers_file.exists(): + # Keep IDs monotonic when resuming from a partially persisted run. + tid += 1 + state["trial_count"] = tid + trial_answers["trial_id"] = tid + answers_file = answers_dir / f"trial_{tid}_answers.json" with open(answers_file, "w") as f: json.dump(trial_answers, f, indent=2, default=str) @@ -207,7 +290,15 @@ def param_importance(smac: HyperparameterOptimizationFacade, output_path: pathli return result -def run(dataset_name: str, max_questions: int, n_trials: int, output_dir: Union[str, pathlib.Path], registry_path:str) -> Tuple[ +def run( + dataset_name: str, + max_questions: int, + n_trials: int, + output_dir: Union[str, pathlib.Path], + registry_path: str, + resume: bool = False, + n_trials_is_total: bool = True, +) -> Tuple[ Dict[str, Any], List[Any], Dict[str, Any]]: registry = load_registry(registry_path) datasets = registry["datasets"] @@ -289,27 +380,49 @@ def run(dataset_name: str, max_questions: int, n_trials: int, output_dir: Union[ )) - scenario = Scenario( - cs, - deterministic=True, - n_trials=n_trials, - walltime_limit=172800, #7200, - seed=42, - output_directory=out / "smac_output", - ) - state: Dict[str, Any] = {"trial_count": 0, "best_cost": 1.0, "convergence": [], "history": []} + state: Dict[str, Any] + if resume: + state = _restore_state_from_existing(out, answers_dir) + else: + state = {"trial_count": 0, "best_cost": 1.0, "convergence": [], "history": []} + + already_done = int(state["trial_count"]) + remaining_trials = max(0, n_trials - already_done) if n_trials_is_total else n_trials + + best_cfg: Dict[str, Any] = {} + importance: Dict[str, Any] = {} + total_time = 0.0 + + if remaining_trials > 0: + scenario = Scenario( + cs, + deterministic=True, + n_trials=remaining_trials, + walltime_limit=172800, #7200, + seed=42, + output_directory=out / "smac_output", + ) + + smac = HyperparameterOptimizationFacade( + scenario=scenario, + target_function=lambda config, seed=0: objective(config, questions, state, answers_dir) + ) + t0 = time.time() + incumbent = smac.optimize() + if isinstance(incumbent, list): + incumbent = incumbent[0] + importance = param_importance(smac, out) + total_time = time.time() - t0 + best_cfg = incumbent.get_dictionary() + else: + logging.info("No remaining trials to run. Returning existing results.") + if state["history"]: + best_cfg = min(state["history"], key=lambda h: h["cost"]).get("config", {}) + importance = _load_existing_importance(out) + + if not best_cfg and state["history"]: + best_cfg = min(state["history"], key=lambda h: h["cost"]).get("config", {}) - smac = HyperparameterOptimizationFacade( - scenario=scenario, - target_function=lambda config, seed=0: objective(config, questions, state, answers_dir) - ) - t0 = time.time() - incumbent = smac.optimize() - if isinstance(incumbent, list): - incumbent = incumbent[0] - importance = param_importance(smac, out) - total_time = time.time() - t0 - best_cfg = incumbent.get_dictionary() best_trial = min( (h for h in state["history"] if h.get("config") == best_cfg), key=lambda h: h["cost"], @@ -340,6 +453,12 @@ def run(dataset_name: str, max_questions: int, n_trials: int, output_dir: Union[ parser.add_argument("--logging-config", type=str) parser.add_argument("--registry", type=str, default="registry.json") parser.add_argument("--output_dir", type=str, default="optimization_results_baseline") + parser.add_argument("--resume", action="store_true") + parser.add_argument( + "--n_trials_is_total", + action="store_true", + help="Interpret --n_trials as the total desired trial count instead of additional trials.", + ) args, _ = parser.parse_known_args() final_output_dir = pathlib.Path(args.output_dir) @@ -348,13 +467,21 @@ def run(dataset_name: str, max_questions: int, n_trials: int, output_dir: Union[ if not final_output_dir.exists() and env_out: final_output_dir = pathlib.Path(env_out).parent - incumbent, history, importance = run(args.dataset, args.max_questions, args.n_trials, final_output_dir, args.registry) + incumbent, history, importance = run( + args.dataset, + args.max_questions, + args.n_trials, + final_output_dir, + args.registry, + resume=args.resume, + n_trials_is_total=(args.n_trials_is_total or args.resume), + ) # incumbent, history, importance = run( # args.dataset, args.max_questions, args.n_trials, args.output_dir, # ) - best = min(history, key=lambda x: x["cost"]) + best = min(history, key=lambda x: x["cost"]) if history else None print(f"\nBest config: {dict(incumbent)}") # print(f"BERTScore (golden): {best['avg_bertscore_golden']:.4f}") if importance: From 5cf3c753b7e5fbedfa57be7a7a760c0011a6139d Mon Sep 17 00:00:00 2001 From: farshad68 Date: Thu, 11 Jun 2026 15:18:20 +0200 Subject: [PATCH 20/47] add type to function --- learn2rag/optimization/__init__.py | 4 ++- .../optimization/baseline_optimization.py | 36 +++++++++++-------- learn2rag/optimization/registry.json | 18 ++++++++++ learn2rag/pipeline/generate.py | 10 ++++-- .../compose/pipelines/optimization.yml | 2 ++ pyproject.toml | 6 +++- 6 files changed, 57 insertions(+), 19 deletions(-) create mode 100644 learn2rag/optimization/registry.json diff --git a/learn2rag/optimization/__init__.py b/learn2rag/optimization/__init__.py index 86410e8..8bad4b0 100644 --- a/learn2rag/optimization/__init__.py +++ b/learn2rag/optimization/__init__.py @@ -6,6 +6,8 @@ import copy import yaml import argparse +from typing import Any +from collections.abc import Mapping from . import baseline_optimization #TODO : now we need to copy the dataset to here manually it should consider in installation maybe ! @@ -66,7 +68,7 @@ def main() -> None: logging.info(f"Successfully updated opt_config at: {target_config_path}") -def deep_update(source, overrides): +def deep_update(source: dict[str, Any], overrides:Mapping[str, Any]) -> dict[str, Any]: """Recursively updates a dictionary.""" for key, value in overrides.items(): if isinstance(value, collections.abc.Mapping) and key in source: diff --git a/learn2rag/optimization/baseline_optimization.py b/learn2rag/optimization/baseline_optimization.py index be02a12..a2e9b60 100644 --- a/learn2rag/optimization/baseline_optimization.py +++ b/learn2rag/optimization/baseline_optimization.py @@ -9,10 +9,10 @@ import time import copy import os -from typing import Dict, Any, List, Union, Tuple - +from typing import Dict, Any, List, Union, Tuple, cast +from qdrant_client.models import ScoredPoint import numpy as np -from bert_score import score as bert_score +from bert_score import score as bert_score # type: ignore from ConfigSpace import ConfigurationSpace, Integer, Categorical, ForbiddenGreaterThanRelation, Configuration from smac import HyperparameterOptimizationFacade, Scenario @@ -21,12 +21,12 @@ import learn2rag.pipeline.search import learn2rag.pipeline.generate -def load_registry(path: str = "registry.json") -> dict: +def load_registry(path: str = "registry.json") -> dict[str, Any]: p = pathlib.Path(path) if not p.is_file(): logging.error("registry file not found") with p.open() as f: - return json.load(f) + return cast(Dict[str, Any], json.load(f)) def run_pipeline(question: str, user_config: Dict[str, Any], working_config: Dict[str, Any]) -> Tuple[str, str, float, float]: t0 = time.time() @@ -34,16 +34,19 @@ def run_pipeline(question: str, user_config: Dict[str, Any], working_config: Dic search_time = time.time() - t0 t0 = time.time() - answer = learn2rag.pipeline.generate.generate(question, docs, working_config) + answer = learn2rag.pipeline.generate.generate(question, docs.points, working_config) gen_time = time.time() - t0 doc_list = docs.points if hasattr(docs, "points") else docs context = "" if doc_list: - context = "\n\n".join([ - f"Source: {d.payload.get('path', 'unknown')}\nContent: {d.payload.get('content', '')}" - for d in doc_list - ]) + context_parts = [] + for d in doc_list: + payload = getattr(d, "payload", {}) or {} + path = payload.get("path", "unknown") if isinstance(payload, dict) else "unknown" + content = payload.get("content", "") if isinstance(payload, dict) else "" + context_parts.append(f"Source: {path}\nContent: {content}") + context = "\n\n".join(context_parts) return answer, context[:3000], search_time, gen_time #I removed seed because there are no use for it @@ -53,7 +56,7 @@ def objective(config: Configuration, dataset_name: str, state: Dict[str, Any], answers_dir: pathlib.Path - ,prompt_map + ,prompt_map: Dict[str, Any] ) -> float: state["trial_count"] += 1 tid = state["trial_count"] @@ -153,7 +156,7 @@ def param_importance(smac: HyperparameterOptimizationFacade, output_path: pathli raw = {} for p in params: - groups = {} + groups : Dict[str, List[float]] = {} for c, cost in zip(configs, np.array(costs)): groups.setdefault(str(c[p]), []).append(cost) means = [np.mean(g) for g in groups.values()] @@ -161,7 +164,7 @@ def param_importance(smac: HyperparameterOptimizationFacade, output_path: pathli total = sum(raw.values()) imp = {p: round(v / total, 4) for p, v in raw.items()} if total > 0 else raw - ranking = sorted(imp, key=imp.get, reverse=True) + ranking = sorted(imp, key=lambda k: imp[k], reverse=True) result = {"method": "variance_based", "ranking": ranking, "individual": imp} with open(output_path / "parameter_importance.json", "w") as f: json.dump(result, f, indent=2) @@ -170,6 +173,7 @@ def param_importance(smac: HyperparameterOptimizationFacade, output_path: pathli def run(dataset_name: str, max_questions: int, n_trials: int, output_dir: Union[str, pathlib.Path],registry_path:str) -> Tuple[ Dict[str, Any], List[Any], Dict[str, Any]]: + logging.info(f"registry_path is : {registry_path}") registry = load_registry(registry_path) datasets = registry["datasets"] if dataset_name not in datasets: @@ -220,9 +224,13 @@ def run(dataset_name: str, max_questions: int, n_trials: int, output_dir: Union[ ) t0 = time.time() incumbent = smac.optimize() + if isinstance(incumbent, list): + best_cfg = incumbent[0].get_dictionary() + else: + best_cfg = incumbent.get_dictionary() importance = param_importance(smac, out) total_time = time.time() - t0 - best_cfg = incumbent.get_dictionary() + #best_cfg = incumbent.get_dictionary() results_path = out / "optimization_results.json" results_path.write_text(json.dumps({ "best_config": best_cfg, diff --git a/learn2rag/optimization/registry.json b/learn2rag/optimization/registry.json new file mode 100644 index 0000000..941c261 --- /dev/null +++ b/learn2rag/optimization/registry.json @@ -0,0 +1,18 @@ +{ + "datasets": { + "WikiEval": { + "subdirectory": "", "split": "train", + "fields": {"q": "question", "a": "answer", "id": "id"} + } + }, + "prompts": { + "default": + "# Role and Objective\nYou will act as a smart AI chatbot that answers questions only by using the content from the provided information list.\n\n # Instructions\n- Respond in the language of the question.\n - Answer clear and concise.\n- Only use the provided information.\n - NEVER use your general knowledge.\n\n # Information:\n{context}" + , + "concise": + "Answer the question using ONLY the provided information. Be concise and direct. If the information does not contain the answer, say so.\n\n Information:\n{context}" + , + "detailed": + "You are a knowledgeable assistant. Using ONLY the provided information below, answer the question thoroughly. Cite your sources. If the information is insufficient, state that clearly.\n\n Information:\n{context}" + } +} \ No newline at end of file diff --git a/learn2rag/pipeline/generate.py b/learn2rag/pipeline/generate.py index 64e3efc..c088ef5 100644 --- a/learn2rag/pipeline/generate.py +++ b/learn2rag/pipeline/generate.py @@ -1,6 +1,7 @@ -from typing import Any, Generator +from typing import Any, Generator, Sequence import logging from langchain.prompts import SystemMessagePromptTemplate, HumanMessagePromptTemplate, ChatPromptTemplate + from qdrant_client.http.models import ScoredPoint from .llm import llm @@ -14,11 +15,14 @@ {content} """ -def generate(query: str, search_results: list[ScoredPoint], opt_config: dict[str, Any]) -> Any: +def generate(query: str, search_results: Sequence[ScoredPoint], opt_config: dict[str, Any]) -> Any: assert llm is not None if hasattr(search_results, "points"): search_results = search_results.points - context = "\n\n".join([context_template.format(source=result.payload['path'], content=result.payload['content']) for result in search_results]) # type: ignore[index] + context = "\n\n".join([ + context_template.format(source=result.payload['path'], content=result.payload['content']) + for result in search_results if result.payload + ]) system_message = SystemMessagePromptTemplate.from_template(opt_config["prompt"]) user_message = HumanMessagePromptTemplate.from_template("{question}") prompt = ChatPromptTemplate.from_messages([system_message, user_message]) diff --git a/learn2rag/ui/templates/compose/pipelines/optimization.yml b/learn2rag/ui/templates/compose/pipelines/optimization.yml index c721f88..c368649 100644 --- a/learn2rag/ui/templates/compose/pipelines/optimization.yml +++ b/learn2rag/ui/templates/compose/pipelines/optimization.yml @@ -99,6 +99,8 @@ services: - 'learn2rag.optimization' - '--logging-config' - '{{storage_path}}/logging_config.yml' + - '--registry-path' + - '{{learn2rag_path}}/learn2rag/optimization/registry.json' environment: LEARN2RAG_PATH: '{{learn2rag_path}}' QDRANT__SERVICE__HTTP_PORT: '{{ports.qdrant_http}}' diff --git a/pyproject.toml b/pyproject.toml index e53ed41..a0adc3e 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -208,7 +208,11 @@ build-backend = "setuptools.build_meta" requires = ["setuptools >= 77.0.3"] [tool.mypy] files = "learn2rag" -exclude = "^learn2rag/pipeline/scripts/" +exclude = ["^learn2rag/pipeline/scripts/", + "^learn2rag/optimization/contrastive_optimization.py", +"generate_contrastive_answers.py", +"self_judge_optimization.py", +"tool_read_data_set.py"] strict = true [[tool.mypy.overrides]] module = [ From 3bab6bcaf77de41d0d8cd6a8811650242d72a269 Mon Sep 17 00:00:00 2001 From: farshad68 Date: Fri, 12 Jun 2026 11:29:48 +0200 Subject: [PATCH 21/47] set api_key with mock value for test --- learn2rag/tests/test_learn2rag.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/learn2rag/tests/test_learn2rag.py b/learn2rag/tests/test_learn2rag.py index 095de51..d51719d 100644 --- a/learn2rag/tests/test_learn2rag.py +++ b/learn2rag/tests/test_learn2rag.py @@ -24,7 +24,7 @@ def setUp(self) -> None: self.storage_path = Path(save_data_path('Learn2RAG', 'tests')) self.storage_path.mkdir(parents=True, exist_ok=True) self.openai_client = OpenAI( - api_key='', + api_key='mock-key', base_url=f'http://localhost:{self.rag_port}', max_retries=0, ) From 478671505b4efb4785b28a892e855cb3247a8c90 Mon Sep 17 00:00:00 2001 From: farshad68 Date: Fri, 12 Jun 2026 14:12:39 +0200 Subject: [PATCH 22/47] remove chunk_size and chunk_overlap because optimizing them with out reindex is not functional --- learn2rag/optimization/baseline_optimization.py | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/learn2rag/optimization/baseline_optimization.py b/learn2rag/optimization/baseline_optimization.py index a2e9b60..ac0b669 100644 --- a/learn2rag/optimization/baseline_optimization.py +++ b/learn2rag/optimization/baseline_optimization.py @@ -66,8 +66,8 @@ def objective(config: Configuration, working_cfg = copy.deepcopy(opt_config) working_cfg.update({ "top_k": cfg["top_k"], - "chunk_size": cfg["chunk_size"], - "chunk_overlap": cfg["chunk_overlap"], + # "chunk_size": cfg["chunk_size"], + # "chunk_overlap": cfg["chunk_overlap"], "prompt": prompt_map[cfg["prompt_template"]], }) @@ -203,11 +203,11 @@ def run(dataset_name: str, max_questions: int, n_trials: int, output_dir: Union[ cs = ConfigurationSpace(seed=42) cs.add([ Integer("top_k", (1, 20), default=4), - Integer("chunk_size", (200, 4000), default=2000), - Integer("chunk_overlap", (0, 500), default=200), + #Integer("chunk_size", (200, 4000), default=2000), + #Integer("chunk_overlap", (0, 500), default=200), Categorical("prompt_template", list(prompt_map.keys()), default="default"), ]) - cs.add(ForbiddenGreaterThanRelation(cs["chunk_overlap"], cs["chunk_size"])) + #cs.add(ForbiddenGreaterThanRelation(cs["chunk_overlap"], cs["chunk_size"])) scenario = Scenario( cs, deterministic=True, From 8a351dec4a020c2771242d109f9ae1237aa9a11c Mon Sep 17 00:00:00 2001 From: Hanna Reder Date: Fri, 12 Jun 2026 15:01:53 +0000 Subject: [PATCH 23/47] fix Ollama timeout and colbert reranking issues --- .../optimization/retrieval_optimization.py | 215 +++++++++++++++++- learn2rag/pipeline/llm.py | 21 ++ learn2rag/pipeline/rewrite.py | 99 ++++++-- learn2rag/pipeline/search.py | 44 +++- 4 files changed, 347 insertions(+), 32 deletions(-) diff --git a/learn2rag/optimization/retrieval_optimization.py b/learn2rag/optimization/retrieval_optimization.py index d456a7c..f7f1b13 100644 --- a/learn2rag/optimization/retrieval_optimization.py +++ b/learn2rag/optimization/retrieval_optimization.py @@ -6,6 +6,7 @@ os.environ["CUDA_VISIBLE_DEVICES"]="0" #Select GPU number 0 import argparse +import datetime import json import logging import pathlib @@ -13,6 +14,8 @@ import copy import os import asyncio +import subprocess +import sys from typing import Dict, Any, List, Union, Tuple, cast import numpy as np @@ -61,6 +64,13 @@ def _load_existing_trial_answers(answers_dir: pathlib.Path) -> list[dict[str, An def _restore_state_from_existing(out: pathlib.Path, answers_dir: pathlib.Path) -> Dict[str, Any]: state: Dict[str, Any] = {"trial_count": 0, "best_cost": 1.0, "convergence": [], "history": []} + trial_answers = _load_existing_trial_answers(answers_dir) + answers_by_id = { + int(t.get("trial_id", 0)): t + for t in trial_answers + if isinstance(t, dict) and t.get("trial_id") is not None + } + results_path = out / "optimization_results.json" if results_path.exists(): try: @@ -68,15 +78,45 @@ def _restore_state_from_existing(out: pathlib.Path, answers_dir: pathlib.Path) - history = results.get("run_history", []) convergence = results.get("convergence", []) if isinstance(history, list) and history: - state["history"] = history - state["convergence"] = convergence if isinstance(convergence, list) else [] - state["trial_count"] = max(int(h.get("trial_id", 0)) for h in history) - state["best_cost"] = min(float(h.get("cost", 1.0)) for h in history) + merged_history: dict[int, dict[str, Any]] = { + int(h.get("trial_id", 0)): dict(h) + for h in history + if isinstance(h, dict) and h.get("trial_id") is not None + } + + for tid, trial in answers_by_id.items(): + previous = merged_history.get(tid, {}) + merged_history[tid] = { + "trial_id": tid, + "config": trial.get("config", previous.get("config", {})), + "recall": float(trial.get("recall") or previous.get("recall") or 0.0), + "avg_t_search": float(trial.get("avg_t_search") or previous.get("avg_t_search") or 0.0), + "cost": float(trial.get("cost") or previous.get("cost") or 1.0), + "time_s": previous.get("time_s"), + "search_s": previous.get("search_s"), + "scoring_s": previous.get("scoring_s"), + } + + merged_list = [merged_history[tid] for tid in sorted(merged_history)] + best_cost = 1.0 + rebuilt_convergence: list[dict[str, Any]] = [] + for entry in merged_list: + best_cost = min(best_cost, float(entry.get("cost", 1.0))) + rebuilt_convergence.append({ + "trial": int(entry.get("trial_id", 0)), + "cost": float(entry.get("cost", 1.0)), + "best_cost": best_cost, + }) + + state["history"] = merged_list + state["convergence"] = rebuilt_convergence if not isinstance(convergence, list) or len(rebuilt_convergence) != len(convergence) else convergence + state["trial_count"] = max(int(h.get("trial_id", 0)) for h in merged_list) + state["best_cost"] = best_cost return state except Exception as e: logging.warning(f"Could not read {results_path}: {e}") - trials = _load_existing_trial_answers(answers_dir) + trials = trial_answers if not trials: return state @@ -117,7 +157,155 @@ def _load_existing_importance(out: pathlib.Path) -> Dict[str, Any]: logging.warning(f"Could not read {path}: {e}") return {} + +def _find_latest_optimization_file(smac_output_dir: pathlib.Path) -> Union[pathlib.Path, None]: + if not smac_output_dir.exists(): + return None + candidates = list(smac_output_dir.rglob("optimization.json")) + if not candidates: + return None + return max(candidates, key=lambda p: p.stat().st_mtime) + + +def _parse_last_update(value: Any) -> Union[float, None]: + if isinstance(value, (int, float)): + return float(value) + if isinstance(value, str): + try: + # Handle ISO values like 2026-06-11T12:34:56.123456+00:00 or trailing Z. + dt = datetime.datetime.fromisoformat(value.replace("Z", "+00:00")) + return dt.timestamp() + except ValueError: + return None + return None + + +def _last_update_age_seconds(smac_output_dir: pathlib.Path) -> Union[float, None]: + optimization_file = _find_latest_optimization_file(smac_output_dir) + if optimization_file is None: + return None + try: + data = json.loads(optimization_file.read_text()) + except Exception as e: + logging.warning(f"Could not read {optimization_file}: {e}") + return None + ts = _parse_last_update(data.get("last_update")) if isinstance(data, dict) else None + if ts is None: + return None + return max(0.0, time.time() - ts) + + +def _run_search_heartbeat_age_seconds(heartbeat_file: pathlib.Path) -> Union[float, None]: + if not heartbeat_file.exists(): + return None + try: + return max(0.0, time.time() - heartbeat_file.stat().st_mtime) + except OSError as e: + logging.warning(f"Could not stat {heartbeat_file}: {e}") + return None + + +def _touch_run_search_heartbeat() -> None: + heartbeat_path = os.environ.get("L2R_RUN_SEARCH_HEARTBEAT_FILE") + if not heartbeat_path: + return + try: + p = pathlib.Path(heartbeat_path) + p.parent.mkdir(parents=True, exist_ok=True) + p.touch() + except Exception as e: + logging.warning(f"Could not update run_search heartbeat at {heartbeat_path}: {e}") + + +def _build_worker_command(args: argparse.Namespace, final_output_dir: pathlib.Path) -> List[str]: + cmd = [ + sys.executable, + "-m", + "learn2rag.optimization.retrieval_optimization", + "--dataset", args.dataset, + "--max_questions", str(args.max_questions), + "--n_trials", str(args.n_trials), + "--registry", args.registry, + "--output_dir", str(final_output_dir), + "--resume", + ] + if args.n_trials_is_total or args.resume: + cmd.append("--n_trials_is_total") + if args.logging_config: + cmd.extend(["--logging-config", args.logging_config]) + return cmd + + +def run_with_watchdog(args: argparse.Namespace, final_output_dir: pathlib.Path) -> int: + stale_after_s = max(1, args.watchdog_stale_minutes * 60) + run_search_stale_after_s = max(1, args.watchdog_run_search_stale_minutes * 60) + restart_wait_s = max(1, args.watchdog_restart_delay_minutes * 60) + poll_s = max(5, args.watchdog_poll_seconds) + + dataset_out = final_output_dir / args.dataset + smac_output_dir = dataset_out / "smac_output" + run_search_heartbeat_file = dataset_out / "run_search_heartbeat.txt" + worker_cmd = _build_worker_command(args, final_output_dir) + + restart_count = 0 + while True: + logging.info(f"Starting optimization worker (restart #{restart_count})") + try: + run_search_heartbeat_file.unlink(missing_ok=True) + except OSError as e: + logging.warning(f"Could not reset heartbeat file {run_search_heartbeat_file}: {e}") + + worker_env = os.environ.copy() + worker_env["L2R_RUN_SEARCH_HEARTBEAT_FILE"] = str(run_search_heartbeat_file) + proc = subprocess.Popen(worker_cmd, env=worker_env) + stale_detected = False + + while proc.poll() is None: + time.sleep(poll_s) + age = _last_update_age_seconds(smac_output_dir) + if age is not None and age > stale_after_s: + stale_detected = True + logging.warning( + f"Detected stale optimization.json update (age={age:.0f}s > {stale_after_s}s). " + "Terminating worker for restart." + ) + proc.terminate() + try: + proc.wait(timeout=30) + except subprocess.TimeoutExpired: + proc.kill() + proc.wait() + break + + run_search_age = _run_search_heartbeat_age_seconds(run_search_heartbeat_file) + if run_search_age is not None and run_search_age > run_search_stale_after_s: + stale_detected = True + logging.warning( + f"Detected stale run_search heartbeat (age={run_search_age:.0f}s > {run_search_stale_after_s}s). " + "Terminating worker for restart." + ) + proc.terminate() + try: + proc.wait(timeout=30) + except subprocess.TimeoutExpired: + proc.kill() + proc.wait() + break + + if not stale_detected: + return_code = proc.returncode if proc.returncode is not None else 1 + if return_code == 0: + logging.info("Optimization worker finished successfully.") + else: + logging.error(f"Optimization worker exited with return code {return_code}.") + return return_code + + restart_count += 1 + logging.info(f"Sleeping {restart_wait_s}s before resuming optimization.") + time.sleep(restart_wait_s) + def run_search(question: str, user_config: Dict[str, Any], working_config: Dict[str, Any]) -> Tuple[List[Any], float]: + _touch_run_search_heartbeat() t0 = time.time() docs = asyncio.run(learn2rag.pipeline.search.search_authorized(question, user="anonymous", request_id=None, user_config=user_config, opt_config=working_config)) search_time = time.time() - t0 @@ -387,7 +575,8 @@ def run( state = {"trial_count": 0, "best_cost": 1.0, "convergence": [], "history": []} already_done = int(state["trial_count"]) - remaining_trials = max(0, n_trials - already_done) if n_trials_is_total else n_trials + target_trials = max(already_done, n_trials) if n_trials_is_total else already_done + n_trials + remaining_trials = max(0, target_trials - already_done) best_cfg: Dict[str, Any] = {} importance: Dict[str, Any] = {} @@ -397,7 +586,7 @@ def run( scenario = Scenario( cs, deterministic=True, - n_trials=remaining_trials, + n_trials=target_trials, walltime_limit=172800, #7200, seed=42, output_directory=out / "smac_output", @@ -407,13 +596,14 @@ def run( scenario=scenario, target_function=lambda config, seed=0: objective(config, questions, state, answers_dir) ) + t0 = time.time() incumbent = smac.optimize() if isinstance(incumbent, list): incumbent = incumbent[0] importance = param_importance(smac, out) total_time = time.time() - t0 - best_cfg = incumbent.get_dictionary() + best_cfg = dict(incumbent) else: logging.info("No remaining trials to run. Returning existing results.") if state["history"]: @@ -459,6 +649,11 @@ def run( action="store_true", help="Interpret --n_trials as the total desired trial count instead of additional trials.", ) + parser.add_argument("--watchdog", action="store_true", help="Restart optimization if SMAC last_update is stale.") + parser.add_argument("--watchdog_stale_minutes", type=int, default=90) + parser.add_argument("--watchdog_run_search_stale_minutes", type=int, default=7) + parser.add_argument("--watchdog_restart_delay_minutes", type=int, default=5) + parser.add_argument("--watchdog_poll_seconds", type=int, default=60) args, _ = parser.parse_known_args() final_output_dir = pathlib.Path(args.output_dir) @@ -467,6 +662,10 @@ def run( if not final_output_dir.exists() and env_out: final_output_dir = pathlib.Path(env_out).parent + if args.watchdog: + exit_code = run_with_watchdog(args, final_output_dir) + raise SystemExit(exit_code) + incumbent, history, importance = run( args.dataset, args.max_questions, diff --git a/learn2rag/pipeline/llm.py b/learn2rag/pipeline/llm.py index 18cc061..5f0db5f 100644 --- a/learn2rag/pipeline/llm.py +++ b/learn2rag/pipeline/llm.py @@ -1,5 +1,6 @@ import logging import os +import httpx from pydantic import SecretStr from langchain_core.language_models.chat_models import BaseChatModel from langchain_ollama import ChatOllama @@ -9,6 +10,25 @@ logger = logging.getLogger(__name__) +def _env_float(name: str, default: float) -> float: + value = os.environ.get(name) + if value is None: + return default + try: + return float(value) + except ValueError: + logger.warning("Invalid float for %s=%r. Falling back to %s.", name, value, default) + return default + + +def _ollama_timeout() -> httpx.Timeout: + timeout_s = max(1.0, _env_float("L2R_OLLAMA_TIMEOUT_SECONDS", 90.0)) + connect_s = min(10.0, timeout_s) + write_s = min(30.0, timeout_s) + pool_s = min(10.0, timeout_s) + return httpx.Timeout(timeout=timeout_s, connect=connect_s, read=timeout_s, write=write_s, pool=pool_s) + + class LLMClient(): # ID is used as a key to store in user data, should not be changed ID: str @@ -50,6 +70,7 @@ def __init__(self, *, url: str, token: str | None, model: str, proxy: str | None client_kwargs={ 'headers': {'Authorization': f'Bearer {token}'} if token else {}, 'proxy': proxy, + 'timeout': _ollama_timeout(), }, ) diff --git a/learn2rag/pipeline/rewrite.py b/learn2rag/pipeline/rewrite.py index 42e405e..e2eb87f 100644 --- a/learn2rag/pipeline/rewrite.py +++ b/learn2rag/pipeline/rewrite.py @@ -1,8 +1,73 @@ from langchain_core.messages import SystemMessage, HumanMessage import ast +import logging +import os +import time from .llm import llm +logger = logging.getLogger(__name__) + + +def _env_int(name: str, default: int) -> int: + value = os.environ.get(name) + if value is None: + return default + try: + return int(value) + except ValueError: + logger.warning("Invalid int for %s=%r. Falling back to %s.", name, value, default) + return default + + +def _env_float(name: str, default: float) -> float: + value = os.environ.get(name) + if value is None: + return default + try: + return float(value) + except ValueError: + logger.warning("Invalid float for %s=%r. Falling back to %s.", name, value, default) + return default + + +def _invoke_llm(messages: list[SystemMessage | HumanMessage], *, purpose: str) -> str: + if llm is None: + return '' + + max_attempts = max(1, _env_int("L2R_OLLAMA_MAX_RETRIES", 2)) + retry_sleep_s = max(0.0, _env_float("L2R_OLLAMA_RETRY_BACKOFF_SECONDS", 2.0)) + + for attempt in range(1, max_attempts + 1): + try: + t0 = time.time() + logger.info("llm_invoke_start purpose=%s attempt=%d/%d", purpose, attempt, max_attempts) + response = llm.invoke(messages, stream=False) + duration_s = time.time() - t0 + logger.info( + "llm_invoke_done purpose=%s attempt=%d/%d duration_s=%.2f", + purpose, + attempt, + max_attempts, + duration_s, + ) + content = response.content + return content.strip() if isinstance(content, str) else '' + except Exception as exc: + logger.warning( + "llm_invoke_failed purpose=%s attempt=%d/%d error=%s", + purpose, + attempt, + max_attempts, + exc, + ) + if attempt < max_attempts and retry_sleep_s > 0: + time.sleep(retry_sleep_s * attempt) + + logger.error("llm_invoke_give_up purpose=%s attempts=%d", purpose, max_attempts) + return '' + + # future todo: add history handling / add state handling for loops in pipeline try: @@ -25,15 +90,11 @@ def rewrite_query(user_query: str) -> str: - Return only the rewritten query text. """ - response = llm.invoke([ + content = _invoke_llm([ SystemMessage(content=system_message_rewrite_query), HumanMessage(content=user_query), - ]) - - content = response.content - if isinstance(content, str): - return content.strip() - return '' + ], purpose="rewrite_query") + return content def generate_subqueries(user_query: str, n: int=3) -> list[str]: @@ -53,21 +114,19 @@ def generate_subqueries(user_query: str, n: int=3) -> list[str]: {synonym_list} """ - response = llm.invoke([ + content = _invoke_llm([ SystemMessage(content=system_message_generate_subqueries), HumanMessage(content=user_query), - ]) - - content = response.content - if not isinstance(content, str): + ], purpose="generate_subqueries") + if not content: return [] try: result = ast.literal_eval(content.strip()) if isinstance(result, list): return [str(x).strip() for x in result if str(x).strip()] - except Exception: - pass + except Exception as exc: + logger.warning("generate_subqueries_parse_failed query=%r error=%s content=%r", user_query, exc, content[:500]) return [] @@ -91,20 +150,18 @@ def generate_keywords(user_query: str, n: int=3) -> list[str]: {synonym_list} """ - response = llm.invoke([ + content = _invoke_llm([ SystemMessage(content=system_message_generate_keywords), HumanMessage(content=user_query), - ]) - - content = response.content - if not isinstance(content, str): + ], purpose="generate_keywords") + if not content: return [] try: result = ast.literal_eval(content.strip()) if isinstance(result, list): return [str(x).strip() for x in result if str(x).strip()] - except Exception: - pass + except Exception as exc: + logger.warning("generate_keywords_parse_failed query=%r error=%s content=%r", user_query, exc, content[:500]) return [] diff --git a/learn2rag/pipeline/search.py b/learn2rag/pipeline/search.py index 617eba7..bece13b 100644 --- a/learn2rag/pipeline/search.py +++ b/learn2rag/pipeline/search.py @@ -119,6 +119,7 @@ def _rerank_points_with_colbert( *, top_k: int, opt_config: dict[str, Any], + user_config: dict[str, Any], ) -> list[ScoredPoint]: collection_name = user_config["collection_name"] qdrant = Qdrant(collection_name=collection_name, opt_config=opt_config) @@ -197,8 +198,26 @@ def _collect_query_points( extra={'activity': '_collect_query_points', 'request_id': request_id}, ) - for sq in subqueries: + for idx, sq in enumerate(subqueries, start=1): + profilingLogger.info( + "subquery_search_start query=%r subquery_index=%d/%d subquery=%r top_k=%s", + query, + idx, + len(subqueries), + sq, + opt_config_subqueries["top_k"], + extra={'activity': '_collect_query_points', 'request_id': request_id}, + ) sq_results = search(sq, user_config, opt_config_subqueries, request_id=request_id) + profilingLogger.info( + "subquery_search_done query=%r subquery_index=%d/%d subquery=%r points=%d", + query, + idx, + len(subqueries), + sq, + len(sq_results.points), + extra={'activity': '_collect_query_points', 'request_id': request_id}, + ) points_all.extend(sq_results.points) if rewrite_mode in ["keywords", "subqueries_keywords"]: @@ -217,8 +236,26 @@ def _collect_query_points( extra={'activity': '_collect_query_points', 'request_id': request_id}, ) - for kw in keywords: + for idx, kw in enumerate(keywords, start=1): + profilingLogger.info( + "keyword_search_start query=%r keyword_index=%d/%d keyword=%r top_k=%s", + query, + idx, + len(keywords), + kw, + opt_config_keywords["top_k"], + extra={'activity': '_collect_query_points', 'request_id': request_id}, + ) kw_results = search(kw, user_config, opt_config_keywords, request_id=request_id) + profilingLogger.info( + "keyword_search_done query=%r keyword_index=%d/%d keyword=%r points=%d", + query, + idx, + len(keywords), + kw, + len(kw_results.points), + extra={'activity': '_collect_query_points', 'request_id': request_id}, + ) points_all.extend(kw_results.points) points = _sort_and_deduplicate(points_all) @@ -251,7 +288,8 @@ def _collect_query_points( query, points, top_k=opt_config["top_k_reranker"], - opt_config=opt_config + opt_config=opt_config, + user_config=user_config, ) else: points = points[:opt_config["top_k"]] From bd9bedb947763c4c981eaa7e7e30a2e7ec43e7d2 Mon Sep 17 00:00:00 2001 From: denkv Date: Tue, 16 Jun 2026 14:21:28 +0200 Subject: [PATCH 24/47] Add an ability to upload traning examples file --- learn2rag/ui/__init__.py | 34 +++++++++++++++ .../ui/templates/pipelines_details_page.html | 43 +++++++++++++++++++ learn2rag/ui/templates/pipelines_list.html | 6 +++ 3 files changed, 83 insertions(+) create mode 100644 learn2rag/ui/templates/pipelines_details_page.html diff --git a/learn2rag/ui/__init__.py b/learn2rag/ui/__init__.py index cb37f4f..e763872 100644 --- a/learn2rag/ui/__init__.py +++ b/learn2rag/ui/__init__.py @@ -12,6 +12,7 @@ import time from typing import Any import urllib +from itertools import islice from babel import negotiate_locale from flask import Flask, flash, redirect as flask_redirect, render_template, request, make_response, url_for @@ -479,6 +480,39 @@ def start_pipeline(name: str, pipeline: dict[str, Any], template_name: str) -> N # TODO "load" the corresponding Ollama model + @app.get('/pipelines/') + def pipeline_details(name: str) -> 'str | werkzeug.wrappers.response.Response': + pipeline = learn2rag.data.get_entry(app.instance_path, 'pipelines', name) + if pipeline is None: + flash(pgettext('flash', 'The requested pipeline is not found'), 'error') + return redirect(url_for('pipelines_list')) + storage_path = Path(pipeline['storage_path']) + try: + with (storage_path / 'training.csv').open() as training_file: + training_examples = ''.join(islice(training_file, 3)) + except FileNotFoundError: + training_examples = None + return render_template( + 'pipelines_details_page.html', + name=name, + pipeline=pipeline, + training_examples=training_examples, + ) + + @app.post('/pipelines//training') + def pipeline_details_training_data(name: str) -> 'str | werkzeug.wrappers.response.Response': + pipeline = learn2rag.data.get_entry(app.instance_path, 'pipelines', name) + if pipeline is None: + flash(pgettext('flash', 'The requested pipeline is not found'), 'error') + return redirect(url_for('pipelines_list')) + try: + training_file = request.files['trainingFile'] + training_file.save(Path(pipeline['storage_path']) / 'training.csv') + except Exception as e: + app.logger.exception(e) + flash(pgettext('flash', 'Could not save the file'), 'error') + return redirect(url_for('pipeline_details', name=name)) + @app.post('/pipelines/') def pipeline_action(name: str) -> 'str | werkzeug.wrappers.response.Response': pipeline = learn2rag.data.get_entry(app.instance_path, 'pipelines', name) diff --git a/learn2rag/ui/templates/pipelines_details_page.html b/learn2rag/ui/templates/pipelines_details_page.html new file mode 100644 index 0000000..5916ba8 --- /dev/null +++ b/learn2rag/ui/templates/pipelines_details_page.html @@ -0,0 +1,43 @@ +{% extends 'base.html' %} + +{% block header %} +

{% block title %}{{pipeline.label}}{% endblock %}

+{% endblock %} + +{% block content %} +

{{pgettext('header', 'Details')}}

+{{pipeline.label}} +
+

{{pgettext('header', 'Optimization')}}

+{% if training_examples %} +
+ + + + + + + + + + +
{{pgettext('header', 'Training data')}}
+ 
{{training_examples}}…
+
+
+{% endif %} +
+ +
+ +
+
+ +
+
+{% endblock %} diff --git a/learn2rag/ui/templates/pipelines_list.html b/learn2rag/ui/templates/pipelines_list.html index 8b5100e..f636f4a 100644 --- a/learn2rag/ui/templates/pipelines_list.html +++ b/learn2rag/ui/templates/pipelines_list.html @@ -83,6 +83,12 @@ {{pgettext('button', 'More')}}
    +
  • + + {{pgettext('button', 'Optimization')}} + +
    • +
    • {% if not (projects[name] and projects[name].running) %} {% for project_name, project in compose_templates.items() %} {% if project_name not in ['continuous'] %} From 6c50f4fbc8a7d6d947a966a3ab6713b6da7c2aa3 Mon Sep 17 00:00:00 2001 From: farshad68 Date: Wed, 17 Jun 2026 17:48:10 +0200 Subject: [PATCH 25/47] support csv file and dedicated path for dataset --- learn2rag/evaluation/tools.py | 25 ++++++++++++++++--- .../optimization/baseline_optimization.py | 9 ++++++- learn2rag/optimization/registry.json | 3 ++- 3 files changed, 31 insertions(+), 6 deletions(-) diff --git a/learn2rag/evaluation/tools.py b/learn2rag/evaluation/tools.py index b927bc1..082b45e 100644 --- a/learn2rag/evaluation/tools.py +++ b/learn2rag/evaluation/tools.py @@ -79,13 +79,30 @@ def ingest_dataset_documents(dataset_name: str) -> None: # learn2rag.pipeline.ingestion.index(user_config, opt_config) -def read_dataset_qa(dataset_name: str, subdirectory: str, split: str | None=None) -> Any: - logging.debug(f'{dataset_name=}') - dataset_work_dir = pathlib.Path('./datasets') / dataset_name - dataset_dict = datasets.load_from_disk(dataset_work_dir / 'source' / subdirectory) +def read_dataset_qa(file_path: pathlib.Path | str, split: str | None = None) -> Any: + target_path = pathlib.Path(file_path) + logging.debug(f'Loading dataset from: {target_path}') + + if not target_path.exists(): + raise FileNotFoundError(f"Dataset path does not exist: {target_path}") + + if target_path.suffix.lower() == '.csv': + logging.debug(f'load csv file ') + dataset_dict = datasets.load_dataset('csv', data_files=str(target_path)) + else: + logging.debug(f'load HF dataset ') + dataset_dict = datasets.load_from_disk(str(target_path)) + return dataset_dict[split] if split is not None else dataset_dict +# def read_dataset_qa(dataset_name: str, subdirectory: str, split: str | None=None) -> Any: +# logging.debug(f'{dataset_name=}') +# dataset_work_dir = pathlib.Path('./datasets') / dataset_name +# dataset_dict = datasets.load_from_disk(dataset_work_dir / 'source' / subdirectory) +# return dataset_dict[split] if split is not None else dataset_dict + + def basic_pipeline(dataset_name: str, question: str) -> dict[str, Any]: user_config = { 'file_path': None, diff --git a/learn2rag/optimization/baseline_optimization.py b/learn2rag/optimization/baseline_optimization.py index ac0b669..fe32a33 100644 --- a/learn2rag/optimization/baseline_optimization.py +++ b/learn2rag/optimization/baseline_optimization.py @@ -180,13 +180,20 @@ def run(dataset_name: str, max_questions: int, n_trials: int, output_dir: Union[ raise ValueError(f"Unknown dataset: {dataset_name}. Available: {list(datasets.keys())}") dcfg = datasets[dataset_name] fields = dcfg["fields"] + base_path = pathlib.Path(dcfg["path"]) out = pathlib.Path(output_dir) / dataset_name out.mkdir(parents=True, exist_ok=True) answers_dir = out / "trial_answers" answers_dir.mkdir(parents=True, exist_ok=True) + if base_path.suffix.lower() == '.csv': + target_path = base_path + else: + target_path = base_path / 'source' / dcfg.get("subdirectory", "") + + logging.debug(f"target path for dataset is {target_path} ") - qa = read_dataset_qa(dataset_name, dcfg["subdirectory"], dcfg["split"]) + qa = read_dataset_qa(target_path, split=dcfg["split"]) if max_questions: qa = qa.select(range(min(max_questions, len(qa)))) diff --git a/learn2rag/optimization/registry.json b/learn2rag/optimization/registry.json index 941c261..3377340 100644 --- a/learn2rag/optimization/registry.json +++ b/learn2rag/optimization/registry.json @@ -2,7 +2,8 @@ "datasets": { "WikiEval": { "subdirectory": "", "split": "train", - "fields": {"q": "question", "a": "answer", "id": "id"} + "fields": {"q": "question", "a": "answer", "id": "id"}, + "path": "./CSV/WikiEval_dataset.csv" } }, "prompts": { From 6eb05a17b8cf644a92d235752fa592bdf28af5cd Mon Sep 17 00:00:00 2001 From: farshad68 Date: Wed, 17 Jun 2026 18:37:31 +0200 Subject: [PATCH 26/47] add type ignore overrides for datasets module --- learn2rag/evaluation/example.py | 3 ++- pyproject.toml | 4 +++- 2 files changed, 5 insertions(+), 2 deletions(-) diff --git a/learn2rag/evaluation/example.py b/learn2rag/evaluation/example.py index 2343a65..841d59a 100644 --- a/learn2rag/evaluation/example.py +++ b/learn2rag/evaluation/example.py @@ -51,5 +51,6 @@ def process_qa(dataset_name: str, qa_rows: Any) -> None: # qa_rows = read_dataset_qa('hotpot_qa', 'distractor', 'validation') # process_qa('hotpot_qa', qa_rows.select(range(3))) - qa_rows = read_dataset_qa('WikiEval', '', 'train') + target_path = pathlib.Path('./datasets/WikiEval/source') + qa_rows = read_dataset_qa(target_path, split='train') process_qa('WikiEval', qa_rows) diff --git a/pyproject.toml b/pyproject.toml index c9fac7c..d9b500c 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -222,9 +222,11 @@ exclude = ["^learn2rag/pipeline/scripts/", strict = true [[tool.mypy.overrides]] module = [ - "datasets.*", + "datasets", + "datasets.*" ] ignore_missing_imports = true +follow_imports = "skip" [[tool.mypy.overrides]] module = ["learn2rag.pipeline.main"] ignore_errors = true From edd85df5d68d7dc0546fd8d285a8360783959593 Mon Sep 17 00:00:00 2001 From: denkv Date: Thu, 25 Jun 2026 11:26:48 +0200 Subject: [PATCH 27/47] Preview an uploaded training data file --- learn2rag/ui/__init__.py | 8 ++++---- .../ui/templates/pipelines_details_page.html | 20 ++++++++++++------- 2 files changed, 17 insertions(+), 11 deletions(-) diff --git a/learn2rag/ui/__init__.py b/learn2rag/ui/__init__.py index e763872..6988f42 100644 --- a/learn2rag/ui/__init__.py +++ b/learn2rag/ui/__init__.py @@ -24,6 +24,7 @@ import werkzeug.wrappers from learn2rag.compose import Project +from learn2rag.evaluation.tools import read_dataset_qa import learn2rag.data import learn2rag.pipeline.llm from ..utils import ( @@ -488,15 +489,14 @@ def pipeline_details(name: str) -> 'str | werkzeug.wrappers.response.Response': return redirect(url_for('pipelines_list')) storage_path = Path(pipeline['storage_path']) try: - with (storage_path / 'training.csv').open() as training_file: - training_examples = ''.join(islice(training_file, 3)) + training_dataset = read_dataset_qa(storage_path / 'training.csv', 'train') except FileNotFoundError: - training_examples = None + training_dataset = None return render_template( 'pipelines_details_page.html', name=name, pipeline=pipeline, - training_examples=training_examples, + training_dataset=training_dataset, ) @app.post('/pipelines//training') diff --git a/learn2rag/ui/templates/pipelines_details_page.html b/learn2rag/ui/templates/pipelines_details_page.html index 5916ba8..af4733c 100644 --- a/learn2rag/ui/templates/pipelines_details_page.html +++ b/learn2rag/ui/templates/pipelines_details_page.html @@ -9,23 +9,29 @@

    {{pgettext('header', 'Details')}}

    {{pipeline.label}}

    {{pgettext('header', 'Optimization')}}

    -{% if training_examples %} +{% if training_dataset %}
    - + + + {% for training_item in training_dataset.select(range(3)) %} - + + - + {% endfor %} + + + + + +
    {{pgettext('header', 'Training data')}}
    - 
    {{training_examples}}…
    -     		{{training_item['question']}}{{training_item['answer']}}
    {{gettext('Total rows: %(amount)s', amount=training_dataset.num_rows)}}
    From 77ffb6c1df029cb4767d019a6deca5be5322155b Mon Sep 17 00:00:00 2001 From: denkv Date: Thu, 25 Jun 2026 12:29:05 +0200 Subject: [PATCH 28/47] Use per-pipeline `opt_config` --- learn2rag/compose/__init__.py | 11 +++++++++-- .../ui/templates/compose/pipelines/continuous.yml | 8 ++++++-- learn2rag/ui/templates/compose/pipelines/import.yml | 6 +++++- .../ui/templates/compose/pipelines/optimization.yml | 5 ++++- learn2rag/ui/templates/compose/pipelines/pipeline.yml | 5 ++++- 5 files changed, 28 insertions(+), 7 deletions(-) diff --git a/learn2rag/compose/__init__.py b/learn2rag/compose/__init__.py index 688c969..1877c1c 100644 --- a/learn2rag/compose/__init__.py +++ b/learn2rag/compose/__init__.py @@ -206,8 +206,15 @@ def start(self) -> None: try: for file in self.content.get('files', []): file_path = Path(file['path']).expanduser().absolute() - file_path.parent.mkdir(parents=True, exist_ok=True) - file_path.write_text(file['content']) + if not file_path.exists() or file.get('force', True): + file_path.parent.mkdir(parents=True, exist_ok=True) + if 'content' in file: + content = file['content'] + elif 'src' in file: + content = Path(file['src']).read_text() + else: + raise NotImplementedError(file) + file_path.write_text(content) except Exception as e: con.rollback() raise e diff --git a/learn2rag/ui/templates/compose/pipelines/continuous.yml b/learn2rag/ui/templates/compose/pipelines/continuous.yml index b1ae969..8b7979e 100644 --- a/learn2rag/ui/templates/compose/pipelines/continuous.yml +++ b/learn2rag/ui/templates/compose/pipelines/continuous.yml @@ -29,6 +29,10 @@ files: "llm": "{{language_model.model}}" } + - path: '{{storage_path}}/opt_config.json' + src: '{{learn2rag_path}}/learn2rag/pipeline/opt_config.json' + force: false + - path: '{{storage_path}}/logging_config.yml' content: | version: 1 @@ -191,7 +195,7 @@ services: QDRANT__SERVICE__API_KEY: '{{qdrant_api_key}}' PIPELINE_USER_CONFIG: '{{storage_path}}/basic_user_config.json' IMPORTER_CONFIG: '{{storage_path}}/importer_config.json' - PIPELINE_OPT_CONFIG: '{{learn2rag_path}}/learn2rag/pipeline/opt_config.json' + PIPELINE_OPT_CONFIG: '{{storage_path}}/opt_config.json' LANGCHAIN_API_KEY: '1' LANGCHAIN_TRACING_V2: 'false' LLM_API_TYPE: '{{language_model.api}}' @@ -213,7 +217,7 @@ services: QDRANT__SERVICE__API_KEY: '{{qdrant_api_key}}' PIPELINE_USER_CONFIG: '{{storage_path}}/basic_user_config.json' IMPORTER_CONFIG: '{{storage_path}}/importer_config.json' - PIPELINE_OPT_CONFIG: '{{learn2rag_path}}/learn2rag/pipeline/opt_config.json' + PIPELINE_OPT_CONFIG: '{{storage_path}}/opt_config.json' LANGCHAIN_API_KEY: '1' LANGCHAIN_TRACING_V2: 'false' LLM_API_TYPE: '{{language_model.api}}' diff --git a/learn2rag/ui/templates/compose/pipelines/import.yml b/learn2rag/ui/templates/compose/pipelines/import.yml index fe9302b..b68392f 100644 --- a/learn2rag/ui/templates/compose/pipelines/import.yml +++ b/learn2rag/ui/templates/compose/pipelines/import.yml @@ -15,6 +15,10 @@ files: host: '127.0.0.1' telemetry_disabled: true + - path: '{{storage_path}}/opt_config.json' + src: '{{learn2rag_path}}/learn2rag/pipeline/opt_config.json' + force: false + - path: '{{storage_path}}/importer_config.json' content: '{{import_config | tojson}}' @@ -125,7 +129,7 @@ services: QDRANT__SERVICE__API_KEY: '{{qdrant_api_key}}' PIPELINE_USER_CONFIG: '{{storage_path}}/basic_user_config.json' IMPORTER_CONFIG: '{{storage_path}}/importer_config.json' - PIPELINE_OPT_CONFIG: '{{learn2rag_path}}/learn2rag/pipeline/opt_config.json' + PIPELINE_OPT_CONFIG: '{{storage_path}}/opt_config.json' LANGCHAIN_API_KEY: '1' LANGCHAIN_TRACING_V2: 'false' LLM_API_TYPE: '{{language_model.api}}' diff --git a/learn2rag/ui/templates/compose/pipelines/optimization.yml b/learn2rag/ui/templates/compose/pipelines/optimization.yml index c368649..817c89d 100644 --- a/learn2rag/ui/templates/compose/pipelines/optimization.yml +++ b/learn2rag/ui/templates/compose/pipelines/optimization.yml @@ -12,6 +12,9 @@ files: "imported_documents_file_path": "loaded_documents.json", "llm": "{{language_model.model}}" } + - path: '{{storage_path}}/opt_config.json' + src: '{{learn2rag_path}}/learn2rag/pipeline/opt_config.json' + force: false - path: '{{storage_path}}/qdrant_config.yml' content: | log_level: INFO @@ -107,7 +110,7 @@ services: QDRANT__SERVICE__API_KEY: '{{qdrant_api_key}}' PIPELINE_USER_CONFIG: '{{storage_path}}/basic_user_config.json' IMPORTER_CONFIG: '{{storage_path}}/importer_config.json' - PIPELINE_OPT_CONFIG: '{{learn2rag_path}}/learn2rag/pipeline/opt_config.json' + PIPELINE_OPT_CONFIG: '{{storage_path}}/opt_config.json' LANGCHAIN_API_KEY: '1' LANGCHAIN_TRACING_V2: 'false' LLM_API_TYPE: '{{language_model.api}}' diff --git a/learn2rag/ui/templates/compose/pipelines/pipeline.yml b/learn2rag/ui/templates/compose/pipelines/pipeline.yml index 1c77961..68e6faa 100644 --- a/learn2rag/ui/templates/compose/pipelines/pipeline.yml +++ b/learn2rag/ui/templates/compose/pipelines/pipeline.yml @@ -24,6 +24,9 @@ files: "imported_documents_file_path": "loaded_documents.json", "llm": "{{language_model.model}}" } + - path: '{{storage_path}}/opt_config.json' + src: '{{learn2rag_path}}/learn2rag/pipeline/opt_config.json' + force: false # importer_config.json should already be present @@ -184,7 +187,7 @@ services: QDRANT__SERVICE__API_KEY: '{{qdrant_api_key}}' PIPELINE_USER_CONFIG: '{{storage_path}}/basic_user_config.json' IMPORTER_CONFIG: '{{storage_path}}/importer_config.json' - PIPELINE_OPT_CONFIG: '{{learn2rag_path}}/learn2rag/pipeline/opt_config.json' + PIPELINE_OPT_CONFIG: '{{storage_path}}/opt_config.json' LANGCHAIN_API_KEY: '1' LANGCHAIN_TRACING_V2: 'false' LLM_API_TYPE: '{{language_model.api}}' From 2ee979cdd0529d7641e85accdbf6a37d8703c5ab Mon Sep 17 00:00:00 2001 From: denkv Date: Thu, 25 Jun 2026 12:29:32 +0200 Subject: [PATCH 29/47] Add missing `importer_config` for optimizaiton pipeline --- learn2rag/ui/templates/compose/pipelines/optimization.yml | 3 +++ 1 file changed, 3 insertions(+) diff --git a/learn2rag/ui/templates/compose/pipelines/optimization.yml b/learn2rag/ui/templates/compose/pipelines/optimization.yml index 817c89d..2dae517 100644 --- a/learn2rag/ui/templates/compose/pipelines/optimization.yml +++ b/learn2rag/ui/templates/compose/pipelines/optimization.yml @@ -5,6 +5,9 @@ ports: - ui - qdrant_http files: + - path: '{{storage_path}}/importer_config.json' + content: '{{import_config | tojson}}' + - path: '{{storage_path}}/basic_user_config.json' content: | { From f17ae3b658e4e57bd2a7b3b99852a625d59cb366 Mon Sep 17 00:00:00 2001 From: denkv Date: Thu, 25 Jun 2026 12:30:30 +0200 Subject: [PATCH 30/47] Create and pass `registry.json` for optimization --- .../compose/pipelines/optimization.yml | 26 ++++++++++++++++++- 1 file changed, 25 insertions(+), 1 deletion(-) diff --git a/learn2rag/ui/templates/compose/pipelines/optimization.yml b/learn2rag/ui/templates/compose/pipelines/optimization.yml index 2dae517..94ba3ad 100644 --- a/learn2rag/ui/templates/compose/pipelines/optimization.yml +++ b/learn2rag/ui/templates/compose/pipelines/optimization.yml @@ -85,6 +85,28 @@ files: - path: '{{storage_path}}/logs/.keep' content: '' + - path: '{{storage_path}}/optimization_registry.json' + content: | + { + "datasets": { + "training": { + "subdirectory": "", "split": "train", + "fields": {"q": "question", "a": "answer", "id": "id"}, + "path": "{{storage_path}}/training.csv" + } + }, + "prompts": { + "default": + "# Role and Objective\nYou will act as a smart AI chatbot that answers questions only by using the content from the provided information list.\n\n # Instructions\n- Respond in the language of the question.\n - Answer clear and concise.\n- Only use the provided information.\n - NEVER use your general knowledge.\n\n # Information:\n{context}" + , + "concise": + "Answer the question using ONLY the provided information. Be concise and direct. If the information does not contain the answer, say so.\n\n Information:\n{context}" + , + "detailed": + "You are a knowledgeable assistant. Using ONLY the provided information below, answer the question thoroughly. Cite your sources. If the information is insufficient, state that clearly.\n\n Information:\n{context}" + } + } + services: qdrant: working_dir: '{{storage_path}}' @@ -106,7 +128,9 @@ services: - '--logging-config' - '{{storage_path}}/logging_config.yml' - '--registry-path' - - '{{learn2rag_path}}/learn2rag/optimization/registry.json' + - '{{storage_path}}/optimization_registry.json' + - '--dataset' + - 'training' environment: LEARN2RAG_PATH: '{{learn2rag_path}}' QDRANT__SERVICE__HTTP_PORT: '{{ports.qdrant_http}}' From 085df97340b41f5d360a304595f35a5221b53de7 Mon Sep 17 00:00:00 2001 From: denkv Date: Thu, 25 Jun 2026 12:30:52 +0200 Subject: [PATCH 31/47] Start optimization from the pipeline details page --- learn2rag/ui/__init__.py | 1 + learn2rag/ui/templates/pipelines_details_page.html | 5 +++++ learn2rag/ui/templates/pipelines_list.html | 2 +- 3 files changed, 7 insertions(+), 1 deletion(-) diff --git a/learn2rag/ui/__init__.py b/learn2rag/ui/__init__.py index 6988f42..d185652 100644 --- a/learn2rag/ui/__init__.py +++ b/learn2rag/ui/__init__.py @@ -497,6 +497,7 @@ def pipeline_details(name: str) -> 'str | werkzeug.wrappers.response.Response': name=name, pipeline=pipeline, training_dataset=training_dataset, + projects=Project.get_all(), ) @app.post('/pipelines//training') diff --git a/learn2rag/ui/templates/pipelines_details_page.html b/learn2rag/ui/templates/pipelines_details_page.html index af4733c..fada205 100644 --- a/learn2rag/ui/templates/pipelines_details_page.html +++ b/learn2rag/ui/templates/pipelines_details_page.html @@ -37,6 +37,11 @@

    {{pgettext('header', 'Optimization')}}

    {% endif %} +{% if training_dataset and not (projects[name] and projects[name].running) %} +
    + +
    +{% endif %}
    diff --git a/learn2rag/ui/templates/pipelines_list.html b/learn2rag/ui/templates/pipelines_list.html index f636f4a..f6fa0fb 100644 --- a/learn2rag/ui/templates/pipelines_list.html +++ b/learn2rag/ui/templates/pipelines_list.html @@ -91,7 +91,7 @@
    • {% if not (projects[name] and projects[name].running) %} {% for project_name, project in compose_templates.items() %} - {% if project_name not in ['continuous'] %} + {% if project_name not in ['continuous', 'optimization'] %}
  • {{ pipeline_start(name, project, 'dropdown-item text-bg-primary') }}
    • From 1447c0512a1d7a005874c7d54450dd752365a58b Mon Sep 17 00:00:00 2001 From: denkv Date: Thu, 25 Jun 2026 13:01:38 +0200 Subject: [PATCH 32/47] Fix logging config --- learn2rag/ui/templates/compose/pipelines/optimization.yml | 2 ++ 1 file changed, 2 insertions(+) diff --git a/learn2rag/ui/templates/compose/pipelines/optimization.yml b/learn2rag/ui/templates/compose/pipelines/optimization.yml index 94ba3ad..4e6b999 100644 --- a/learn2rag/ui/templates/compose/pipelines/optimization.yml +++ b/learn2rag/ui/templates/compose/pipelines/optimization.yml @@ -38,6 +38,8 @@ files: format: "%(log_color)s%(asctime)s %(levelname)-8s %(name)s %(message)s" profiling: format: "%(created)f %(request_id)s %(activity)s %(message)s" + defaults: + request_id: null handlers: display: class: logging.StreamHandler From 018a2036d38355cd2cd365a95b1e315af15000bb Mon Sep 17 00:00:00 2001 From: denkv Date: Thu, 25 Jun 2026 13:01:46 +0200 Subject: [PATCH 33/47] Fix source and path keys --- learn2rag/pipeline/generate.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/learn2rag/pipeline/generate.py b/learn2rag/pipeline/generate.py index c5f271d..5e3a21e 100644 --- a/learn2rag/pipeline/generate.py +++ b/learn2rag/pipeline/generate.py @@ -18,7 +18,7 @@ def generate(query: str, search_results: Sequence[ScoredPoint], opt_config: dict if hasattr(search_results, "points"): search_results = search_results.points context = "\n\n".join([ - context_template.format(source=result.payload['path'], content=result.payload['content']) + context_template.format(source=result.payload['source'], content=result.payload['content']) for result in search_results if result.payload ]) From 6ba58acab6aa491cc06ae386a6b3b1c3f5d0ae88 Mon Sep 17 00:00:00 2001 From: denkv Date: Thu, 25 Jun 2026 14:49:59 +0200 Subject: [PATCH 34/47] Revert "set api_key with mock value for test" This reverts commit 3bab6bcaf77de41d0d8cd6a8811650242d72a269. --- learn2rag/tests/test_learn2rag.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/learn2rag/tests/test_learn2rag.py b/learn2rag/tests/test_learn2rag.py index d51719d..095de51 100644 --- a/learn2rag/tests/test_learn2rag.py +++ b/learn2rag/tests/test_learn2rag.py @@ -24,7 +24,7 @@ def setUp(self) -> None: self.storage_path = Path(save_data_path('Learn2RAG', 'tests')) self.storage_path.mkdir(parents=True, exist_ok=True) self.openai_client = OpenAI( - api_key='mock-key', + api_key='', base_url=f'http://localhost:{self.rag_port}', max_retries=0, ) From 116930c9b8ab61c500f43e27ddb9c865938f7757 Mon Sep 17 00:00:00 2001 From: denkv Date: Mon, 13 Jul 2026 10:58:04 +0200 Subject: [PATCH 35/47] Create the storage directory before saving the file --- learn2rag/ui/__init__.py | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/learn2rag/ui/__init__.py b/learn2rag/ui/__init__.py index d185652..c69530f 100644 --- a/learn2rag/ui/__init__.py +++ b/learn2rag/ui/__init__.py @@ -507,8 +507,10 @@ def pipeline_details_training_data(name: str) -> 'str | werkzeug.wrappers.respon flash(pgettext('flash', 'The requested pipeline is not found'), 'error') return redirect(url_for('pipelines_list')) try: + storage_path = Path(pipeline['storage_path']) + storage_path.mkdir(parents=True, exist_ok=True) training_file = request.files['trainingFile'] - training_file.save(Path(pipeline['storage_path']) / 'training.csv') + training_file.save(storage_path / 'training.csv') except Exception as e: app.logger.exception(e) flash(pgettext('flash', 'Could not save the file'), 'error') From a5b6a8ca4b1487d79dca55995d02b02dfac8f169 Mon Sep 17 00:00:00 2001 From: farshad68 Date: Wed, 22 Jul 2026 14:49:17 +0200 Subject: [PATCH 36/47] add first working version of the test for optimization --- .../optimization/baseline_optimization.py | 10 +- learn2rag/tests/test_learn2rag.py | 106 ++++++++++++++++++ 2 files changed, 113 insertions(+), 3 deletions(-) diff --git a/learn2rag/optimization/baseline_optimization.py b/learn2rag/optimization/baseline_optimization.py index fe32a33..ab6021e 100644 --- a/learn2rag/optimization/baseline_optimization.py +++ b/learn2rag/optimization/baseline_optimization.py @@ -21,8 +21,12 @@ import learn2rag.pipeline.search import learn2rag.pipeline.generate -def load_registry(path: str = "registry.json") -> dict[str, Any]: - p = pathlib.Path(path) +def load_registry(registry_source: Union[str, pathlib.Path, Dict[str, Any]] = "registry.json") -> dict[str, Any]: + if isinstance(registry_source, dict): + return registry_source + + + p = pathlib.Path(registry_source) if not p.is_file(): logging.error("registry file not found") with p.open() as f: @@ -171,7 +175,7 @@ def param_importance(smac: HyperparameterOptimizationFacade, output_path: pathli return result -def run(dataset_name: str, max_questions: int, n_trials: int, output_dir: Union[str, pathlib.Path],registry_path:str) -> Tuple[ +def run(dataset_name: str, max_questions: int, n_trials: int, output_dir: Union[str, pathlib.Path],registry_path: Union[str, pathlib.Path, Dict[str, Any]] ) -> Tuple[ Dict[str, Any], List[Any], Dict[str, Any]]: logging.info(f"registry_path is : {registry_path}") registry = load_registry(registry_path) diff --git a/learn2rag/tests/test_learn2rag.py b/learn2rag/tests/test_learn2rag.py index dab7d1b..ebef777 100644 --- a/learn2rag/tests/test_learn2rag.py +++ b/learn2rag/tests/test_learn2rag.py @@ -14,6 +14,7 @@ logger = logging.getLogger(__name__) template_dir = Path(__file__).resolve().parent.parent / 'ui' / 'templates' / 'compose' / 'pipelines' +# optimization_dir = Path(__file__).resolve().parent.parent / 'optimization' data_dir = Path(__file__).resolve().parent / 'data' @@ -112,3 +113,108 @@ def check_rag() -> None: except APIConnectionError: assert False waitUntil(check_rag, timeout=1 * 60 * 1000) + + def test_optimization(self) -> None: + template_context = { + 'is_windows': is_windows(), + 'learn2rag_path': Path('.').absolute(), + 'storage_path': self.storage_path, + 'ports': { + 'pipeline': self.rag_port, + }, + 'qdrant_api_key': '', + 'language_model': {'api': 'ChatFake'}, + 'pipeline': { + 'qdrant_path': self.storage_path / 'qdrant_persistence', + }, + 'import_config': { + 'loaders': [ + { + 'loader_id': 'local_test', + 'loader_type': 'DirectoryLoader', + 'recursive': 'True', + 'path': str(data_dir), + }, + ], + }, + } + + project = Project.create(template_dir / 'import.yml', self.project_name, template=True, + template_context=template_context) + assert project is not None, 'project should not be None' + project.start() + assert project.running + + def check_import() -> None: + project = Project.get(self.project_name) + assert project is not None + assert not project.running + + waitUntil(check_import, timeout=1 * 60 * 1000) + + project.remove() + + project = Project.create(template_dir / 'pipeline.yml', self.project_name, template=True, + template_context=template_context) + project.start() + + def check_pipeline() -> None: + try: + self.openai_client.models.list() + except APIConnectionError: + assert False + + waitUntil(check_pipeline, timeout=1 * 60 * 1000) + + # Optimization + from learn2rag.optimization.baseline_optimization import run + import os + import json + dataset_name = "test_rabbit" + opt_out_dir = self.storage_path / "opt_output" + results_file = opt_out_dir / dataset_name / "optimization_results.json" + + mock_user_config = { + "collection_name": dataset_name, + "qdrant_path": str(self.storage_path / 'qdrant_persistence') + } + os.environ["PIPELINE_USER_CONFIG"] = json.dumps(mock_user_config) + + initial_mtime = results_file.stat().st_mtime if results_file.exists() else 0.0 + + + mock_registry = { + "datasets": { + dataset_name: { + "subdirectory": "", "split": "train", + "fields": {"q": "question", "a": "answer", "id": "id"}, + "path": str(data_dir / "rabbit_eval.csv") + } + }, + "prompts": { + "default": "Answer using ONLY the provided information: {context}", + "concise": "Be concise. Information: {context}" + } + } + + best_cfg, history, importance = run( + dataset_name=dataset_name , + max_questions=2, + n_trials=2, + output_dir=opt_out_dir, + registry_path=mock_registry + ) + + + assert best_cfg is not None, "Optimization should return a valid configuration" + assert len(history) == 2, "History length should match n_trials" + + + assert results_file.exists(), "Optimization output JSON was not created" + current_mtime = results_file.stat().st_mtime + assert current_mtime > initial_mtime, "The optimization results file was not updated during the run!" + + with open(results_file, 'r') as f: + results_data = json.load(f) + assert "best_config" in results_data + assert "top_k" in results_data["best_config"], "Optimization failed to output expected parameters" \ No newline at end of file From ea97ec8e13a5545aef221027045969152eed8ff8 Mon Sep 17 00:00:00 2001 From: farshad68 Date: Wed, 22 Jul 2026 15:12:26 +0200 Subject: [PATCH 37/47] update test --- learn2rag/tests/test_learn2rag.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/learn2rag/tests/test_learn2rag.py b/learn2rag/tests/test_learn2rag.py index ebef777..acda46a 100644 --- a/learn2rag/tests/test_learn2rag.py +++ b/learn2rag/tests/test_learn2rag.py @@ -156,6 +156,8 @@ def check_import() -> None: project = Project.create(template_dir / 'pipeline.yml', self.project_name, template=True, template_context=template_context) + + assert project is not None project.start() def check_pipeline() -> None: From ed40be7d13e4ba977aaf68c151cdb0e4e0951b64 Mon Sep 17 00:00:00 2001 From: farshad68 Date: Wed, 22 Jul 2026 15:23:26 +0200 Subject: [PATCH 38/47] add test evaluation q and a --- learn2rag/tests/data/rabbit_eval.csv | 7 +++++++ 1 file changed, 7 insertions(+) create mode 100644 learn2rag/tests/data/rabbit_eval.csv diff --git a/learn2rag/tests/data/rabbit_eval.csv b/learn2rag/tests/data/rabbit_eval.csv new file mode 100644 index 0000000..0f823e0 --- /dev/null +++ b/learn2rag/tests/data/rabbit_eval.csv @@ -0,0 +1,7 @@ +answer,question +"Answer: Rabbits belong to the family Leporidae, which also includes hares, and the order Lagomorpha, which includes pikas.","Question: What family and order do rabbits belong to, and what other animals are included in these classifications?" +"Answer: The most widespread rabbit genera are Oryctolagus and Sylvilagus. The European rabbit, which belongs to the genus Oryctolagus, has been introduced on every continent except Antarctica.","Question: What are the most widespread rabbit genera, and on which continents can the European rabbit be found?" +"Answer: Rabbits do not constitute a clade because they are a paraphyletic grouping, as hares are nested within the Leporidae clade but not described as rabbits. They differ from rodents by having a number of traits rodents lack, including two extra incisors.","Question: Why do rabbits not constitute a clade, and how do they physically differ from rodents despite once being classified as such?" +"Answer: A rabbit's hind legs are longer than its fore legs, allowing for quick hopping to escape predators and providing powerful kicks if captured. Rabbits are typically nocturnal and often sleep with their eyes open.","Question: How does the bone structure of a rabbit's legs aid in its survival against predators, and what are their typical sleep habits?" +"Answer: A rabbit's ears are essential for thermoregulation, containing a high density of blood vessels. They also have a high surface area to help detect potential predators.","Question: What functions do a rabbit's ears serve regarding survival and physiology?" +"Answer: Humans have used rabbits as livestock since at least the first century BC in ancient Rome, raising them for meat, fur, and wool. The practice of raising and breeding them is known as cuniculture.","Question: When did humans begin using rabbits as livestock, for what purposes, and what is the practice of breeding them called?" \ No newline at end of file From 2d17e9438dc19808104688966ca4b7d4c7e7da60 Mon Sep 17 00:00:00 2001 From: farshad68 Date: Wed, 22 Jul 2026 16:17:49 +0200 Subject: [PATCH 39/47] add strategy for selecting the optimization algorithm --- learn2rag/optimization/__init__.py | 23 +++++++++++++++---- .../compose/pipelines/optimization.yml | 2 ++ 2 files changed, 21 insertions(+), 4 deletions(-) diff --git a/learn2rag/optimization/__init__.py b/learn2rag/optimization/__init__.py index 2e3a4b5..53c5795 100644 --- a/learn2rag/optimization/__init__.py +++ b/learn2rag/optimization/__init__.py @@ -9,8 +9,15 @@ from typing import Any from collections.abc import Mapping -#from . import baseline_optimization +from . import baseline_optimization from . import retrieval_optimization + +OPTIMIZATION_STRATEGIES = { + "baseline": baseline_optimization.run, + "retrieval": retrieval_optimization.run, +} + + #TODO : now we need to copy the dataset to here manually it should consider in installation maybe ! # {storage_path}/datasets/WikiEval/ def main() -> None: @@ -21,6 +28,13 @@ def main() -> None: parser.add_argument("--dataset", type=str, default="WikiEval") parser.add_argument("--questions", type=int, default=10) parser.add_argument("--trials", type=int, default=10) + parser.add_argument( + "--strategy", + type=str, + default="baseline", + choices=list(OPTIMIZATION_STRATEGIES.keys()), + help="Which optimization algorithm to run" + ) args, unknown = parser.parse_known_args() if args.logging_config and pathlib.Path(args.logging_config).exists(): @@ -30,7 +44,7 @@ def main() -> None: logger = logging.getLogger(__name__) logger.info(f"Running task: {args.task}") - + logger.info(f"Optimization started for {args.dataset} using strategy: {args.strategy}") logging.info(f"Optimization started for {args.dataset}") #TODO : read or get dataset_name and maxquestions and n_trails @@ -38,8 +52,9 @@ def main() -> None: output_dir = pathlib.Path("./optimization/output/") output_dir.mkdir(parents=True, exist_ok=True) - retrieval_optimization.run(args.dataset, args.questions, args.trials, output_dir, args.registry_path) - #baseline_optimization.run(args.dataset,args.questions,args.trials,output_dir,args.registry_path) + run_optimization = OPTIMIZATION_STRATEGIES[args.strategy] + run_optimization(args.dataset, args.questions, args.trials, output_dir, args.registry_path) + logging.info("optimization is done") results_path = output_dir /args.dataset/ "optimization_results.json" logging.info(f"save optimized results here : {results_path}") diff --git a/learn2rag/ui/templates/compose/pipelines/optimization.yml b/learn2rag/ui/templates/compose/pipelines/optimization.yml index 4e6b999..3e785e7 100644 --- a/learn2rag/ui/templates/compose/pipelines/optimization.yml +++ b/learn2rag/ui/templates/compose/pipelines/optimization.yml @@ -133,6 +133,8 @@ services: - '{{storage_path}}/optimization_registry.json' - '--dataset' - 'training' + - '--strategy' + - 'retrieval' environment: LEARN2RAG_PATH: '{{learn2rag_path}}' QDRANT__SERVICE__HTTP_PORT: '{{ports.qdrant_http}}' From cbf1cf094c62147b70f680b3cab10b912218fe7f Mon Sep 17 00:00:00 2001 From: farshad68 Date: Wed, 22 Jul 2026 16:57:16 +0200 Subject: [PATCH 40/47] add type --- learn2rag/optimization/__init__.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/learn2rag/optimization/__init__.py b/learn2rag/optimization/__init__.py index 53c5795..7fd91ad 100644 --- a/learn2rag/optimization/__init__.py +++ b/learn2rag/optimization/__init__.py @@ -6,13 +6,13 @@ import copy import yaml import argparse -from typing import Any +from typing import Any, Dict, Callable from collections.abc import Mapping from . import baseline_optimization from . import retrieval_optimization -OPTIMIZATION_STRATEGIES = { +OPTIMIZATION_STRATEGIES: Dict[str, Callable[..., Any]] = { "baseline": baseline_optimization.run, "retrieval": retrieval_optimization.run, } From ec76dc5131f045ee8f1ba04089811cbdb5e9a5de Mon Sep 17 00:00:00 2001 From: Carolin Walter Date: Fri, 24 Jul 2026 17:39:19 +0200 Subject: [PATCH 41/47] refactor retrieval optimization --- learn2rag/evaluation/tools.py | 2 +- learn2rag/pipeline/debug.py | 59 + learn2rag/pipeline/main.py | 98 -- learn2rag/pipeline/old_loaders.py | 109 -- learn2rag/pipeline/qdrant.py | 6 +- pyproject.toml | 36 +- uv.lock | 1864 ++++++++++++++--------------- 7 files changed, 1011 insertions(+), 1163 deletions(-) create mode 100755 learn2rag/pipeline/debug.py delete mode 100755 learn2rag/pipeline/main.py delete mode 100644 learn2rag/pipeline/old_loaders.py diff --git a/learn2rag/evaluation/tools.py b/learn2rag/evaluation/tools.py index efd409c..2b82471 100644 --- a/learn2rag/evaluation/tools.py +++ b/learn2rag/evaluation/tools.py @@ -88,7 +88,7 @@ def read_dataset_qa(file_path: pathlib.Path | str, split: str | None = None) -> if target_path.suffix.lower() == '.csv': logging.debug(f'load csv file ') - dataset_dict = datasets.load_dataset('csv', data_files=str(target_path)) + dataset_dict = datasets.load_dataset('csv', data_files=str(target_path), sep=';') else: logging.debug(f'load HF dataset ') dataset_dict = datasets.load_from_disk(str(target_path)) diff --git a/learn2rag/pipeline/debug.py b/learn2rag/pipeline/debug.py new file mode 100755 index 0000000..d1a9d85 --- /dev/null +++ b/learn2rag/pipeline/debug.py @@ -0,0 +1,59 @@ +import asyncio +import logging +import logging.config +import yaml +import json + +from langchain_core.documents.base import Document + +from . import ingestion +from . import search +from . import generate +from .store import delete_collection, delete_documents, get_documents, update_documents + + +if __name__ == "__main__": + + try: + logging.config.dictConfig(yaml.safe_load(open("./learn2rag/pipeline/logging.yaml").read())) + except FileNotFoundError: + logging.basicConfig() + + from .config import user_config, opt_config + + #delete_collection(loader_id="json_test_file", user_config=user_config, opt_config=opt_config) + #results = get_documents(loader_id="json_test_file", user_config=user_config, opt_config=opt_config) + + with open("loaded_documents.json", "r", encoding="utf-8") as f: + raw = json.load(f) + + documents = [ + Document(page_content=d["content"], metadata=d["metadata"]) + for d in raw + ] + #update_documents(loader_id="json_test_file", documents=documents, user_config=user_config, opt_config=opt_config) + # warning: index does not update, use update whereever you can! + ingestion.index(documents, user_config, opt_config) + + if opt_config["query_mode"] == "multi": + # in query_mode 'multi' different querys for each vector in the multi-vector are allowed + multi_query = {"content": "What is USM AI?", "title": "What is USM AI?", "summary": "What is USM AI?", "source_path":"USU/ITSM/"} + results = search.search_multi(multi_query, user_config, opt_config, request_id=None) + points = results.points + # modify the query for generation part + query = " ".join(f"{k}={v}" for k, v in multi_query.items()) + else: + query = "Was sind A, B und C?" + user = "anonymous" + points = asyncio.run(search.search_authorized(query, user, request_id=None)) + + sources = "\n".join(set(point.payload['source'] for point in points)) # type: ignore[index] + + for point in points: + print(f"ID: {point.id}, Path: {point.payload['source']}, Score: {point.score}") # type: ignore[index] + + answer = generate.generate(query, points, opt_config) + + print(query) + print(answer) + print(sources) diff --git a/learn2rag/pipeline/main.py b/learn2rag/pipeline/main.py deleted file mode 100755 index 20bbbcc..0000000 --- a/learn2rag/pipeline/main.py +++ /dev/null @@ -1,98 +0,0 @@ -import asyncio -import logging -import logging.config -import yaml -from operator import itemgetter - -from langchain_core.documents.base import Document - -from . import old_loaders - -from . import ingestion -from . import search -from . import generate -from .operators import BasicPipeline -from .store import delete_collection, delete_documents, get_documents, update_documents - - -async def main() -> None: - try: - logging.config.dictConfig(yaml.safe_load(open("./learn2rag/pipeline/logging.yaml").read())) - except FileNotFoundError: - logging.basicConfig() - - from .config import user_config, opt_config - - - #delete_collection(loader_id="local_docs", user_config=user_config, opt_config=opt_config) - #results = get_documents(loader_id="local_docs", user_config=user_config, opt_config=opt_config) - - - documents = [ - Document(page_content=d["content"], metadata=d["metadata"]) - for d in [ - { - "metadata": { - "source": "C:C:\\Users\\foo\\Revised Manuscript_Text categorization approach.docx", - "content_hash": "e18e509d138cf86c22df0b0dfafc5ca5b8f1e266f5e3470de68190f3ebe495b0", - "source_path": "C:\\Users\\foo", - "file_extension": "docx", - "process_date": "2025-07-28", - "process_time": "14:42:02", - "loader_type": "DirectoryLoader", - "loader_id": "local_docs", - "title": "The title of a real document", - "summary": "This document is awesome" - }, - "content": "A brand-new Corpus-based Real-time Text Classification and Tagging Approach for Social Data..." - }, - { - "metadata": { - "source": "C:C:\\Users\\foo\\qdrant.docx", - "content_hash": "7f3b9c1a0d4e6f8b2c5a7d9e1f0b3c6d8a4e2f1c9b7d0a6e5f1c3a8b9d2e4f0", - "source_path": "C:\\Users\\foo", - "file_extension": "docx", - "process_date": "2025-07-28", - "process_time": "14:42:02", - "loader_type": "DirectoryLoader", - "loader_id": "local_docs", - "title": "The title of a real document", - "summary": "This document is awesome" - }, - "content": "ein fortlaufender Text ohne Absätze, der sehr deutlich über 4000 Token liegen sollte: In einer weit entfernten Region, in der die Landschaft aus sanften Hügeln, dichten Wäldern, breiten Flüssen und alten Steinen bestand, lag eine Stadt, die von den Bewohnern seit Generationen als Ort des Wissens, der Geduld und der sorgfältigen Beobachtung beschrieben wurde, denn dort hatte man gelernt, dass alles, was Bestand haben soll, nicht nur gebaut, sondern auch verstanden werden muss, und so begann jeder Tag mit einem stillen Blick auf das, was sich verändert hatte, sei es das Licht auf den Dächern, der Wind in den Gassen, das Wasser an den Kaimauern oder die Art, wie Menschen miteinander sprachen, wenn sie glaubten, ungehört zu sein; in dieser Stadt lebte ein Archivarin namens Mara, die jeden Morgen vor Sonnenaufgang durch die schmalen Straßen zum Haus der Aufzeichnungen ging, einem Gebäude aus dunklem Holz und hellem Stein, dessen Fenster so hoch waren, dass sie den Himmel wie schmale Streifen einfassten, und während andere noch schliefen, ordnete Mara Pergamente, Karten, Briefe, Berichte, Listen und Fragmente von Erzählungen, weil sie überzeugt war, dass eine Gesellschaft nur dann ihre Zukunft verstehen konnte, wenn sie ihre Vergangenheit nicht als Last, sondern als Werkzeug betrachtete, und jedes Dokument, das durch ihre Hände ging, war für sie nicht nur Papier oder Tinte, sondern ein Hinweis auf Entscheidungen, Zweifel, Hoffnungen und Versprechen, die irgendwann einmal in die Welt gesetzt worden waren; an den Tagen, an denen der Markt besonders belebt war, hörte sie vom offenen Fenster ihres Arbeitsraums das Rufen der Händler, das Klappern der Wagenräder und das leise Murmeln der Kunden, die Obst, Stoffe, Werkzeuge, Gewürze oder Bücher kauften, und obwohl sie selten selbst hinunterging, kannte sie die Händler nach ihren Stimmen, ihren Gewohnheiten und den kleinen Geschichten, die sie beim Liefern erzählten, etwa von einem Fischer, der behauptete, ein silberner Fisch habe ihm den Weg durch dichten Nebel gezeigt, oder von einer Schneiderin, die aus Stoffresten Karten nähte, um Kinder auf spielerische Weise geographische Zusammenhänge verstehen zu lassen; Mara notierte solche Geschichten nicht, weil sie sie für wahr oder unwahr im einfachen Sinn hielt, sondern weil sie darin eine Art menschliche Logik erkannte, denn selbst Fantasie folgt Regeln, und selbst Irrtum verrät, worauf jemand gehofft oder wovor er sich gefürchtet hat, und so lernte sie, zwischen offenkundigen Fakten und inneren Wahrheiten zu unterscheiden, ohne eines von beiden geringzuschätzen; eines Tages brachte der Bote des Stadtrats eine Mappe mit roten Schnüren, versiegelt mit dem Zeichen der sechs Türme, und darin befand sich eine Nachricht, die den ganzen Rhythmus der Stadt verändern sollte, weil sie ankündigte, dass der alte Wasserkanal, der seit Jahrhunderten die Gärten versorgte und die Mühlen antrieb, in den kommenden Monaten neu vermessen werden müsse, da sein Lauf sich an mehreren Stellen verschoben habe und die Gefahr bestehe, dass nach starkem Regen Teile des Ufers brechen könnten, wodurch nicht nur Felder, sondern auch Wohnviertel bedroht wären; viele sahen in dieser Ankündigung zunächst bloß eine technische Angelegenheit, doch Mara erkannte sofort, dass es in Wahrheit eine Prüfung des kollektiven Gedächtnisses war, denn die letzten vollständigen Karten des Kanals stammten aus einer Zeit, in der andere Messmethoden verwendet worden waren, und manche Namen der Uferabschnitte existierten nur noch in den Erzählungen alter Menschen, die sich an Überschwemmungen, Reparaturen und Umleitungen erinnerten, die nie offiziell verzeichnet worden waren; also begann sie, gemeinsam mit einem kleinen Kreis aus Gelehrten, Handwerkern, Wasserbauern, Schiffern und Anwohnern ein System des Sammelns zu entwerfen, das nicht nur auf amtlichen Dokumenten beruhte, sondern auch auf mündlicher Überlieferung, auf Skizzen, auf Markierungen an Mauern, auf eingeritzten Zeichen an Steinen und auf den Erinnerungen jener, die das Wasser jahrelang beobachtet hatten, und während sie arbeiteten, wurde deutlich, dass die Stadt nicht an Informationsmangel litt, sondern an der Zerstreuung ihres Wissens, denn vieles war vorhanden, aber nichts sprach mit dem anderen, und so mussten Brücken nicht nur über Flüsse, sondern auch zwischen Menschen, Disziplinen und Gewohnheiten gebaut werden; Mara selbst war keine große Rednerin, doch sie stellte die Fragen, die sonst niemand zu stellen wagte, zum Beispiel, warum bestimmte Berichte immer wieder dieselben Formulierungen benutzten, obwohl die Situation vor Ort anders war, oder weshalb eine Entscheidung, die auf einem alten Erlass beruhte, nie an die veränderten Gegebenheiten angepasst worden war, und häufig stellte sich heraus, dass niemand aus Böswilligkeit geschwiegen hatte, sondern aus Routine, aus Respekt vor Zuständigkeiten oder aus der stillen Annahme, jemand anders werde das Problem schon bemerken, bevor es ernst werde; genau darin lag für Mara die größte Gefahr jeder gut organisierten Gemeinschaft, dass nämlich die Annahme von Ordnung dazu verleiten kann, kritische Fragen zu vermeiden, weil man die Existenz von Formularen, Zuständigkeiten und Protokollen bereits mit echter Verständigung verwechselt, und deshalb bestand ihre Arbeit nicht nur aus dem Sammeln von Daten, sondern aus dem Einüben einer Kultur des Nachfragens, des Abgleichs und der gemeinsamen Prüfung; während die Vermessung des Kanals begann, begleitete sie eine Gruppe von Ingenieuren, die lange Stäbe, Messketten, Notiztafeln und kleine Wetterinstrumente trugen, und die ersten Tage waren von Präzision geprägt, von Zahlenreihen, Höhenangaben und Abständen, doch bald stießen sie auf Widersprüche zwischen Karte und Realität, zwischen Bericht und Gelände, zwischen offizieller Bezeichnung und lokalem Sprachgebrauch, denn an einer Stelle sprach der eine vom „alten Knick“, der nächste vom „Fischgrund“, ein dritter von der „Schattenbiegung“, und jedes Mal war es dieselbe Stelle, nur aus einer anderen Erinnerung heraus benannt, sodass Mara vorschlug, nicht einen Namen zu wählen und die übrigen zu verwerfen, sondern alle Namen nebeneinander zu führen, weil jeder von ihnen einen Blickwinkel enthielt, der für andere Zwecke nützlich sein konnte; diese Entscheidung erwies sich später als entscheidend, als ein Regenband aus dem Norden kam und die Wasserstände rascher stiegen als erwartet, denn die Menschen entlang des Kanals erkannten an den verschiedenen Namen sofort, welche Abschnitte jeweils gemeint waren, obwohl in früheren amtlichen Listen nur eine einzige Bezeichnung gestanden hatte, die für manche Bewohner kaum etwas sagte; so zeigte sich, dass Sprache nicht bloß etikettiert, sondern Orientierung schafft, und je genauer eine Gemeinschaft hinsieht, desto eher versteht sie, dass Mehrdeutigkeit nicht immer ein Problem ist, sondern manchmal ein Speicher von Erfahrung; in den Wochen danach wuchs Maras Arbeit über den Kanal hinaus, denn aus der anfänglichen Vermessung entwickelte sich ein umfassenderes Vorhaben, das die Stadt selbst betraf, ihre Lagerhäuser, ihre Straßen, ihre Werkstätten, ihre Schulen und ihre Archive, weil alle erkannten, dass die Frage, wie man Wissen ordnet, eng mit der Frage verknüpft ist, wie man Verantwortung verteilt, und so bildeten sich kleine Gruppen, die Themen wie Wartung, Beschaffung, Kommunikation, Dokumentation und Krisenreaktion neu organisierten, wobei jede Gruppe darauf achten sollte, nicht nur Berichte zu produzieren, sondern auch Rückmeldungen zu erhalten, Fehler offen zu benennen und Zuständigkeiten so zu formulieren, dass andere sie verstehen konnten; es war kein leichter Prozess, denn Menschen fürchten oft nicht die Arbeit selbst, sondern die Veränderung ihrer Gewohnheiten, und manche Beamte empfanden es als Angriff, wenn man sie bat, ihre alten Abläufe zu erklären, während einige Handwerker misstrauisch wurden, wenn ihre praktischen Kenntnisse plötzlich in Tabellen auftauchten, doch Mara vermittelte stets, dass Sichtbarkeit nicht Kontrolle bedeute, sondern Zusammenarbeit, und dass ein guter Prozess nicht nur denjenigen nützt, die ihn aufsetzen, sondern allen, die auf seine Ergebnisse angewiesen sind; in einer besonders langen Sitzung, die bis in die Abenddämmerung dauerte, wurde über die Frage gestritten, ob man für jede wichtige Entscheidung eine zentrale Stelle bestimmen solle oder ob es besser sei, mehrere unabhängige Bestätigungen einzuholen, und Mara hörte still zu, bis die Stimmen müde wurden, dann sagte sie, dass Zentralisierung dort sinnvoll sei, wo Zeit knapp und Risiko hoch sei, während Verteilung dort Vorteile biete, wo Vielfalt an Beobachtungen nötig sei, und dass man beides nicht als Gegensätze, sondern als Werkzeuge verstehen müsse, die je nach Lage unterschiedlich einzusetzen seien; dieser Satz wurde später oft wiederholt, nicht weil er besonders poetisch gewesen wäre, sondern weil er eine Haltung zusammenfasste, die viele erst allmählich lernten: dass Systeme nur dann robust werden, wenn sie sowohl klare Verantwortlichkeit als auch Raum für Korrektur besitzen; währenddessen lebte außerhalb der Stadt ein alter Kartograph namens Elian, der einst für den Hof gearbeitet hatte und nun in einem kleinen Haus am Waldrand lebte, umgeben von Kartenrollen, Holzlinealen, Glaslinsen und einem Ofen, der im Winter den Raum trocken hielt, und als er von Maras Arbeit hörte, schickte er ihr eine Nachricht mit der Einladung, seine Sammlung alter Flussverläufe zu prüfen, weil er vermutete, dass darin Hinweise auf frühere Umleitungen verborgen waren, die in offiziellen Dokumenten nicht mehr vorkamen; Mara reiste zu ihm an einem Morgen, an dem dichter Nebel über den Wiesen lag, und fand einen Mann, dessen Hände von der jahrelangen Arbeit an Papier und Pergament leicht gefärbt waren, aber dessen Augen noch immer die lebhafte Aufmerksamkeit eines Suchenden hatten, und er zeigte ihr Karten aus verschiedenen Jahrzehnten, manche mit feinen Bleistiftlinien, manche mit Tinte, manche mit verblassten Markierungen, die er anhand von Randnotizen, Wasserständen und lokalen Erzählungen datiert hatte, und gemeinsam entdeckten sie, dass mehrere Fehlstellen in den aktuellen Aufzeichnungen nicht auf Zufall beruhten, sondern auf der Praxis früherer Schreiber, störende Ereignisse zu glätten, um ein harmonischeres Bild der Stadt zu hinterlassen; diese Erkenntnis erschütterte Mara nicht, denn sie hatte schon lange geahnt, dass jede Verwaltung dazu neigt, das Unbequeme zu verkleinern, wenn nicht gar zu verschweigen, doch sie war dankbar für den Beleg, weil er ihr half, andere davon zu überzeugen, dass Offenheit kein Zeichen von Schwäche ist, sondern die Voraussetzung für belastbare Entscheidungen; Elian wiederum sagte, dass eine Karte niemals die Welt selbst sei, sondern ein Vertrag zwischen Gedächtnis und Gebrauch, und diese Formulierung schrieb Mara später über ihr Bett, weil sie ihr half, die Grenzen jeder Darstellung zu respektieren, sei es eine Karte, ein Bericht, ein Diagramm, ein Protokoll oder ein Modell; im Verlauf des Sommers wurden die Arbeiten am Kanal vollendet, doch daraus entstand kein Gefühl des Abschlusses, sondern vielmehr ein neues Bewusstsein dafür, dass jede Lösung weitere Fragen eröffnet, denn nun wollte man wissen, wie die Gärten effizienter bewässert werden könnten, wie die Mühlen ihre Last besser verteilen sollten, wie Schiffe ihre Routen sicherer planen könnten und wie die Bevölkerung im Falle künftiger Unwetter schneller informiert werden könnte, und so begann man, ein Netzwerk aus Signalpunkten aufzubauen, das aus Türmen, Glocken, Flaggen und Boten bestand, ergänzt durch einfache Regeln, welche Meldung welchen Weg nehmen sollte; Mara bestand darauf, dass die Regeln kurz, verständlich und testbar sein müssten, weil lange Anweisungen in Stresssituationen versagen, und sie führte kleine Übungen durch, bei denen absichtlich falsche oder unvollständige Nachrichten in Umlauf gebracht wurden, um zu sehen, wo das System brüchig war, und jedes Mal, wenn ein Fehler erkannt wurde, schrieb sie nicht nur die Ursache auf, sondern auch die Beobachtung, die dazu geführt hatte, denn sie wollte nicht allein wissen, was scheiterte, sondern auch, wie man das Scheitern bemerkte; nach einigen Monaten hatten sich diese Übungen zu einer Art städtischer Gewohnheit entwickelt, und selbst Kinder spielten in den Höfen, dass sie Meldungen weitergeben, prüfen und bestätigen müssten, wobei sie lachten, wenn jemand die falsche Reihenfolge wählte, aber auch lernten, dass jede Information eine Quelle und einen Zweck hat; in dieser Zeit erkrankte Elian schwer, und Mara besuchte ihn mehrfach, brachte ihm Suppe, sauberes Wasser und Abschriften seiner besten Karten, damit er trotz Schwäche weiter mitdenken konnte, und in den Gesprächen am Bett wurde deutlich, dass seine größte Sorge nicht sein eigener Zustand war, sondern die Frage, ob sein Wissen nach seinem Tod in Vergessenheit geraten würde, weil es über zu viele private Notizen verteilt war, die niemand außer ihm entschlüsseln konnte; also begannen sie gemeinsam, ein übersichtliches Verzeichnis seiner Karten und Notizen anzulegen, mit klaren Titeln, Datierungen, Querverweisen und kurzen Erläuterungen, sodass auch andere damit arbeiten konnten, und als er die ersten Ergebnisse sah, lächelte er und meinte, das sei die freundlichste Form der Unsterblichkeit, nicht als Denkmal, sondern als nutzbares Wissen weiterzuleben; Mara behielt diesen Satz lange im Gedächtnis, weil er ihr vor Augen führte, dass gute Organisation nicht nur Effizienz erzeugt, sondern Würde verleiht, da sie verhindert, dass Erkenntnisse mit ihren Urhebern sterben; als der Herbst kam, färbten sich die Bäume goldbraun, und die Stadt bereitete sich auf die kälteren Monate vor, indem Vorräte geprüft, Dächer geflickt, Leinen verstaut und Brennholz gestapelt wurden, und wieder zeigte sich, wie sehr die Qualität alltäglicher Vorbereitung von verlässlicher Information abhängt, denn wer zu spät erfährt, dass ein Dach undicht ist, verliert mehr als nur Zeit, und wer zu spät erkennt, dass ein Lager knapp wird, handelt unter Druck und macht Fehler; deshalb setzte Mara sich dafür ein, dass alle wichtigen Beobachtungen nicht erst in großen Berichten, sondern unmittelbar und in einfacher Form erfasst wurden, am besten dort, wo die Arbeit stattfand, weil jede zusätzliche Übertragung die Wahrscheinlichkeit von Missverständnissen erhöht; diese Praxis stieß anfangs auf Widerstand, weil einige meinten, es sei unnötig, Handwerker mit Listen zu belasten, doch bald stellte sich heraus, dass gerade die direkte Erfassung viele spätere Rückfragen ersparte, und so entstanden kleine, robuste Abläufe, in denen ein Werkstattmeister, eine Lagerverwalterin oder ein Botenführer sofort melden konnte, was relevant war, ohne erst durch mehrere Hierarchieebenen zu gehen; im Winter, wenn Schnee die Dächer bedeckte und die Straßen leiser wurden, kehrte die Stadt in eine langsamere, nachdenklichere Haltung zurück, und Mara nutzte die Ruhe, um aus den vielen gesammelten Notizen ein Lehrbuch des städtischen Wissens zu erstellen, das nicht nur erklärte, wie man Daten sammelt, sondern auch, wie man Zweifel formuliert, Prioritäten setzt, Fehler erkennt, Rückmeldungen verarbeitet und Entscheidungen anpasst; sie schrieb darin über die Notwendigkeit klarer Begriffe, über die Vorteile mehrfacher Perspektiven, über die Grenzen von Annahmen und über die Kunst, aus unvollständigen Informationen dennoch vernünftig zu handeln, und je weiter sie schrieb, desto mehr merkte sie, dass sie nicht bloß ein Buch zusammenstellte, sondern eine Haltung überlieferte, die vielleicht in künftigen Krisen nützlicher sein würde als jedes einzelne Detail; als das Jahr sich dem Ende näherte, kam der Stadtrat zusammen, um die Ergebnisse zu bewerten, und statt einer feierlichen Rede erwarteten sie Zahlen, Karten, Fallbeispiele und Erfahrungen aus der Praxis, und Mara präsentierte ruhig, was erreicht worden war: weniger widersprüchliche Meldungen, schnellere Reaktionszeiten, klarere Zuständigkeiten, mehr Transparenz bei der Pflege öffentlicher Anlagen und ein wachsendes Vertrauen zwischen Verwaltung und Bevölkerung, weil man gelernt hatte, dass Beteiligung nicht bedeutet, jede Entscheidung endlos zu diskutieren, sondern die richtigen Menschen zur richtigen Zeit mit den richtigen Informationen zu versorgen; die Ratsmitglieder nickten, einige überrascht, andere erleichtert, und einer von ihnen fragte, was die wichtigste Lehre des Jahres sei, worauf Mara antwortete, dass Ordnung nur dann nützlich sei, wenn sie der Wirklichkeit dient, und dass jede Struktur, die nicht regelmäßig überprüft wird, irgendwann zur bloßen Gewohnheit erstarrt; nach dieser Sitzung ging sie spät in der Nacht durch die schneebedeckten Straßen nach Hause, und während der Mond auf den Dächern lag, dachte sie daran, wie seltsam und kostbar menschliche Gemeinschaften sind, wie viel Mühe es kostet, Vertrauen aufzubauen, wie leicht Missverständnisse entstehen und wie viel sich zum Guten wendet, wenn Menschen bereit sind, einander zuzuhören, ihre Aufzeichnungen zu teilen, ihre Annahmen zu prüfen und die Welt nicht nur so zu sehen, wie sie erscheinen möchte, sondern so, wie sie tatsächlich ist; sie öffnete die Tür ihres Hauses, legte den Mantel ab, setzte Wasser auf und blickte noch einmal auf die Schachtel mit Karten, Notizen und Berichten, die auf dem Tisch stand, und empfand keine Erschöpfung, sondern stille Zuversicht, weil sie wusste, dass alles Wichtige nicht in einem einzigen großen Akt geschieht, sondern in vielen kleinen, wiederholten Gesten von Sorgfalt, Klarheit und Respekt, die zusammen etwas schaffen, das größer ist als die Summe seiner Teile, und genau darin, dachte sie, liegt die eigentliche Arbeit jeder Stadt, jeder Institution und jeder Gemeinschaft: das Verstreute zu verbinden, das Unsichere zu prüfen, das Vorläufige zu verbessern und das Vergängliche so aufzuschreiben, dass daraus Orientierung entstehen kann, heute, morgen und in den Jahren, die noch kommen werden." - }, - ] -] - - #update_documents(loader_id="local_docs", documents=documents, user_config=user_config, opt_config=opt_config) - #Todo , what is the usage for all_documents which add from feature/retrieval_optimization branch - #all_documents = old_loaders.json_loader(user_config['imported_documents_file_path']) - ingestion.index(documents, user_config, opt_config) - - - if opt_config["query_mode"] == "multi": - # in query_mode 'multi' different querys for each vector in the multi-vector are allowed - multi_query = {"content": "What is USM AI?", "title": "What is USM AI?", "summary": "What is USM AI?", "source_path":"USU/ITSM/"} - results = search.search_multi(multi_query, user_config, opt_config) - points = results.points - # modify the query for generation part - query = " ".join(f"{k}={v}" for k, v in multi_query.items()) - answer = generate.generate(query, points, opt_config) - else: - pipeline = BasicPipeline() - query = "Was sind A, B und C?" - answer, points = itemgetter('answer', 'documents')(await pipeline( - inputs={'question': query, 'user': 'anonymous'}, - )) - - sources = "\n".join(set(point.payload['path'] for point in points)) # type: ignore[index] - - for point in points: - print(f"ID: {point.id}, Path: {point.payload['source']}, Score: {point.score}") # type: ignore[index] - - print(query) - print(answer) - print(sources) - -if __name__ == "__main__": - asyncio.run(main()) diff --git a/learn2rag/pipeline/old_loaders.py b/learn2rag/pipeline/old_loaders.py deleted file mode 100644 index eacaaa7..0000000 --- a/learn2rag/pipeline/old_loaders.py +++ /dev/null @@ -1,109 +0,0 @@ -import asyncio -import bz2 -import itertools -import logging -from typing import Iterator, Sequence -import os - -from bs4 import SoupStrainer # type: ignore[attr-defined] -from lxml import etree - -from langchain_community.document_loaders import ( - BSHTMLLoader, - PyPDFLoader, - WebBaseLoader, - JSONLoader, -) -from langchain_core.documents import Document - - -def json_loader(file_path: str) -> list[Document]: - loader = JSONLoader( - file_path, - jq_schema=".[]", - content_key="content", - metadata_func=lambda record, meta: record.get("metadata", {}), - ) - return loader.load() - - -def html_loader(file_path: str) -> list[Document]: - loader = BSHTMLLoader(file_path) - return loader.load() - - -def pdf_loader(file_path: str) -> list[Document]: - loader = PyPDFLoader(file_path) - docs = asyncio.run(loader.aload()) - return docs - - -def sync_pdf_loader(file_path: str) -> list[Document]: - all_documents = [] - for file in os.listdir(file_path): - if file.endswith(".pdf"): - loader = PyPDFLoader( - os.path.join(file_path, file), mode="single" - ) # important: default of mode is page-vise! - docs = loader.load() - all_documents.extend(docs) - return all_documents - - -def web_loader(web_path: Sequence[str]) -> list[Document]: - bs4_strainer = SoupStrainer( - class_=[ - "SP-Content__main", - "section sectionZ sectionArticle", - "page__content", - "post-content", - ] - ) - loader = WebBaseLoader( - web_path=web_path, - bs_kwargs={"parse_only": bs4_strainer}, - ) - docs = loader.load() - return docs - - -def cleanup_etree(elem: etree._Element) -> None: - elem.clear() - while elem.getprevious() is not None: - del elem.getparent()[0] # type:ignore[union-attr] - - -def read_wikibooks_dump(path: str) -> Iterator[tuple[str, str]]: - total = 0 - skipped = 0 - file = bz2.open(path) - for action, elem in etree.iterparse( - file, events=("end",), recover=True, huge_tree=True - ): - localname = etree.QName(elem).localname - if localname == "page": - title = elem.xpath('*[local-name()="title"]') - text = elem.xpath('*//*[local-name()="text"]') - if len(title) == 1 and len(text) == 1 and text[0].text is not None: - yield title[0].text, text[0].text - total += 1 - if total % 10000 == 0: - logging.debug("Pages read from %s: %d", path, total) - else: - skipped += 1 - cleanup_etree(elem) - logging.debug("Pages skipped in %s: %d", path, skipped) - - -def wikibooks_loader(path: str, limit: int | None = None) -> list[Document]: - docs: list[Document] = [] - for title, text in itertools.islice(read_wikibooks_dump(path), limit): - docs.append( - Document( - page_content=text, - metadata={ - "source": f"wikibooks:{title}", - }, - ) - ) - return docs \ No newline at end of file diff --git a/learn2rag/pipeline/qdrant.py b/learn2rag/pipeline/qdrant.py index 510507e..747bcfc 100644 --- a/learn2rag/pipeline/qdrant.py +++ b/learn2rag/pipeline/qdrant.py @@ -12,11 +12,7 @@ class Qdrant: - client = QdrantClient( - location=location, - api_key=api_key, - path=path, - ) + client = QdrantClient(location=location, api_key=api_key, path=path) def __init__(self, collection_name: str, opt_config: dict[str, Any]) -> None: self.collection_name = collection_name diff --git a/pyproject.toml b/pyproject.toml index e08d484..65ece3a 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -182,22 +182,22 @@ dependencies = [ "wrapt==1.17.2", "yarl==1.20.1", "zstandard==0.23.0", - "o365==2.1.9", - "azure-identity==1.25.3", - "msal==1.35.1", - "openpyxl==3.1.5", - "types-psutil==7.2.2.20260130", - "types-pyxdg==0.28.0.20251115", - "types-requests==2.32.4.20260324", - "pandas-stubs==3.0.0.260204", - "python-pptx==1.0.2", - "msoffcrypto-tool==6.0.0", - "ebooklib==0.20", - "bert-score==0.3.13", - "ConfigSpace==1.2.2", - "scikit-learn==1.8.0", - "smac==2.3.1" - + "o365 (>=2.1.8,<3.0.0)", + "azure-identity (>=1.25.1,<2.0.0)", + "msal (>=1.34.0,<2.0.0)", + "openpyxl (>=3.1.5,<4.0.0)", + "types-psutil (>=7.2.2.20260130,<8.0.0.0)", + "types-pyxdg (>=0.28.0.20251115,<0.29.0.0)", + "types-requests (>=2.32.4.20260107,<3.0.0.0)", + "pandas-stubs (>=3.0.0.260204,<4.0.0.0)", + "python-pptx (>=1.0.2,<2.0.0)", + "msoffcrypto-tool (>=6.0.0,<7.0.0)", + "ebooklib (>=0.20,<0.21)", + "apscheduler==3.11.2", + "configspace>=1.2.2", + "smac>=2.4.0", + "bert-score>=0.3.13", + "scikit-learn>=1.8.0", ] description = "" license = "MIT" @@ -215,7 +215,7 @@ requires = ["setuptools >= 77.0.3"] [tool.mypy] files = "learn2rag" exclude = ["^learn2rag/pipeline/scripts/", - "^learn2rag/pipeline/main\\.py$", + "^learn2rag/pipeline/debug\\.py$", "^learn2rag/optimization/contrastive_optimization.py", "generate_contrastive_answers.py", "self_judge_optimization.py", @@ -229,7 +229,7 @@ module = [ ignore_missing_imports = true follow_imports = "skip" [[tool.mypy.overrides]] -module = ["learn2rag.pipeline.main"] +module = ["learn2rag.pipeline.debug"] ignore_errors = true [tool.pytest.ini_options] log_cli = true diff --git a/uv.lock b/uv.lock index d2b912d..8ed621b 100644 --- a/uv.lock +++ b/uv.lock @@ -162,15 +162,15 @@ wheels = [ [[package]] name = "azure-core" -version = "1.41.0" +version = "1.39.0" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "requests" }, { name = "typing-extensions" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/a6/f3/b416179e408990df5db0d516283022dde0f5d0111d98c1a848e41853e81c/azure_core-1.41.0.tar.gz", hash = "sha256:f46ff5dfcd230f25cf1c19e8a34b8dc08a337b2503e268bb600a16c00db8ad5a", size = 381042, upload-time = "2026-05-07T23:30:54.302Z" } +sdist = { url = "https://files.pythonhosted.org/packages/34/83/bbde3faa84ddcb8eb0eca4b3ffb3221252281db4ce351300fe248c5c70b1/azure_core-1.39.0.tar.gz", hash = "sha256:8a90a562998dd44ce84597590fff6249701b98c0e8797c95fcdd695b54c35d74", size = 367531, upload-time = "2026-03-19T01:31:29.461Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/5b/db/325c6d7312d2200251c52323878281045aaffcb5586612296484e4280eaa/azure_core-1.41.0-py3-none-any.whl", hash = "sha256:522b4011e8180b1a3dcd2024396a4e7fe9ac37fb8597db47163d230b5efe892d", size = 220920, upload-time = "2026-05-07T23:30:56.357Z" }, + { url = "https://files.pythonhosted.org/packages/7e/d6/8ebcd05b01a580f086ac9a97fb9fac65c09a4b012161cc97c21a336e880b/azure_core-1.39.0-py3-none-any.whl", hash = "sha256:4ac7b70fab5438c3f68770649a78daf97833caa83827f91df9c14e0e0ea7d34f", size = 218318, upload-time = "2026-03-19T01:31:31.25Z" }, ] [[package]] @@ -374,11 +374,11 @@ wheels = [ [[package]] name = "cloudpathlib" -version = "0.24.0" +version = "0.23.0" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/06/19/58bc6b5d7d0f81c7209b05445af477e147c486552f96665a5912211839b9/cloudpathlib-0.24.0.tar.gz", hash = "sha256:c521a984e77b47e656fe78e20a7e3e260e0ab45fc69e33ac01094227c979e34a", size = 53600, upload-time = "2026-04-30T00:54:43.265Z" } +sdist = { url = "https://files.pythonhosted.org/packages/f4/18/2ac35d6b3015a0c74e923d94fc69baf8307f7c3233de015d69f99e17afa8/cloudpathlib-0.23.0.tar.gz", hash = "sha256:eb38a34c6b8a048ecfd2b2f60917f7cbad4a105b7c979196450c2f541f4d6b4b", size = 53126, upload-time = "2025-10-07T22:47:56.278Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/c2/5b/ba933f896d9b0b07608d575a8501e2b4e32166b60d84c430a4a7285ebe64/cloudpathlib-0.24.0-py3-none-any.whl", hash = "sha256:b1c51e2d2ec7dc4fed6538991f4aea849d6cf11a7e6b9069f86e461aa1f9b5b4", size = 63214, upload-time = "2026-04-30T00:54:42.06Z" }, + { url = "https://files.pythonhosted.org/packages/ae/8a/c4bb04426d608be4a3171efa2e233d2c59a5c8937850c10d098e126df18e/cloudpathlib-0.23.0-py3-none-any.whl", hash = "sha256:8520b3b01468fee77de37ab5d50b1b524ea6b4a8731c35d1b7407ac0cd716002", size = 62755, upload-time = "2025-10-07T22:47:54.905Z" }, ] [[package]] @@ -560,7 +560,7 @@ wheels = [ [[package]] name = "dask" -version = "2026.3.0" +version = "2026.7.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "click" }, @@ -571,9 +571,9 @@ dependencies = [ { name = "pyyaml" }, { name = "toolz" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/d7/2a/5d8cc1579590af86576dde890254440e478c7174b93a02095ecfc2e6ba38/dask-2026.3.0.tar.gz", hash = "sha256:f7d96c8274e8a900d217c1ff6ea8d1bbf0b4c2c21e74a409644498d925eb8f85", size = 11000710, upload-time = "2026-03-18T07:10:14.945Z" } +sdist = { url = "https://files.pythonhosted.org/packages/d6/39/cbd21c9133d02b4e60899ed466ad5e876553ea68ebffee6209e7dcafc8d4/dask-2026.7.1.tar.gz", hash = "sha256:5727484427665f051e86bf87d021a64d6411141cdc8a20bfe3c1ad2968cc06b7", size = 11548794, upload-time = "2026-07-14T01:06:22.46Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/4a/f3/00bb1e867fba351e2d784170955713bee200c43ea306c59f30bd7e748192/dask-2026.3.0-py3-none-any.whl", hash = "sha256:be614b9242b0b38288060fb2d7696125946469c98a1c30e174883fd199e0428d", size = 1485630, upload-time = "2026-03-18T07:10:12.832Z" }, + { url = "https://files.pythonhosted.org/packages/7e/5f/7c22733da92b3a6cc4dddcaa8731089d213c2790bbc997e51c429a4e8f8b/dask-2026.7.1-py3-none-any.whl", hash = "sha256:985ffd6c5e9d7979ede515e84ae8d39b647d6aa64f77600f15714ff65f578fe6", size = 1496882, upload-time = "2026-07-14T01:06:20.341Z" }, ] [package.optional-dependencies] @@ -634,24 +634,24 @@ wheels = [ [[package]] name = "debugpy" -version = "1.8.21" +version = "1.8.20" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/f2/aa/12037145b7a56eaa5b29b41872f7a21b538e807e13f32c4d3c46e59be084/debugpy-1.8.21.tar.gz", hash = "sha256:a3c53278e84c94e11bd87c53970ec391d1a67396c8b22609fcac576520e611a6", size = 1697577, upload-time = "2026-06-01T19:30:35.156Z" } +sdist = { url = "https://files.pythonhosted.org/packages/e0/b7/cd8080344452e4874aae67c40d8940e2b4d47b01601a8fd9f44786c757c7/debugpy-1.8.20.tar.gz", hash = "sha256:55bc8701714969f1ab89a6d5f2f3d40c36f91b2cbe2f65d98bf8196f6a6a2c33", size = 1645207, upload-time = "2026-01-29T23:03:28.199Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/77/6b/d817e1f8cc77aa055d37fba092e0febfdff40fe652d8d53d4cd7a86ad98d/debugpy-1.8.21-cp313-cp313-macosx_15_0_universal2.whl", hash = "sha256:13678151fc401e2d68c9880b91e28714f797d40422994572b24560ef80910a88", size = 2477398, upload-time = "2026-06-01T19:30:57.644Z" }, - { url = "https://files.pythonhosted.org/packages/48/57/412421516afc3055fa577516f00beec3d663f9b0ab330639547ae6c57720/debugpy-1.8.21-cp313-cp313-manylinux_2_34_x86_64.whl", hash = "sha256:ecbd158386c31ffe71d46f72d44d56e66331ab9b16cad649156d514368f23ab2", size = 3962096, upload-time = "2026-06-01T19:30:59.235Z" }, - { url = "https://files.pythonhosted.org/packages/c1/62/2c616337cf6ba7b07ebbc97f02c6c945a8e2f76b365e33ee809c32ee36d1/debugpy-1.8.21-cp313-cp313-win32.whl", hash = "sha256:2c2ae706dec41d99a9ca1f7ebc987a83e65578363be6f6b3ac9067504917fae1", size = 5336288, upload-time = "2026-06-01T19:31:00.79Z" }, - { url = "https://files.pythonhosted.org/packages/f8/99/9175103392f84c4b1bf7622888cdc68da07f0ff7d9e581266428f6776033/debugpy-1.8.21-cp313-cp313-win_amd64.whl", hash = "sha256:aa648733047443eb1d07682c4ef287d36a54507b643ffdf38b09a3ef002c72a0", size = 5376567, upload-time = "2026-06-01T19:31:02.56Z" }, - { url = "https://files.pythonhosted.org/packages/95/51/67e7cf11a53e40694f720457d5b3a1cdaaa3d5a9a633e482f225456b93ff/debugpy-1.8.21-py2.py3-none-any.whl", hash = "sha256:b1e37d333663c8851516a47364ef473da127f9caebe4417e6df6f5825a7e9a92", size = 5352888, upload-time = "2026-06-01T19:31:25.186Z" }, + { url = "https://files.pythonhosted.org/packages/15/e2/fc500524cc6f104a9d049abc85a0a8b3f0d14c0a39b9c140511c61e5b40b/debugpy-1.8.20-cp313-cp313-macosx_15_0_universal2.whl", hash = "sha256:5dff4bb27027821fdfcc9e8f87309a28988231165147c31730128b1c983e282a", size = 2539560, upload-time = "2026-01-29T23:03:48.738Z" }, + { url = "https://files.pythonhosted.org/packages/90/83/fb33dcea789ed6018f8da20c5a9bc9d82adc65c0c990faed43f7c955da46/debugpy-1.8.20-cp313-cp313-manylinux_2_34_x86_64.whl", hash = "sha256:84562982dd7cf5ebebfdea667ca20a064e096099997b175fe204e86817f64eaf", size = 4293272, upload-time = "2026-01-29T23:03:50.169Z" }, + { url = "https://files.pythonhosted.org/packages/a6/25/b1e4a01bfb824d79a6af24b99ef291e24189080c93576dfd9b1a2815cd0f/debugpy-1.8.20-cp313-cp313-win32.whl", hash = "sha256:da11dea6447b2cadbf8ce2bec59ecea87cc18d2c574980f643f2d2dfe4862393", size = 5331208, upload-time = "2026-01-29T23:03:51.547Z" }, + { url = "https://files.pythonhosted.org/packages/13/f7/a0b368ce54ffff9e9028c098bd2d28cfc5b54f9f6c186929083d4c60ba58/debugpy-1.8.20-cp313-cp313-win_amd64.whl", hash = "sha256:eb506e45943cab2efb7c6eafdd65b842f3ae779f020c82221f55aca9de135ed7", size = 5372930, upload-time = "2026-01-29T23:03:53.585Z" }, + { url = "https://files.pythonhosted.org/packages/e0/c3/7f67dea8ccf8fdcb9c99033bbe3e90b9e7395415843accb81428c441be2d/debugpy-1.8.20-py2.py3-none-any.whl", hash = "sha256:5be9bed9ae3be00665a06acaa48f8329d2b9632f15fd09f6a9a8c8d9907e54d7", size = 5337658, upload-time = "2026-01-29T23:04:17.404Z" }, ] [[package]] name = "decorator" -version = "5.3.1" +version = "5.2.1" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/60/8b/32f9823da46cde7df2087faa08cd98d01b908f8dcab982cdba9c84e85355/decorator-5.3.1.tar.gz", hash = "sha256:4cbcdd55a6efadb9dbea26b858f4fb3264567b52d69ca0d25b721b553f60ea82", size = 58084, upload-time = "2026-05-18T06:03:28.057Z" } +sdist = { url = "https://files.pythonhosted.org/packages/43/fa/6d96a0978d19e17b68d634497769987b16c8f4cd0a7a05048bec693caa6b/decorator-5.2.1.tar.gz", hash = "sha256:65f266143752f734b0a7cc83c46f4618af75b8c5911b00ccb61d0ac9b6da0360", size = 56711, upload-time = "2025-02-24T04:41:34.073Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/05/7f/798705f5296a58ca505d600456748d1be48078eac8a7050d8a98bc9edb89/decorator-5.3.1-py3-none-any.whl", hash = "sha256:f47fe6fdbd2edd623ecfe36875d37aba411624e2670dd395dddae1358689bb3c", size = 10365, upload-time = "2026-05-18T06:03:26.517Z" }, + { url = "https://files.pythonhosted.org/packages/4e/8c/f3147f5c4b73e7550fe5f9352eaa956ae838d5c51eb58e7a25b9f3e2643b/decorator-5.2.1-py3-none-any.whl", hash = "sha256:d316bb415a2d9e2d2b3abcc4084c6502fc09240e292cd76a76afc106a1c8e04a", size = 9190, upload-time = "2025-02-24T04:41:32.565Z" }, ] [[package]] @@ -677,7 +677,7 @@ wheels = [ [[package]] name = "distributed" -version = "2026.3.0" +version = "2026.7.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "click" }, @@ -693,12 +693,11 @@ dependencies = [ { name = "tblib" }, { name = "toolz" }, { name = "tornado" }, - { name = "urllib3" }, { name = "zict" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/e7/84/3e98a2d61493d201f253743091cbd4f099f502f957a9a33bb9ce5b8d5416/distributed-2026.3.0.tar.gz", hash = "sha256:4a8fc6102fededfbaae45288501276da2297a054d74eb6589f01b087c7f95c26", size = 2103970, upload-time = "2026-03-18T07:10:23.555Z" } +sdist = { url = "https://files.pythonhosted.org/packages/a9/e4/567125e6f2f504a6b1e37e3aecd936cf61b662c09e6e79270bd37c93f703/distributed-2026.7.1.tar.gz", hash = "sha256:f7c48ab6961734874521574d75898466703bce93f22f0cff5872c7e4ac6425d4", size = 2461209, upload-time = "2026-07-14T01:20:55.349Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/b9/77/2ff7aefc09cf1306a81cd7a46af34f80ebefef81a2e8329b94b58ad813ae/distributed-2026.3.0-py3-none-any.whl", hash = "sha256:52518f4b3e6795e87b442e8f57788ba1ddc750c62d0835669c85927280d38f07", size = 1009769, upload-time = "2026-03-18T07:10:21.241Z" }, + { url = "https://files.pythonhosted.org/packages/3c/4c/369f0b5665afa8ad6fb1862da979dbf61a650ea2b99b5dccda8953aa327c/distributed-2026.7.1-py3-none-any.whl", hash = "sha256:64eaf4406a04ad26acdc5b8e32fad6bac522d07539225a530bab49610b0114a9", size = 1012001, upload-time = "2026-07-14T01:20:53.684Z" }, ] [[package]] @@ -1080,26 +1079,26 @@ wheels = [ [[package]] name = "hf-xet" -version = "1.5.1" +version = "1.4.2" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/4b/2d/57fd21d84d93efb4bd0b962383790e19dd1bc053501b4264c97903b4e83e/hf_xet-1.5.1.tar.gz", hash = "sha256:51ef4500dab3764b41135ee1381a4b62ce56fc54d4c92b719b59e597d6df5bf6", size = 876636, upload-time = "2026-06-08T23:02:53.897Z" } +sdist = { url = "https://files.pythonhosted.org/packages/09/08/23c84a26716382c89151b5b447b4beb19e3345f3a93d3b73009a71a57ad3/hf_xet-1.4.2.tar.gz", hash = "sha256:b7457b6b482d9e0743bd116363239b1fa904a5e65deede350fbc0c4ea67c71ea", size = 672357, upload-time = "2026-03-13T06:58:51.077Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/64/ee/dd9ba7beae1005e54131b7d45263cc74c8a066d47d354e6d58ae9445a388/hf_xet-1.5.1-cp313-cp313t-macosx_10_12_x86_64.whl", hash = "sha256:dbf48c0d02cf0b2e568944330c60d9120c272dabe013bd892d48e25bc6797577", size = 4069485, upload-time = "2026-06-08T23:02:13.193Z" }, - { url = "https://files.pythonhosted.org/packages/b6/bc/9cae6cfeb4e03070874e73e5c97c66eb90369d3206b6a2b1ef5f96520888/hf_xet-1.5.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:e78e4e5192ad2b674c2e1160b651cb9134db974f8ae1835bdfbfb0166b894a43", size = 3838493, upload-time = "2026-06-08T23:02:15.282Z" }, - { url = "https://files.pythonhosted.org/packages/ba/b4/d5c01e0eb6d9f2ca2dacd84d0d1b71e6cfbb2ef3208c968528e010e9b3d7/hf_xet-1.5.1-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:6f7a04a8ad962422e225bc49fbbac99dc1806764b1f3e54dbd154bffa7593947", size = 4505658, upload-time = "2026-06-08T23:02:17.196Z" }, - { url = "https://files.pythonhosted.org/packages/76/c5/29a7598c0c6383c523dc22186d577f4e04267a626cd95ae60f67c00bfe66/hf_xet-1.5.1-cp313-cp313t-manylinux_2_28_aarch64.whl", hash = "sha256:d48199c2bf4f8df0adc55d31d1368b6ec0e4d4f45bc86b08038089c23db0bed8", size = 4292822, upload-time = "2026-06-08T23:02:18.608Z" }, - { url = "https://files.pythonhosted.org/packages/04/9a/dceaf6ca69390126b86ea825fb354b93d01163199070b7bd849225de9468/hf_xet-1.5.1-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:97f212a88d14bbf573619a74b7fecb238de77d08fc702e54dec6f78276ca3283", size = 4491255, upload-time = "2026-06-08T23:02:20.124Z" }, - { url = "https://files.pythonhosted.org/packages/48/a7/e5a7afaacf6c1791fdbeeac42951fb81c3d2bc482992b115dedcc86d963e/hf_xet-1.5.1-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:f61e3665892a6c8c5e765395838b8ddf36185da835253d4bc4509a81e49fb342", size = 4711062, upload-time = "2026-06-08T23:02:21.863Z" }, - { url = "https://files.pythonhosted.org/packages/53/49/2802f8433c9742ce281bddc1e65c02c32268ca3098d66828b05e12e45ee2/hf_xet-1.5.1-cp313-cp313t-win_amd64.whl", hash = "sha256:f4ad3ebd4c32dd2b27099d69dc7b2df821e30767e46fb6ee6a0713778243b8ff", size = 4017205, upload-time = "2026-06-08T23:02:23.495Z" }, - { url = "https://files.pythonhosted.org/packages/9e/5a/50c71195b9fb883659f596e7252faf4c18c58e753a9013bdbf9bac5d2250/hf_xet-1.5.1-cp313-cp313t-win_arm64.whl", hash = "sha256:8298485c1e36e7e67cbd01eeb1376619b7af43d4f1ec245caae306f890a8a32d", size = 3845426, upload-time = "2026-06-08T23:02:25.124Z" }, - { url = "https://files.pythonhosted.org/packages/7a/d8/5e54cf37434759d1f4f2ba9b66077ff9d4c4e1f37b6bd7975da5c40d94ab/hf_xet-1.5.1-cp37-abi3-macosx_10_12_x86_64.whl", hash = "sha256:6abd35c3221eff63836618ddfb954dcf84798603f71d8e33e3ed7b04acfdbe6e", size = 4077794, upload-time = "2026-06-08T23:02:40.656Z" }, - { url = "https://files.pythonhosted.org/packages/35/94/4b2ecfbad8f8b04701a23aefb62f540b9137d058b7e1dbef16a32676f0e9/hf_xet-1.5.1-cp37-abi3-macosx_11_0_arm64.whl", hash = "sha256:94e761bbd266bf4c03cee73753916062665ce8365aa40ed321f45afcb934b41e", size = 3845354, upload-time = "2026-06-08T23:02:42.702Z" }, - { url = "https://files.pythonhosted.org/packages/de/cc/f99f4bc7295023d7bd9ebbfd51f75cc530ca262c1227666268b8208f4b77/hf_xet-1.5.1-cp37-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:892e3a3a3aecc12aded8b93cf4f9cd059282c7de0732f7d55026f3abdf474350", size = 4514864, upload-time = "2026-06-08T23:02:44.497Z" }, - { url = "https://files.pythonhosted.org/packages/cd/6e/21f7e5a2381278bd3b7b7a5a4d90038518bb6308a0c1daf5d9f8268bb178/hf_xet-1.5.1-cp37-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:a93df2039190502835b1db8cd7e178b0b7b889fe9ab51299d5ced26e0dd879a4", size = 4303784, upload-time = "2026-06-08T23:02:46.203Z" }, - { url = "https://files.pythonhosted.org/packages/35/0e/f992bb6927ac1cb30ef74e62268f551f338bc32b2191f7c96a44c6f7283e/hf_xet-1.5.1-cp37-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:0c97106032ef70467b4f6bc2d0ccc266d7613ee076afc56516c502f87ce1c4a6", size = 4500703, upload-time = "2026-06-08T23:02:47.628Z" }, - { url = "https://files.pythonhosted.org/packages/fb/d1/90a498d05447980b977b1669246eeeeae4cfb0ea3e7a286eaba627f91bf9/hf_xet-1.5.1-cp37-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:6208adb15d192b90e4c2ad2a27ed864359b2cb0f2494eb6d7c7f3699ac02e2bf", size = 4719498, upload-time = "2026-06-08T23:02:49.268Z" }, - { url = "https://files.pythonhosted.org/packages/6d/b6/20f99cfe97cc663a711f7b33cc21d4793e51968e9a26125b4afcd77315ba/hf_xet-1.5.1-cp37-abi3-win_amd64.whl", hash = "sha256:f7b3002f95d1c13e24bcb4537baa8f0eb3838957067c91bb4959bc004a6435f5", size = 4026419, upload-time = "2026-06-08T23:02:50.829Z" }, - { url = "https://files.pythonhosted.org/packages/f9/fa/77453694888f03e5a8c8852d1514a0894d8e81c622d39edbaf308ea0dcf4/hf_xet-1.5.1-cp37-abi3-win_arm64.whl", hash = "sha256:93d090b57b211133f6c0dab0205ef5cb6d89162979ba75a74845045cc3063b8e", size = 3855178, upload-time = "2026-06-08T23:02:52.452Z" }, + { url = "https://files.pythonhosted.org/packages/18/06/e8cf74c3c48e5485c7acc5a990d0d8516cdfb5fdf80f799174f1287cc1b5/hf_xet-1.4.2-cp313-cp313t-macosx_10_12_x86_64.whl", hash = "sha256:ac8202ae1e664b2c15cdfc7298cbb25e80301ae596d602ef7870099a126fcad4", size = 3796125, upload-time = "2026-03-13T06:58:33.177Z" }, + { url = "https://files.pythonhosted.org/packages/66/d4/b73ebab01cbf60777323b7de9ef05550790451eb5172a220d6b9845385ec/hf_xet-1.4.2-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:6d2f8ee39fa9fba9af929f8c0d0482f8ee6e209179ad14a909b6ad78ffcb7c81", size = 3555985, upload-time = "2026-03-13T06:58:31.797Z" }, + { url = "https://files.pythonhosted.org/packages/ff/e7/ded6d1bd041c3f2bca9e913a0091adfe32371988e047dd3a68a2463c15a2/hf_xet-1.4.2-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:4642a6cf249c09da8c1f87fe50b24b2a3450b235bf8adb55700b52f0ea6e2eb6", size = 4212085, upload-time = "2026-03-13T06:58:24.323Z" }, + { url = "https://files.pythonhosted.org/packages/97/c1/a0a44d1f98934f7bdf17f7a915b934f9fca44bb826628c553589900f6df8/hf_xet-1.4.2-cp313-cp313t-manylinux_2_28_aarch64.whl", hash = "sha256:769431385e746c92dc05492dde6f687d304584b89c33d79def8367ace06cb555", size = 3988266, upload-time = "2026-03-13T06:58:22.887Z" }, + { url = "https://files.pythonhosted.org/packages/7a/82/be713b439060e7d1f1d93543c8053d4ef2fe7e6922c5b31642eaa26f3c4b/hf_xet-1.4.2-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:c9dd1c1bc4cc56168f81939b0e05b4c36dd2d28c13dc1364b17af89aa0082496", size = 4188513, upload-time = "2026-03-13T06:58:40.858Z" }, + { url = "https://files.pythonhosted.org/packages/21/a6/cbd4188b22abd80ebd0edbb2b3e87f2633e958983519980815fb8314eae5/hf_xet-1.4.2-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:fca58a2ae4e6f6755cc971ac6fcdf777ea9284d7e540e350bb000813b9a3008d", size = 4428287, upload-time = "2026-03-13T06:58:42.601Z" }, + { url = "https://files.pythonhosted.org/packages/b2/4e/84e45b25e2e3e903ed3db68d7eafa96dae9a1d1f6d0e7fc85120347a852f/hf_xet-1.4.2-cp313-cp313t-win_amd64.whl", hash = "sha256:163aab46854ccae0ab6a786f8edecbbfbaa38fcaa0184db6feceebf7000c93c0", size = 3665574, upload-time = "2026-03-13T06:58:53.881Z" }, + { url = "https://files.pythonhosted.org/packages/ee/71/c5ac2b9a7ae39c14e91973035286e73911c31980fe44e7b1d03730c00adc/hf_xet-1.4.2-cp313-cp313t-win_arm64.whl", hash = "sha256:09b138422ecbe50fd0c84d4da5ff537d27d487d3607183cd10e3e53f05188e82", size = 3528760, upload-time = "2026-03-13T06:58:52.187Z" }, + { url = "https://files.pythonhosted.org/packages/b4/86/b40b83a2ff03ef05c4478d2672b1fc2b9683ff870e2b25f4f3af240f2e7b/hf_xet-1.4.2-cp37-abi3-macosx_10_12_x86_64.whl", hash = "sha256:71f02d6e4cdd07f344f6844845d78518cc7186bd2bc52d37c3b73dc26a3b0bc5", size = 3800339, upload-time = "2026-03-13T06:58:36.245Z" }, + { url = "https://files.pythonhosted.org/packages/64/2e/af4475c32b4378b0e92a587adb1aa3ec53e3450fd3e5fe0372a874531c00/hf_xet-1.4.2-cp37-abi3-macosx_11_0_arm64.whl", hash = "sha256:e9b38d876e94d4bdcf650778d6ebbaa791dd28de08db9736c43faff06ede1b5a", size = 3559664, upload-time = "2026-03-13T06:58:34.787Z" }, + { url = "https://files.pythonhosted.org/packages/3c/4c/781267da3188db679e601de18112021a5cb16506fe86b246e22c5401a9c4/hf_xet-1.4.2-cp37-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:77e8c180b7ef12d8a96739a4e1e558847002afe9ea63b6f6358b2271a8bdda1c", size = 4217422, upload-time = "2026-03-13T06:58:27.472Z" }, + { url = "https://files.pythonhosted.org/packages/68/47/d6cf4a39ecf6c7705f887a46f6ef5c8455b44ad9eb0d391aa7e8a2ff7fea/hf_xet-1.4.2-cp37-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:c3b3c6a882016b94b6c210957502ff7877802d0dbda8ad142c8595db8b944271", size = 3992847, upload-time = "2026-03-13T06:58:25.989Z" }, + { url = "https://files.pythonhosted.org/packages/2d/ef/e80815061abff54697239803948abc665c6b1d237102c174f4f7a9a5ffc5/hf_xet-1.4.2-cp37-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:9d9a634cc929cfbaf2e1a50c0e532ae8c78fa98618426769480c58501e8c8ac2", size = 4193843, upload-time = "2026-03-13T06:58:44.59Z" }, + { url = "https://files.pythonhosted.org/packages/54/75/07f6aa680575d9646c4167db6407c41340cbe2357f5654c4e72a1b01ca14/hf_xet-1.4.2-cp37-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:6b0932eb8b10317ea78b7da6bab172b17be03bbcd7809383d8d5abd6a2233e04", size = 4432751, upload-time = "2026-03-13T06:58:46.533Z" }, + { url = "https://files.pythonhosted.org/packages/cd/71/193eabd7e7d4b903c4aa983a215509c6114915a5a237525ec562baddb868/hf_xet-1.4.2-cp37-abi3-win_amd64.whl", hash = "sha256:ad185719fb2e8ac26f88c8100562dbf9dbdcc3d9d2add00faa94b5f106aea53f", size = 3671149, upload-time = "2026-03-13T06:58:57.07Z" }, + { url = "https://files.pythonhosted.org/packages/b4/7e/ccf239da366b37ba7f0b36095450efae4a64980bdc7ec2f51354205fdf39/hf_xet-1.4.2-cp37-abi3-win_arm64.whl", hash = "sha256:32c012286b581f783653e718c1862aea5b9eb140631685bb0c5e7012c8719a87", size = 3533426, upload-time = "2026-03-13T06:58:55.46Z" }, ] [[package]] @@ -1248,6 +1247,18 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/69/22/94ddb47c24b491377aca06cd8fc9202cad6ab50619842457d2beefde21ea/ijson-3.5.0-cp313-cp313t-win_amd64.whl", hash = "sha256:5c2839fa233746d8aad3b8cd2354e441613f5df66d721d59da4a09394bd1db2b", size = 58016, upload-time = "2026-02-24T03:57:45.237Z" }, ] +[[package]] +name = "importlib-metadata" +version = "8.7.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "zipp" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/f3/49/3b30cad09e7771a4982d9975a8cbf64f00d4a1ececb53297f1d9a7be1b10/importlib_metadata-8.7.1.tar.gz", hash = "sha256:49fef1ae6440c182052f407c8d34a68f72efc36db9ca90dc0113398f2fdde8bb", size = 57107, upload-time = "2025-12-21T10:00:19.278Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/fa/5e/f8e9a1d23b9c20a551a8a02ea3637b4642e22c2626e3a13a9a29cdea99eb/importlib_metadata-8.7.1-py3-none-any.whl", hash = "sha256:5a1f80bf1daa489495071efbb095d75a634cf28a8bc299581244063b53176151", size = 27865, upload-time = "2025-12-21T10:00:18.329Z" }, +] + [[package]] name = "iniconfig" version = "2.3.0" @@ -1305,7 +1316,7 @@ wheels = [ [[package]] name = "ipython" -version = "9.14.1" +version = "9.11.0" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "colorama", marker = "sys_platform == 'win32'" }, @@ -1315,14 +1326,13 @@ dependencies = [ { name = "matplotlib-inline" }, { name = "pexpect", marker = "sys_platform != 'emscripten' and sys_platform != 'win32'" }, { name = "prompt-toolkit" }, - { name = "psutil", marker = "sys_platform != 'emscripten'" }, { name = "pygments" }, { name = "stack-data" }, { name = "traitlets" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/e2/23/3a27530575643c8bb7bfc757a28e2e7ef80092afbf59a2bc5716320b6602/ipython-9.14.1.tar.gz", hash = "sha256:f913bf74df06d458e46ced84ca506c23797590d594b236fe60b14df213291e7b", size = 4433457, upload-time = "2026-06-05T08:12:34.921Z" } +sdist = { url = "https://files.pythonhosted.org/packages/86/28/a4698eda5a8928a45d6b693578b135b753e14fa1c2b36ee9441e69a45576/ipython-9.11.0.tar.gz", hash = "sha256:2a94bc4406b22ecc7e4cb95b98450f3ea493a76bec8896cda11b78d7752a6667", size = 4427354, upload-time = "2026-03-05T08:57:30.549Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/9d/22/58818a63eaf8982b67632b1bc20585c811611b15a8da19d6012323dc76a5/ipython-9.14.1-py3-none-any.whl", hash = "sha256:5d4a9ecaa3b10e6e5f269dd0948bdb58ca9cb851899cd23e07c320d3eb11613c", size = 627770, upload-time = "2026-06-05T08:12:33.045Z" }, + { url = "https://files.pythonhosted.org/packages/b2/90/45c72becc57158facc6a6404f663b77bbcea2519ca57f760e2879ae1315d/ipython-9.11.0-py3-none-any.whl", hash = "sha256:6922d5bcf944c6e525a76a0a304451b60a2b6f875e86656d8bc2dfda5d710e19", size = 624222, upload-time = "2026-03-05T08:57:28.94Z" }, ] [[package]] @@ -1374,14 +1384,14 @@ wheels = [ [[package]] name = "jedi" -version = "0.20.0" +version = "0.19.2" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "parso" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/46/b7/a3635f6a2d7cf5b5dd98064fc1d5fbbafcb25477bcea204a3a92145d158b/jedi-0.20.0.tar.gz", hash = "sha256:c3f4ccbd276696f4b19c54618d4fb18f9fc24b0aef02acf704b23f487daa1011", size = 3119416, upload-time = "2026-05-01T23:38:47.814Z" } +sdist = { url = "https://files.pythonhosted.org/packages/72/3a/79a912fbd4d8dd6fbb02bf69afd3bb72cf0c729bb3063c6f4498603db17a/jedi-0.19.2.tar.gz", hash = "sha256:4770dc3de41bde3966b02eb84fbcf557fb33cce26ad23da12c742fb50ecb11f0", size = 1231287, upload-time = "2024-11-11T01:41:42.873Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/9a/93/242e2eab5fe682ffcb8b0084bde703a41d51e17ee0f3a31ff0d9d813620a/jedi-0.20.0-py2.py3-none-any.whl", hash = "sha256:7bdd9c2634f56713299976f4cbd59cb3fa92165cc5e05ea811fb253480728b67", size = 4884812, upload-time = "2026-05-01T23:38:43.919Z" }, + { url = "https://files.pythonhosted.org/packages/c0/5a/9cac0c82afec3d09ccd97c8b6502d48f165f9124db81b4bcb90b4af974ee/jedi-0.19.2-py2.py3-none-any.whl", hash = "sha256:a8ef22bde8490f57fe5c7681a3c83cb58874daf72b4784de3cce5b6ef6edb5b9", size = 1572278, upload-time = "2024-11-11T01:41:40.175Z" }, ] [[package]] @@ -1398,29 +1408,28 @@ wheels = [ [[package]] name = "jiter" -version = "0.15.0" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/66/b5/55f06bb281d92fb3cc86d14e1def2bd908bb77693183e7cb1f5a3c388b0c/jiter-0.15.0.tar.gz", hash = "sha256:4251acc80e2b7c9b7b8823456ea0fceeb0734dac2df7636d3c711b38476b5a76", size = 166640, upload-time = "2026-05-19T10:09:48.361Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/e5/f4/f708c900ecee41b2025ef8413d5351e5649eb2125c506f6720cc69b06f5c/jiter-0.15.0-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:1c11465f97e2abf45a014b83b730222f8f1c5335e802c7055a67d50de6f1f4e3", size = 307829, upload-time = "2026-05-19T10:07:59.704Z" }, - { url = "https://files.pythonhosted.org/packages/86/59/db537c0949e83668c38481d426b9f2fd5ab758c4ee53a811dd0a510626a0/jiter-0.15.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:d1e7b1776f0797956c509e123d0952d10d293a9492dea9f288ab9570ec01d1a5", size = 308445, upload-time = "2026-05-19T10:08:01.184Z" }, - { url = "https://files.pythonhosted.org/packages/37/38/ea0e13b18c30ef951da0d47d39e7fa9edb82a93a62990ffbd7cea9b622d4/jiter-0.15.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:351a341c2105aa430b7047e30f1bf7975f6313b00165d3fc07be2edaf741f279", size = 336181, upload-time = "2026-05-19T10:08:02.688Z" }, - { url = "https://files.pythonhosted.org/packages/58/fc/2303901b16c4ba05865588990a420c0b4156270b44379c20931544a1d962/jiter-0.15.0-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:4ab395feec8d249ec4044e228e98a7033f043426a265df439dc3698823f0a4e4", size = 362985, upload-time = "2026-05-19T10:08:04.394Z" }, - { url = "https://files.pythonhosted.org/packages/5b/6f/11bace093c52e7d4d26c8e606ccd7ae8c972189622469ec0d9e28161e28b/jiter-0.15.0-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:a2a438005b6f22d0273413484d6094d7c2c5d10ec1b3a3bf128e0d1d3ba53258", size = 453292, upload-time = "2026-05-19T10:08:05.967Z" }, - { url = "https://files.pythonhosted.org/packages/22/db/987f2f086ca4d7a6582eb4ccd513f9b26b42d9e4243a087609a3137a8fc7/jiter-0.15.0-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f18f85e4218d1b40f000f42a92239a7a61a902cd42c65e6c360dbd17dcb20894", size = 373501, upload-time = "2026-05-19T10:08:07.857Z" }, - { url = "https://files.pythonhosted.org/packages/8f/7c/89fbcabb2739b7a5b8dc959a1b6c5761f6484f5fed3486854b3c789bb1de/jiter-0.15.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d1aa62e277fc1cbd80e6deacae6f4d983b41b3d7728e0645c5d741a6149bba45", size = 344683, upload-time = "2026-05-19T10:08:09.431Z" }, - { url = "https://files.pythonhosted.org/packages/30/6f/6cca7692e7dddfec6d8d76c54dc97f2af2a41df4ac0674b999df1f09a5f3/jiter-0.15.0-cp313-cp313-manylinux_2_31_riscv64.whl", hash = "sha256:6550fa135c7deb8ead6af49ed7ff648532ea8334a1447fe34a36315ef79c5c29", size = 350892, upload-time = "2026-05-19T10:08:11.352Z" }, - { url = "https://files.pythonhosted.org/packages/39/14/0338d6190cb8e6d22e677ab1d4eabd4117f67cca70c54cd04b82ff64e068/jiter-0.15.0-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:066f8f33f18b2419cd8213b2436fa7fbc9c499f315971cfa3ce1f9820c001b1b", size = 388723, upload-time = "2026-05-19T10:08:12.912Z" }, - { url = "https://files.pythonhosted.org/packages/90/31/cc19f4a1bdb6afb09ce6a2f2615aa8d44d994eba0d8e6105ed1af920e736/jiter-0.15.0-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:75e8a04e91432dde9f1838373cf93d23726c79d3e908d319acf0e796f85592e7", size = 516648, upload-time = "2026-05-19T10:08:14.808Z" }, - { url = "https://files.pythonhosted.org/packages/49/9f/833c541512cd091b63c10c0381973dfe11bc7a503a818c16384417e0c81e/jiter-0.15.0-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:a97261f1fccb8e50ecd2890a96e46efdc3f57c80a197324c6777827231eca712", size = 547382, upload-time = "2026-05-19T10:08:16.927Z" }, - { url = "https://files.pythonhosted.org/packages/d2/11/e7b70e91f90bc4477e8eee9e8a5f7cf3cb41b4525d6394dc98a714eb8f7f/jiter-0.15.0-cp313-cp313-win32.whl", hash = "sha256:c77496cb10bd7549690fbbab3e5ec05857b83e49276f4a9423a766ddd2afcd4c", size = 205845, upload-time = "2026-05-19T10:08:18.401Z" }, - { url = "https://files.pythonhosted.org/packages/4b/23/5c20d9ad6f02c493e4023e5d2d09e1c1f15fe2753c9102c544aff068a88e/jiter-0.15.0-cp313-cp313-win_amd64.whl", hash = "sha256:b15741f501469009ae0ae90b7147958a664a7dede40aa7ff174a8a4645f546d0", size = 196842, upload-time = "2026-05-19T10:08:20.131Z" }, - { url = "https://files.pythonhosted.org/packages/6b/11/1eb400ef248e8c925fd883fbe325daf5e42cd1b0d308539dd332bd4f7ffc/jiter-0.15.0-cp313-cp313-win_arm64.whl", hash = "sha256:5d6a60072b44c3c2b797a7ddcbcbbf2b34ea3cfd4721580fbfd2a09d9d9b84ba", size = 192212, upload-time = "2026-05-19T10:08:21.807Z" }, - { url = "https://files.pythonhosted.org/packages/8a/60/2fd8d7c79da8acf9b7b277c7616847773779356b92acfc9bb158452174da/jiter-0.15.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:ef1fd24d9413f6209e00d3d5a453e67acfe004a25cc6c8e8484faed4311ab9e8", size = 315065, upload-time = "2026-05-19T10:08:23.218Z" }, - { url = "https://files.pythonhosted.org/packages/46/f4/008fb7d65e8ac2abf00811651a661e025c4ba80bbc6f378450384ddd3aed/jiter-0.15.0-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:144f8e72cb53dab146347b91cceac01f5481237f2b93b4a339a1ee8f8878b67c", size = 339444, upload-time = "2026-05-19T10:08:24.701Z" }, - { url = "https://files.pythonhosted.org/packages/00/55/90b0c7b9c6896c0f2a591dd36d36b71d22e09674bfef178fa03ba3f81499/jiter-0.15.0-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:553fcac2ef2cb990877f9fc0833b8b629a3e6a5670b6b5fd58219b41a653ddc4", size = 347779, upload-time = "2026-05-19T10:08:26.408Z" }, - { url = "https://files.pythonhosted.org/packages/51/6b/69666cec5000fd57734c118437394516c749ae8dbeea9fb66d6fef9c4775/jiter-0.15.0-cp313-cp313t-win_amd64.whl", hash = "sha256:774f93f65031856bf14ad9f59bdcab8b8cad501e5ceabd51ba3525f76937a25b", size = 200395, upload-time = "2026-05-19T10:08:28.055Z" }, - { url = "https://files.pythonhosted.org/packages/39/04/a6aa62cd27e8149b0d28df5561f10f6cceaf7935a9ccf3f1c5a05f9a0cd8/jiter-0.15.0-cp313-cp313t-win_arm64.whl", hash = "sha256:f1e1754960f38ec40613a07e5e372df67acb3b890fb383b6fb3de3e49ddbf3c7", size = 190516, upload-time = "2026-05-19T10:08:29.35Z" }, +version = "0.13.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/0d/5e/4ec91646aee381d01cdb9974e30882c9cd3b8c5d1079d6b5ff4af522439a/jiter-0.13.0.tar.gz", hash = "sha256:f2839f9c2c7e2dffc1bc5929a510e14ce0a946be9365fd1219e7ef342dae14f4", size = 164847, upload-time = "2026-02-02T12:37:56.441Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/91/9c/7ee5a6ff4b9991e1a45263bfc46731634c4a2bde27dfda6c8251df2d958c/jiter-0.13.0-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:1f8a55b848cbabf97d861495cd65f1e5c590246fabca8b48e1747c4dfc8f85bf", size = 306897, upload-time = "2026-02-02T12:36:16.748Z" }, + { url = "https://files.pythonhosted.org/packages/7c/02/be5b870d1d2be5dd6a91bdfb90f248fbb7dcbd21338f092c6b89817c3dbf/jiter-0.13.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:f556aa591c00f2c45eb1b89f68f52441a016034d18b65da60e2d2875bbbf344a", size = 317507, upload-time = "2026-02-02T12:36:18.351Z" }, + { url = "https://files.pythonhosted.org/packages/da/92/b25d2ec333615f5f284f3a4024f7ce68cfa0604c322c6808b2344c7f5d2b/jiter-0.13.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f7e1d61da332ec412350463891923f960c3073cf1aae93b538f0bb4c8cd46efb", size = 350560, upload-time = "2026-02-02T12:36:19.746Z" }, + { url = "https://files.pythonhosted.org/packages/be/ec/74dcb99fef0aca9fbe56b303bf79f6bd839010cb18ad41000bf6cc71eec0/jiter-0.13.0-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:3097d665a27bc96fd9bbf7f86178037db139f319f785e4757ce7ccbf390db6c2", size = 363232, upload-time = "2026-02-02T12:36:21.243Z" }, + { url = "https://files.pythonhosted.org/packages/1b/37/f17375e0bb2f6a812d4dd92d7616e41917f740f3e71343627da9db2824ce/jiter-0.13.0-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9d01ecc3a8cbdb6f25a37bd500510550b64ddf9f7d64a107d92f3ccb25035d0f", size = 483727, upload-time = "2026-02-02T12:36:22.688Z" }, + { url = "https://files.pythonhosted.org/packages/77/d2/a71160a5ae1a1e66c1395b37ef77da67513b0adba73b993a27fbe47eb048/jiter-0.13.0-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:ed9bbc30f5d60a3bdf63ae76beb3f9db280d7f195dfcfa61af792d6ce912d159", size = 370799, upload-time = "2026-02-02T12:36:24.106Z" }, + { url = "https://files.pythonhosted.org/packages/01/99/ed5e478ff0eb4e8aa5fd998f9d69603c9fd3f32de3bd16c2b1194f68361c/jiter-0.13.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:98fbafb6e88256f4454de33c1f40203d09fc33ed19162a68b3b257b29ca7f663", size = 359120, upload-time = "2026-02-02T12:36:25.519Z" }, + { url = "https://files.pythonhosted.org/packages/16/be/7ffd08203277a813f732ba897352797fa9493faf8dc7995b31f3d9cb9488/jiter-0.13.0-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:5467696f6b827f1116556cb0db620440380434591e93ecee7fd14d1a491b6daa", size = 390664, upload-time = "2026-02-02T12:36:26.866Z" }, + { url = "https://files.pythonhosted.org/packages/d1/84/e0787856196d6d346264d6dcccb01f741e5f0bd014c1d9a2ebe149caf4f3/jiter-0.13.0-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:2d08c9475d48b92892583df9da592a0e2ac49bcd41fae1fec4f39ba6cf107820", size = 513543, upload-time = "2026-02-02T12:36:28.217Z" }, + { url = "https://files.pythonhosted.org/packages/65/50/ecbd258181c4313cf79bca6c88fb63207d04d5bf5e4f65174114d072aa55/jiter-0.13.0-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:aed40e099404721d7fcaf5b89bd3b4568a4666358bcac7b6b15c09fb6252ab68", size = 547262, upload-time = "2026-02-02T12:36:29.678Z" }, + { url = "https://files.pythonhosted.org/packages/27/da/68f38d12e7111d2016cd198161b36e1f042bd115c169255bcb7ec823a3bf/jiter-0.13.0-cp313-cp313-win32.whl", hash = "sha256:36ebfbcffafb146d0e6ffb3e74d51e03d9c35ce7c625c8066cdbfc7b953bdc72", size = 200630, upload-time = "2026-02-02T12:36:31.808Z" }, + { url = "https://files.pythonhosted.org/packages/25/65/3bd1a972c9a08ecd22eb3b08a95d1941ebe6938aea620c246cf426ae09c2/jiter-0.13.0-cp313-cp313-win_amd64.whl", hash = "sha256:8d76029f077379374cf0dbc78dbe45b38dec4a2eb78b08b5194ce836b2517afc", size = 202602, upload-time = "2026-02-02T12:36:33.679Z" }, + { url = "https://files.pythonhosted.org/packages/15/fe/13bd3678a311aa67686bb303654792c48206a112068f8b0b21426eb6851e/jiter-0.13.0-cp313-cp313-win_arm64.whl", hash = "sha256:bb7613e1a427cfcb6ea4544f9ac566b93d5bf67e0d48c787eca673ff9c9dff2b", size = 185939, upload-time = "2026-02-02T12:36:35.065Z" }, + { url = "https://files.pythonhosted.org/packages/49/19/a929ec002ad3228bc97ca01dbb14f7632fffdc84a95ec92ceaf4145688ae/jiter-0.13.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:fa476ab5dd49f3bf3a168e05f89358c75a17608dbabb080ef65f96b27c19ab10", size = 316616, upload-time = "2026-02-02T12:36:36.579Z" }, + { url = "https://files.pythonhosted.org/packages/52/56/d19a9a194afa37c1728831e5fb81b7722c3de18a3109e8f282bfc23e587a/jiter-0.13.0-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ade8cb6ff5632a62b7dbd4757d8c5573f7a2e9ae285d6b5b841707d8363205ef", size = 346850, upload-time = "2026-02-02T12:36:38.058Z" }, + { url = "https://files.pythonhosted.org/packages/36/4a/94e831c6bf287754a8a019cb966ed39ff8be6ab78cadecf08df3bb02d505/jiter-0.13.0-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9950290340acc1adaded363edd94baebcee7dabdfa8bee4790794cd5cfad2af6", size = 358551, upload-time = "2026-02-02T12:36:39.417Z" }, + { url = "https://files.pythonhosted.org/packages/a2/ec/a4c72c822695fa80e55d2b4142b73f0012035d9fcf90eccc56bc060db37c/jiter-0.13.0-cp313-cp313t-win_amd64.whl", hash = "sha256:2b4972c6df33731aac0742b64fd0d18e0a69bc7d6e03108ce7d40c85fd9e3e6d", size = 201950, upload-time = "2026-02-02T12:36:40.791Z" }, + { url = "https://files.pythonhosted.org/packages/b6/00/393553ec27b824fbc29047e9c7cd4a3951d7fbe4a76743f17e44034fa4e4/jiter-0.13.0-cp313-cp313t-win_arm64.whl", hash = "sha256:701a1e77d1e593c1b435315ff625fd071f0998c5f02792038a5ca98899261b7d", size = 185852, upload-time = "2026-02-02T12:36:42.077Z" }, ] [[package]] @@ -1461,15 +1470,16 @@ wheels = [ [[package]] name = "json-stream-rs-tokenizer" -version = "0.5.1" +version = "0.5.0" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/fc/29/c947b5d3cbbc24f147eebe9cbbc5990f62c7303888298ccc69a23725323e/json_stream_rs_tokenizer-0.5.1.tar.gz", hash = "sha256:a07f1aae5915adc431e9dd61dd636a333c46b52f34ab6dccf98b2c65eae269f8", size = 35495, upload-time = "2026-04-06T18:48:58.103Z" } +sdist = { url = "https://files.pythonhosted.org/packages/90/01/50c61f606556256787dfa47fecdc13606f5a73d57661f8ffd9857274081b/json_stream_rs_tokenizer-0.5.0.tar.gz", hash = "sha256:71f609eccb955357e882f5b5ea4aa8db15597fb4b03c8034b2c584210cabe2cd", size = 35092, upload-time = "2025-12-31T21:13:42.054Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/09/a6/e1e3a98e8efe75b6e54a994537e36c96d0e7ad6ca26b72ba92bc876f7503/json_stream_rs_tokenizer-0.5.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:fed2c740bd9a79c5decd8d5d1fbd20885eb78e3268c401079bd38dc43d2faad8", size = 293035, upload-time = "2026-04-06T18:48:21.386Z" }, - { url = "https://files.pythonhosted.org/packages/86/8d/4d78b464a3c56cc6391d447411fc3b4507570fedad0c77aeffb7377ebeb2/json_stream_rs_tokenizer-0.5.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:1aaa4400380da8361abbbc40ea7da3c6fd48dbae83d1af3fe7131aa35005f1ae", size = 285227, upload-time = "2026-04-06T18:48:22.919Z" }, - { url = "https://files.pythonhosted.org/packages/7d/ca/f3329cf801c08d1c0a57f5fe81481b24dd3a02a6b889f17b9298c55a1b04/json_stream_rs_tokenizer-0.5.1-cp313-cp313-manylinux_2_28_aarch64.whl", hash = "sha256:0eaf6a5faf00e73d751d03017e7ce6d9e524bf4ca8fb7861e375e03c763886cf", size = 317647, upload-time = "2026-04-06T18:48:24.389Z" }, - { url = "https://files.pythonhosted.org/packages/2f/1e/29404cc0bc6f9a9cee05b1d2f13f8b5a797f47ba2b07be4beaae516c8483/json_stream_rs_tokenizer-0.5.1-cp313-cp313-manylinux_2_28_x86_64.whl", hash = "sha256:7db396946a5ac5b2b0aa380b5477f0242f71894f516d6d0553fbfe181b36b749", size = 329530, upload-time = "2026-04-06T18:48:25.791Z" }, - { url = "https://files.pythonhosted.org/packages/fe/5c/2705bdf2d29ea1036fbd25740ac952450890f94a5be285f8260ced33a8d8/json_stream_rs_tokenizer-0.5.1-cp313-cp313-win_amd64.whl", hash = "sha256:3c6cf44c4e6c44e5e40e199192d0ea39311ea612bcb4763210aabd5a828403a7", size = 765803, upload-time = "2026-04-06T18:48:27.275Z" }, + { url = "https://files.pythonhosted.org/packages/0e/b8/2cf6e936604314265c76aa86324a14e1390c336702a741b13ded2f2a6ddc/json_stream_rs_tokenizer-0.5.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:a8300a0bf3846b2d9cd818b1b75107ae1e67f1f43d96587c1ed99bb8744039c9", size = 297092, upload-time = "2025-12-31T21:12:59.716Z" }, + { url = "https://files.pythonhosted.org/packages/3a/84/fa953089b66f84be37fa3313855b8f95ca9d89aafd297f6e675d21cfb144/json_stream_rs_tokenizer-0.5.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:040556e7e55979911ddf11bf96c8906b27f61105471ade52129094efa7fe9e1b", size = 289302, upload-time = "2025-12-31T21:13:00.903Z" }, + { url = "https://files.pythonhosted.org/packages/9c/c5/2903f1e6b6d66ae3578cc63b672972d18af34d35ad08b59e7e0989e7eb44/json_stream_rs_tokenizer-0.5.0-cp313-cp313-manylinux_2_28_aarch64.whl", hash = "sha256:d163b06242d2f31cbd8efd6deb27386f7fc8fdf391a933c92463b24c94e74f56", size = 320726, upload-time = "2025-12-31T21:13:02.062Z" }, + { url = "https://files.pythonhosted.org/packages/51/9f/362c5093c5329c989f3ae5ff1be63ba39fef7a1c356b11da14c3174139ba/json_stream_rs_tokenizer-0.5.0-cp313-cp313-manylinux_2_28_x86_64.whl", hash = "sha256:501a4c5133aa68b642955e86b8d68bea7a563324570684627c0b10bccf3864aa", size = 331754, upload-time = "2025-12-31T21:13:03.333Z" }, + { url = "https://files.pythonhosted.org/packages/31/f0/2911d7c8a5fd3ce52d38ee2b7fe2f2ceff0d124ee4e4491e507bd6013070/json_stream_rs_tokenizer-0.5.0-cp313-cp313-win32.whl", hash = "sha256:11d5771373ba232fe4589c49494874b51d2750102d2cbe760396fc71553bc438", size = 172162, upload-time = "2025-12-31T21:13:04.929Z" }, + { url = "https://files.pythonhosted.org/packages/b4/f1/f992895d069297e4aa7a14ff1e510645fb8f2f8e16648484e6c68150bbae/json_stream_rs_tokenizer-0.5.0-cp313-cp313-win_amd64.whl", hash = "sha256:2141158a691205d85dc1192152a64dd2d5054c120851b9f89a1c195b34ac49c3", size = 178844, upload-time = "2025-12-31T21:13:06.261Z" }, ] [[package]] @@ -1495,7 +1505,7 @@ wheels = [ [[package]] name = "jupyter-client" -version = "8.9.1" +version = "8.8.0" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "jupyter-core" }, @@ -1503,11 +1513,10 @@ dependencies = [ { name = "pyzmq" }, { name = "tornado" }, { name = "traitlets" }, - { name = "typing-extensions" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/7d/dc/5512503b088997c2250b8bf18258fba9d9ce5ead641183700960d3c9d342/jupyter_client-8.9.1.tar.gz", hash = "sha256:a58f730dd9e728ba16ba1d62ebccf7ffe1ebbdbce4e95cfae941b7321ae1f4fa", size = 359256, upload-time = "2026-06-09T13:15:01.033Z" } +sdist = { url = "https://files.pythonhosted.org/packages/05/e4/ba649102a3bc3fbca54e7239fb924fd434c766f855693d86de0b1f2bec81/jupyter_client-8.8.0.tar.gz", hash = "sha256:d556811419a4f2d96c869af34e854e3f059b7cc2d6d01a9cd9c85c267691be3e", size = 348020, upload-time = "2026-01-08T13:55:47.938Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/3f/6f/56d39bf385c5c27988aebaf0c18a2a17e960575740100973511018bd904e/jupyter_client-8.9.1-py3-none-any.whl", hash = "sha256:0b7a295bc46e8751e9adae84781f726c851c1d911bd793edc4a3bde942e3da81", size = 109828, upload-time = "2026-06-09T13:14:58.835Z" }, + { url = "https://files.pythonhosted.org/packages/2d/0b/ceb7694d864abc0a047649aec263878acb9f792e1fec3e676f22dc9015e3/jupyter_client-8.8.0-py3-none-any.whl", hash = "sha256:f93a5b99c5e23a507b773d3a1136bd6e16c67883ccdbd9a829b0bbdb98cd7d7a", size = 107371, upload-time = "2026-01-08T13:55:45.562Z" }, ] [[package]] @@ -1986,9 +1995,10 @@ requires-dist = [ { name = "apscheduler", specifier = "==3.11.2" }, { name = "attrs", specifier = "==25.3.0" }, { name = "azure-identity", specifier = "==1.25.3" }, + { name = "azure-identity", specifier = ">=1.25.1,<2.0.0" }, { name = "backoff", specifier = "==2.2.1" }, { name = "beautifulsoup4", specifier = "==4.14.3" }, - { name = "bert-score", specifier = "==0.3.13" }, + { name = "bert-score", specifier = ">=0.3.13" }, { name = "build", specifier = "==1.3.0" }, { name = "cachetools", specifier = "==5.5.2" }, { name = "certifi", specifier = "==2025.8.3" }, @@ -1998,7 +2008,7 @@ requires-dist = [ { name = "colorama", specifier = "==0.4.6" }, { name = "coloredlogs", specifier = "==15.0.1" }, { name = "colorlog", specifier = "==6.10.1" }, - { name = "configspace", specifier = "==1.2.2" }, + { name = "configspace", specifier = ">=1.2.2" }, { name = "contourpy", specifier = "==1.3.3" }, { name = "cryptography", specifier = "==45.0.6" }, { name = "cycler", specifier = "==0.12.1" }, @@ -2006,6 +2016,7 @@ requires-dist = [ { name = "datasets", specifier = "==4.8.4" }, { name = "deprecated", specifier = "==1.2.18" }, { name = "ebooklib", specifier = "==0.20" }, + { name = "ebooklib", specifier = ">=0.20,<0.21" }, { name = "effdet", specifier = "==0.4.1" }, { name = "emoji", specifier = "==2.15.0" }, { name = "fastapi", specifier = "==0.115.11" }, @@ -2061,8 +2072,10 @@ requires-dist = [ { name = "matplotlib", specifier = "==3.10.5" }, { name = "mpmath", specifier = "==1.3.0" }, { name = "msal", specifier = "==1.35.1" }, + { name = "msal", specifier = ">=1.34.0,<2.0.0" }, { name = "msgraph-sdk", specifier = "==1.54.0" }, { name = "msoffcrypto-tool", specifier = "==6.0.0" }, + { name = "msoffcrypto-tool", specifier = ">=6.0.0,<7.0.0" }, { name = "multidict", specifier = "==6.6.4" }, { name = "mypy", specifier = "==1.19.1" }, { name = "mypy-extensions", specifier = "==1.1.0" }, @@ -2070,6 +2083,7 @@ requires-dist = [ { name = "nltk", specifier = "==3.9.1" }, { name = "numpy", specifier = "==2.2.6" }, { name = "o365", specifier = "==2.1.9" }, + { name = "o365", specifier = ">=2.1.8,<3.0.0" }, { name = "olefile", specifier = "==0.47" }, { name = "ollama", specifier = "==0.6.1" }, { name = "omegaconf", specifier = "==2.3.0" }, @@ -2078,10 +2092,12 @@ requires-dist = [ { name = "openai", specifier = "==2.33.0" }, { name = "opencv-python", specifier = "==4.12.0.88" }, { name = "openpyxl", specifier = "==3.1.5" }, + { name = "openpyxl", specifier = ">=3.1.5,<4.0.0" }, { name = "orjson", specifier = "==3.11.1" }, { name = "packaging", specifier = "==25.0" }, { name = "pandas", specifier = "==2.3.3" }, { name = "pandas-stubs", specifier = "==3.0.0.260204" }, + { name = "pandas-stubs", specifier = ">=3.0.0.260204,<4.0.0.0" }, { name = "pdf2image", specifier = "==1.17.0" }, { name = "pdfminer-six", specifier = "==20250506" }, { name = "pi-heif", specifier = "==1.1.0" }, @@ -2112,6 +2128,7 @@ requires-dist = [ { name = "python-multipart", specifier = "==0.0.20" }, { name = "python-oxmsg", specifier = "==0.0.2" }, { name = "python-pptx", specifier = "==1.0.2" }, + { name = "python-pptx", specifier = ">=1.0.2,<2.0.0" }, { name = "pytz", specifier = "==2025.2" }, { name = "pyxdg", specifier = "==0.28" }, { name = "pyyaml", specifier = "==6.0.3" }, @@ -2122,13 +2139,13 @@ requires-dist = [ { name = "requests-toolbelt", specifier = "==1.0.0" }, { name = "rsa", specifier = "==4.9.1" }, { name = "safetensors", specifier = "==0.6.2" }, - { name = "scikit-learn", specifier = "==1.8.0" }, + { name = "scikit-learn", specifier = ">=1.8.0" }, { name = "scipy", specifier = "==1.16.1" }, { name = "sentence-transformers", specifier = "==5.3.0" }, { name = "setuptools", specifier = "==80.9.0" }, { name = "simsimd", specifier = "==6.5.16" }, { name = "six", specifier = "==1.17.0" }, - { name = "smac", specifier = "==2.3.1" }, + { name = "smac", specifier = ">=2.4.0" }, { name = "sniffio", specifier = "==1.3.1" }, { name = "soupsieve", specifier = "==2.7" }, { name = "sqlalchemy", specifier = "==2.0.42" }, @@ -2141,9 +2158,12 @@ requires-dist = [ { name = "tqdm", specifier = "==4.67.3" }, { name = "transformers", specifier = "==4.55.0" }, { name = "types-psutil", specifier = "==7.2.2.20260130" }, + { name = "types-psutil", specifier = ">=7.2.2.20260130,<8.0.0.0" }, { name = "types-pyxdg", specifier = "==0.28.0.20251115" }, + { name = "types-pyxdg", specifier = ">=0.28.0.20251115,<0.29.0.0" }, { name = "types-pyyaml", specifier = "==6.0.12.20250915" }, { name = "types-requests", specifier = "==2.32.4.20260324" }, + { name = "types-requests", specifier = ">=2.32.4.20260107,<3.0.0.0" }, { name = "typing-extensions", specifier = "==4.15.0" }, { name = "typing-inspect", specifier = "==0.9.0" }, { name = "typing-inspection", specifier = "==0.4.1" }, @@ -2165,35 +2185,35 @@ dev = [{ name = "pandas-stubs", specifier = ">=3.0.0.260204,<4.0.0.0" }] [[package]] name = "librt" -version = "0.11.0" +version = "0.8.1" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/40/08/9e7f6b5d2b5bed6ad055cdd5925f192bb403a51280f86b56554d9d0699a2/librt-0.11.0.tar.gz", hash = "sha256:075dc3ef4458a278e0195cbf6ac9d38808d9b906c5a6c7f7f79c3888276a3fb1", size = 200139, upload-time = "2026-05-10T18:17:25.138Z" } +sdist = { url = "https://files.pythonhosted.org/packages/56/9c/b4b0c54d84da4a94b37bd44151e46d5e583c9534c7e02250b961b1b6d8a8/librt-0.8.1.tar.gz", hash = "sha256:be46a14693955b3bd96014ccbdb8339ee8c9346fbe11c1b78901b55125f14c73", size = 177471, upload-time = "2026-02-17T16:13:06.101Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/82/61/e59168d4d0bf2bf90f4f0caf7a001bfc60254c3af4586013b04dc3ef517b/librt-0.11.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:78dc31f7fdfe9c9d0eb0e8f42d139db230e826415bbcabd9f0e9faaaee909894", size = 144119, upload-time = "2026-05-10T18:16:11.771Z" }, - { url = "https://files.pythonhosted.org/packages/61/fd/caa1d60b12f7dd79ccea23054e06eeaebe266a5f52c40a6b651069200ce5/librt-0.11.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:fa475675db22290c3158e1d42326d0f5a65f04f44a0e68c3630a25b53560fb9c", size = 143565, upload-time = "2026-05-10T18:16:13.334Z" }, - { url = "https://files.pythonhosted.org/packages/b8/a9/dc744f5c2b4978d48db970be29f22716d3413d28b14ad99740817315cf2c/librt-0.11.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:621db29691044bdeda22e789e482e1b0f3a985d90e3426c9c6d17606416205ea", size = 485395, upload-time = "2026-05-10T18:16:14.729Z" }, - { url = "https://files.pythonhosted.org/packages/8f/21/7f8e97a1e4dae952a5a95948f6f8507a173bc1e669f54340bba6ca1ca31b/librt-0.11.0-cp313-cp313-manylinux2014_i686.manylinux_2_17_i686.manylinux_2_28_i686.whl", hash = "sha256:a9010e2ed5b3a9e158c5fd966b3ab7e834bb3d3aacc8f66c91dd4b57a3799230", size = 479383, upload-time = "2026-05-10T18:16:16.321Z" }, - { url = "https://files.pythonhosted.org/packages/a6/6d/d8ee9c114bebf2c50e29ec2aa940826fccb62a645c3e4c18760987d0e16d/librt-0.11.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7c39513d8b7477a2e1ed8c43fc21c524e8d5a0f8d4e8b7b074dbdbe7820a08e2", size = 513010, upload-time = "2026-05-10T18:16:17.647Z" }, - { url = "https://files.pythonhosted.org/packages/f0/43/0b5708af2bd30a46400e72ba6bdaa8f066f15fb9a688527e34220e8d6c06/librt-0.11.0-cp313-cp313-manylinux_2_34_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:7aef3cf1d5af86e770ab04bfd993dfc4ae8b8c17f66fb77dd4a7d50de7bbb1a3", size = 508433, upload-time = "2026-05-10T18:16:19.309Z" }, - { url = "https://files.pythonhosted.org/packages/4a/50/356187247d09013490481033183b3532b58acf8028bcb34b2b56a375c9b2/librt-0.11.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:557183ddc36babe46b27dd60facbd5adb4492181a5be887587d57cda6e092f21", size = 522595, upload-time = "2026-05-10T18:16:20.642Z" }, - { url = "https://files.pythonhosted.org/packages/40/e7/c6ac4240899c7f3248079d5a9900debe0dadb3fdeaf856684c987105ba47/librt-0.11.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:83d3e1f72bd42f6c5c0b7daec530c3f829bd02db42c70b8ddf0c2d90a2459930", size = 527255, upload-time = "2026-05-10T18:16:22.352Z" }, - { url = "https://files.pythonhosted.org/packages/eb/b5/a81322dbeedeeaf9c1ee6f001734d28a09d8383ac9e6779bc24bbd0743c6/librt-0.11.0-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:4ce1f21fbe589bc1afd7872dece84fb0e1144f794a288e58a10d2c54a55c43be", size = 516847, upload-time = "2026-05-10T18:16:23.627Z" }, - { url = "https://files.pythonhosted.org/packages/ae/66/6e6323787d592b55204a42595ff1102da5115601b53a7e9ddebc889a6da5/librt-0.11.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:970b09f7044ea2b64c9da42fd3d335666518cfd1c6e8a182c95da73d0214b41e", size = 553920, upload-time = "2026-05-10T18:16:25.025Z" }, - { url = "https://files.pythonhosted.org/packages/9c/21/623f8ca230857102066d9ca8c6c1734995908c4d0d1bee7bb2ef0021cb33/librt-0.11.0-cp313-cp313-win32.whl", hash = "sha256:78fddc31cd4d3caa897ad5d31f856b1faadc9474021ad6cb182b9018793e254e", size = 101898, upload-time = "2026-05-10T18:16:26.649Z" }, - { url = "https://files.pythonhosted.org/packages/b3/1d/b4ebd44dd723f768469007515cb92251e0ae286c94c140f374801140fa74/librt-0.11.0-cp313-cp313-win_amd64.whl", hash = "sha256:8ca8aa88751a775870b764e93bad5135385f563cb8dcee399abf034ea4d3cb47", size = 119812, upload-time = "2026-05-10T18:16:27.859Z" }, - { url = "https://files.pythonhosted.org/packages/3b/e4/b2f4ca7965ca373b491cdb4bc25cdb30c1649ca81a8782056a83850292a9/librt-0.11.0-cp313-cp313-win_arm64.whl", hash = "sha256:96f044bb325fd9cf1a723015638c219e9143f0dfbc0ca54c565df2b7fc748b44", size = 103448, upload-time = "2026-05-10T18:16:29.066Z" }, + { url = "https://files.pythonhosted.org/packages/c5/3c/f614c8e4eaac7cbf2bbdf9528790b21d89e277ee20d57dc6e559c626105f/librt-0.8.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:7e6bad1cd94f6764e1e21950542f818a09316645337fd5ab9a7acc45d99a8f35", size = 66529, upload-time = "2026-02-17T16:11:57.809Z" }, + { url = "https://files.pythonhosted.org/packages/ab/96/5836544a45100ae411eda07d29e3d99448e5258b6e9c8059deb92945f5c2/librt-0.8.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:cf450f498c30af55551ba4f66b9123b7185362ec8b625a773b3d39aa1a717583", size = 68669, upload-time = "2026-02-17T16:11:58.843Z" }, + { url = "https://files.pythonhosted.org/packages/06/53/f0b992b57af6d5531bf4677d75c44f095f2366a1741fb695ee462ae04b05/librt-0.8.1-cp313-cp313-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:eca45e982fa074090057132e30585a7e8674e9e885d402eae85633e9f449ce6c", size = 199279, upload-time = "2026-02-17T16:11:59.862Z" }, + { url = "https://files.pythonhosted.org/packages/f3/ad/4848cc16e268d14280d8168aee4f31cea92bbd2b79ce33d3e166f2b4e4fc/librt-0.8.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0c3811485fccfda840861905b8c70bba5ec094e02825598bb9d4ca3936857a04", size = 210288, upload-time = "2026-02-17T16:12:00.954Z" }, + { url = "https://files.pythonhosted.org/packages/52/05/27fdc2e95de26273d83b96742d8d3b7345f2ea2bdbd2405cc504644f2096/librt-0.8.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5e4af413908f77294605e28cfd98063f54b2c790561383971d2f52d113d9c363", size = 224809, upload-time = "2026-02-17T16:12:02.108Z" }, + { url = "https://files.pythonhosted.org/packages/7a/d0/78200a45ba3240cb042bc597d6f2accba9193a2c57d0356268cbbe2d0925/librt-0.8.1-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:5212a5bd7fae98dae95710032902edcd2ec4dc994e883294f75c857b83f9aba0", size = 218075, upload-time = "2026-02-17T16:12:03.631Z" }, + { url = "https://files.pythonhosted.org/packages/af/72/a210839fa74c90474897124c064ffca07f8d4b347b6574d309686aae7ca6/librt-0.8.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:e692aa2d1d604e6ca12d35e51fdc36f4cda6345e28e36374579f7ef3611b3012", size = 225486, upload-time = "2026-02-17T16:12:04.725Z" }, + { url = "https://files.pythonhosted.org/packages/a3/c1/a03cc63722339ddbf087485f253493e2b013039f5b707e8e6016141130fa/librt-0.8.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:4be2a5c926b9770c9e08e717f05737a269b9d0ebc5d2f0060f0fe3fe9ce47acb", size = 218219, upload-time = "2026-02-17T16:12:05.828Z" }, + { url = "https://files.pythonhosted.org/packages/58/f5/fff6108af0acf941c6f274a946aea0e484bd10cd2dc37610287ce49388c5/librt-0.8.1-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:fd1a720332ea335ceb544cf0a03f81df92abd4bb887679fd1e460976b0e6214b", size = 218750, upload-time = "2026-02-17T16:12:07.09Z" }, + { url = "https://files.pythonhosted.org/packages/71/67/5a387bfef30ec1e4b4f30562c8586566faf87e47d696768c19feb49e3646/librt-0.8.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:93c2af9e01e0ef80d95ae3c720be101227edae5f2fe7e3dc63d8857fadfc5a1d", size = 241624, upload-time = "2026-02-17T16:12:08.43Z" }, + { url = "https://files.pythonhosted.org/packages/d4/be/24f8502db11d405232ac1162eb98069ca49c3306c1d75c6ccc61d9af8789/librt-0.8.1-cp313-cp313-win32.whl", hash = "sha256:086a32dbb71336627e78cc1d6ee305a68d038ef7d4c39aaff41ae8c9aa46e91a", size = 54969, upload-time = "2026-02-17T16:12:09.633Z" }, + { url = "https://files.pythonhosted.org/packages/5c/73/c9fdf6cb2a529c1a092ce769a12d88c8cca991194dfe641b6af12fa964d2/librt-0.8.1-cp313-cp313-win_amd64.whl", hash = "sha256:e11769a1dbda4da7b00a76cfffa67aa47cfa66921d2724539eee4b9ede780b79", size = 62000, upload-time = "2026-02-17T16:12:10.632Z" }, + { url = "https://files.pythonhosted.org/packages/d3/97/68f80ca3ac4924f250cdfa6e20142a803e5e50fca96ef5148c52ee8c10ea/librt-0.8.1-cp313-cp313-win_arm64.whl", hash = "sha256:924817ab3141aca17893386ee13261f1d100d1ef410d70afe4389f2359fea4f0", size = 52495, upload-time = "2026-02-17T16:12:11.633Z" }, ] [[package]] name = "llvmlite" -version = "0.47.0" +version = "0.46.0" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/01/88/a8952b6d5c21e74cbf158515b779666f692846502623e9e3c39d8e8ba25f/llvmlite-0.47.0.tar.gz", hash = "sha256:62031ce968ec74e95092184d4b0e857e444f8fdff0b8f9213707699570c33ccc", size = 193614, upload-time = "2026-03-31T18:29:53.497Z" } +sdist = { url = "https://files.pythonhosted.org/packages/74/cd/08ae687ba099c7e3d21fe2ea536500563ef1943c5105bf6ab4ee3829f68e/llvmlite-0.46.0.tar.gz", hash = "sha256:227c9fd6d09dce2783c18b754b7cd9d9b3b3515210c46acc2d3c5badd9870ceb", size = 193456, upload-time = "2025-12-08T18:15:36.295Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/77/6f/4615353e016799f80fa52ccb270a843c413b22361fadda2589b2922fb9b0/llvmlite-0.47.0-cp313-cp313-macosx_12_0_arm64.whl", hash = "sha256:a3c6a735d4e1041808434f9d440faa3d78d9b4af2ee64d05a66f351883b6ceec", size = 37232771, upload-time = "2026-03-31T18:29:01.324Z" }, - { url = "https://files.pythonhosted.org/packages/31/b8/69f5565f1a280d032525878a86511eebed0645818492feeb169dfb20ae8e/llvmlite-0.47.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:2699a74321189e812d476a43d6d7f652f51811e7b5aad9d9bba842a1c7927acb", size = 56275178, upload-time = "2026-03-31T18:29:05.748Z" }, - { url = "https://files.pythonhosted.org/packages/d6/da/b32cafcb926fb0ce2aa25553bf32cb8764af31438f40e2481df08884c947/llvmlite-0.47.0-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6c6951e2b29930227963e53ee152441f0e14be92e9d4231852102d986c761e40", size = 55128632, upload-time = "2026-03-31T18:29:11.235Z" }, - { url = "https://files.pythonhosted.org/packages/46/9f/4898b44e4042c60fafcb1162dfb7014f6f15b1ec19bf29cfea6bf26df90d/llvmlite-0.47.0-cp313-cp313-win_amd64.whl", hash = "sha256:c2e9adf8698d813a9a5efb2d4370caf344dbc1e145019851fee6a6f319ba760e", size = 38138695, upload-time = "2026-03-31T18:29:15.43Z" }, + { url = "https://files.pythonhosted.org/packages/e6/ff/3eba7eb0aed4b6fca37125387cd417e8c458e750621fce56d2c541f67fa8/llvmlite-0.46.0-cp313-cp313-macosx_12_0_arm64.whl", hash = "sha256:30b60892d034bc560e0ec6654737aaa74e5ca327bd8114d82136aa071d611172", size = 37232767, upload-time = "2025-12-08T18:15:13.22Z" }, + { url = "https://files.pythonhosted.org/packages/0e/54/737755c0a91558364b9200702c3c9c15d70ed63f9b98a2c32f1c2aa1f3ba/llvmlite-0.46.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:6cc19b051753368a9c9f31dc041299059ee91aceec81bd57b0e385e5d5bf1a54", size = 56275176, upload-time = "2025-12-08T18:15:16.339Z" }, + { url = "https://files.pythonhosted.org/packages/e6/91/14f32e1d70905c1c0aa4e6609ab5d705c3183116ca02ac6df2091868413a/llvmlite-0.46.0-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:bca185892908f9ede48c0acd547fe4dc1bafefb8a4967d47db6cf664f9332d12", size = 55128629, upload-time = "2025-12-08T18:15:19.493Z" }, + { url = "https://files.pythonhosted.org/packages/4a/a7/d526ae86708cea531935ae777b6dbcabe7db52718e6401e0fb9c5edea80e/llvmlite-0.46.0-cp313-cp313-win_amd64.whl", hash = "sha256:67438fd30e12349ebb054d86a5a1a57fd5e87d264d2451bcfafbbbaa25b82a35", size = 38138941, upload-time = "2025-12-08T18:15:22.536Z" }, ] [[package]] @@ -2275,14 +2295,14 @@ wheels = [ [[package]] name = "markdown-it-py" -version = "4.2.0" +version = "4.0.0" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "mdurl" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/06/ff/7841249c247aa650a76b9ee4bbaeae59370dc8bfd2f6c01f3630c35eb134/markdown_it_py-4.2.0.tar.gz", hash = "sha256:04a21681d6fbb623de53f6f364d352309d4094dd4194040a10fd51833e418d49", size = 82454, upload-time = "2026-05-07T12:08:28.36Z" } +sdist = { url = "https://files.pythonhosted.org/packages/5b/f5/4ec618ed16cc4f8fb3b701563655a69816155e79e24a17b651541804721d/markdown_it_py-4.0.0.tar.gz", hash = "sha256:cb0a2b4aa34f932c007117b194e945bd74e0ec24133ceb5bac59009cda1cb9f3", size = 73070, upload-time = "2025-08-11T12:57:52.854Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/b3/81/4da04ced5a082363ecfa159c010d200ecbd959ae410c10c0264a38cac0f5/markdown_it_py-4.2.0-py3-none-any.whl", hash = "sha256:9f7ebbcd14fe59494226453aed97c1070d83f8d24b6fc3a3bcf9a38092641c4a", size = 91687, upload-time = "2026-05-07T12:08:27.182Z" }, + { url = "https://files.pythonhosted.org/packages/94/54/e7d793b573f298e1c9013b8c4dade17d481164aa517d1d7148619c2cedbf/markdown_it_py-4.0.0-py3-none-any.whl", hash = "sha256:87327c59b172c5011896038353a81343b6754500a08cd7a4973bb48c6d578147", size = 87321, upload-time = "2025-08-11T12:57:51.923Z" }, ] [[package]] @@ -2360,14 +2380,14 @@ wheels = [ [[package]] name = "matplotlib-inline" -version = "0.2.2" +version = "0.2.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "traitlets" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/bd/c0/9f7c9a46090390368a4d7bcb76bb87a4a36c421e4c0792cdb53486ffac7a/matplotlib_inline-0.2.2.tar.gz", hash = "sha256:72f3fe8fce36b70d4a5b612f899090cd0401deddc4ea90e1572b9f4bfb058c79", size = 8150, upload-time = "2026-05-08T17:33:33.49Z" } +sdist = { url = "https://files.pythonhosted.org/packages/c7/74/97e72a36efd4ae2bccb3463284300f8953f199b5ffbc04cbbb0ec78f74b1/matplotlib_inline-0.2.1.tar.gz", hash = "sha256:e1ee949c340d771fc39e241ea75683deb94762c8fa5f2927ec57c83c4dffa9fe", size = 8110, upload-time = "2025-10-23T09:00:22.126Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/41/09/5b161152e2d90f7b87f781c2e1267494aef9c32498df793f73ad0a0a494a/matplotlib_inline-0.2.2-py3-none-any.whl", hash = "sha256:3c821cf1c209f59fb2d2d64abbf5b23b67bcb2210d663f9918dd851c6da1fcf6", size = 9534, upload-time = "2026-05-08T17:33:32.055Z" }, + { url = "https://files.pythonhosted.org/packages/af/33/ee4519fa02ed11a94aef9559552f3b17bb863f2ecfe1a35dc7f548cde231/matplotlib_inline-0.2.1-py3-none-any.whl", hash = "sha256:d56ce5156ba6085e00a9d54fead6ed29a9c47e215cd1bba2e976ef39f5710a76", size = 9516, upload-time = "2025-10-23T09:00:20.675Z" }, ] [[package]] @@ -2381,21 +2401,21 @@ wheels = [ [[package]] name = "microsoft-kiota-abstractions" -version = "1.10.3" +version = "1.9.10" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "opentelemetry-api" }, { name = "opentelemetry-sdk" }, { name = "std-uritemplate" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/c9/0f/e8f6ccdc2f22e6cd73da9dd2e5dd2f302664bf8ad6e775f0bf4cde08092e/microsoft_kiota_abstractions-1.10.3.tar.gz", hash = "sha256:07367351399396c1f1713a4ab112fd499f84fe019696ba477cf63d4ce48b8165", size = 24470, upload-time = "2026-06-08T16:42:38.823Z" } +sdist = { url = "https://files.pythonhosted.org/packages/45/e1/39de28380fc0eddf12f66099469fb7561bc38f577ea06e3a074751ebbcd9/microsoft_kiota_abstractions-1.9.10.tar.gz", hash = "sha256:8eb62d64c35ad0eeb4e8bcdbb143c0b308dc4a494e757f8e44cb959d34f44ecf", size = 24473, upload-time = "2026-03-12T17:27:15.398Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/40/08/51b75a9a0b7535ac2913b176474a31914c847f204e2ce17bb5dc57f68851/microsoft_kiota_abstractions-1.10.3-py3-none-any.whl", hash = "sha256:8f08c82f75362bb8525aad977c0d064dbf20c89219e31f5fea09a5728f8b1988", size = 44453, upload-time = "2026-06-08T16:42:39.716Z" }, + { url = "https://files.pythonhosted.org/packages/4d/59/bf0cb26c80fbd3fa882df8474ad87e9dbd742656c376388c427c4e314171/microsoft_kiota_abstractions-1.9.10-py3-none-any.whl", hash = "sha256:cd169067ebe48e6feea1258630807034239e0c61c2abe5fd66896a58177e8f05", size = 44462, upload-time = "2026-03-12T17:27:16.532Z" }, ] [[package]] name = "microsoft-kiota-authentication-azure" -version = "1.10.3" +version = "1.9.10" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "aiohttp" }, @@ -2404,14 +2424,14 @@ dependencies = [ { name = "opentelemetry-api" }, { name = "opentelemetry-sdk" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/fc/df/f95ebb712b99e4002558b5e60e2b066d98472257f7cf31f4f696b9c76100/microsoft_kiota_authentication_azure-1.10.3.tar.gz", hash = "sha256:7750bb002d2ab435cffcf609e9f35154ba391d5fa2452aea4fa6e673e2173b75", size = 5000, upload-time = "2026-06-08T16:42:50.335Z" } +sdist = { url = "https://files.pythonhosted.org/packages/d5/53/7760f979c141ec590f0c1cfcb92b3e410eb2909cc19feb42f3fce78db171/microsoft_kiota_authentication_azure-1.9.10.tar.gz", hash = "sha256:b9f10a9fa86e36114abfee448d2dab91a502d6a55d349a306e2e41a1218fe1ad", size = 4999, upload-time = "2026-03-12T17:27:26.323Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/f5/ce/d665f7180db22ef4e24e33ef84aacb56debc19330f9e671248669df6ee75/microsoft_kiota_authentication_azure-1.10.3-py3-none-any.whl", hash = "sha256:3b6589434b8a388b1520835cfd270ffee6e612b9511c6bbee06c8f9b51b600cb", size = 6954, upload-time = "2026-06-08T16:42:51.239Z" }, + { url = "https://files.pythonhosted.org/packages/1e/4a/e7852f9358d897ada1eec4e825c815761befe36df4defa79f1ae6c7b588c/microsoft_kiota_authentication_azure-1.9.10-py3-none-any.whl", hash = "sha256:b5d98b0d17173c61c0c7ab4274ea4ca69253b3c13424137758034506694964e9", size = 6961, upload-time = "2026-03-12T17:27:27.238Z" }, ] [[package]] name = "microsoft-kiota-http" -version = "1.10.3" +version = "1.9.10" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "httpx", extra = ["http2"] }, @@ -2419,57 +2439,57 @@ dependencies = [ { name = "opentelemetry-api" }, { name = "opentelemetry-sdk" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/cd/86/2d3fea265a2b8ae6b552ff84884baf76a5a49aed0259d004b969bf3960ca/microsoft_kiota_http-1.10.3.tar.gz", hash = "sha256:56e0e0799f6de04d56346b4ee6b18f6c79af02e6bd08064d875a3b05e375e7b4", size = 21521, upload-time = "2026-06-08T16:42:59.839Z" } +sdist = { url = "https://files.pythonhosted.org/packages/a7/e5/20972b620bd8cca086c284e97b285d437c108a23fee122ad7b92bd246c1a/microsoft_kiota_http-1.9.10.tar.gz", hash = "sha256:af1838d091f76426c974897357093ed977ce66f1d808cb161c190de873bb5833", size = 21493, upload-time = "2026-03-12T17:27:35.393Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/21/cf/04566ff5a0017700b8a7d07c75bb11f1b5570c12d5f43480b5b1cb72fe83/microsoft_kiota_http-1.10.3-py3-none-any.whl", hash = "sha256:5f025a5ec0e218d098b6f36982b75a5a9feb1be914d7ff409e525757d4de12e4", size = 31998, upload-time = "2026-06-08T16:43:00.721Z" }, + { url = "https://files.pythonhosted.org/packages/ce/f4/78ce18330a626138b2ff6bb62574adac01e8b9ee87c1349ddfeb9cab0556/microsoft_kiota_http-1.9.10-py3-none-any.whl", hash = "sha256:6127032c8d94f8607e4d36d0822b88bc8689ab368b4c00d6c7beb7d2d0f2ab10", size = 31960, upload-time = "2026-03-12T17:27:36.1Z" }, ] [[package]] name = "microsoft-kiota-serialization-form" -version = "1.10.3" +version = "1.9.10" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "microsoft-kiota-abstractions" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/d2/d8/9281bb1c46b4c818d7f91f10c9bd8e33340004f53079bf52e419342b3510/microsoft_kiota_serialization_form-1.10.3.tar.gz", hash = "sha256:323ad8856bcd3db74c9cf5950e22dc83e52713ad5aa4d7353d5650c518697c0e", size = 9254, upload-time = "2026-06-08T16:43:09.468Z" } +sdist = { url = "https://files.pythonhosted.org/packages/56/90/7e1a090a2099acae1a1baa9a0762214b73b63d9268369b510994f75f54e4/microsoft_kiota_serialization_form-1.9.10.tar.gz", hash = "sha256:4c6655d8cd479d1ada63fdfe6a272e50d87d7c8369dbc8e13833ba4787fc798b", size = 9012, upload-time = "2026-03-12T17:27:44.214Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/47/e8/7183acb4aba06168ca73ec20163914d30ad5f14075d07a41235e19a439e1/microsoft_kiota_serialization_form-1.10.3-py3-none-any.whl", hash = "sha256:f63dee0bf059804ce325aca8f14228f73598de25a3b9e56c3c32050e0427130d", size = 10876, upload-time = "2026-06-08T16:43:10.377Z" }, + { url = "https://files.pythonhosted.org/packages/d9/4c/5092fc896b34c21e8b9c03c63006b313a81e2377176a69c97aa6a9c8f5bb/microsoft_kiota_serialization_form-1.9.10-py3-none-any.whl", hash = "sha256:765d3f6408668f58bfdf892c32b45967c579d9131f3ba5a6b6868cb7ab956bfe", size = 10728, upload-time = "2026-03-12T17:27:45.103Z" }, ] [[package]] name = "microsoft-kiota-serialization-json" -version = "1.10.3" +version = "1.9.10" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "microsoft-kiota-abstractions" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/45/7c/81306c46b4c8b897d4d663bd1937376921029e163b9869e4ee7127076060/microsoft_kiota_serialization_json-1.10.3.tar.gz", hash = "sha256:84feb6b683289b7a8ca0495201050d36ce5ff28f384c24389f9e3fe221a38c93", size = 9893, upload-time = "2026-06-08T16:43:18.784Z" } +sdist = { url = "https://files.pythonhosted.org/packages/67/0e/55afd533a764ba77da988b7ca4242c84867a3a25f2ff0bf4c2b24b5e8fca/microsoft_kiota_serialization_json-1.9.10.tar.gz", hash = "sha256:6063028f30dd67afa2db20a72d9bde5e5d26d468f8bdedadd1445cf7c7630e17", size = 9746, upload-time = "2026-03-12T17:27:53.015Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/4d/78/679b45d37d7ac442df8d2f898306279fced3ef4d082586abc6da7495565c/microsoft_kiota_serialization_json-1.10.3-py3-none-any.whl", hash = "sha256:9e6453cef81e4d6c00596b920503097ea2be795e304e7212c65ed7ecea66001a", size = 11565, upload-time = "2026-06-08T16:43:19.679Z" }, + { url = "https://files.pythonhosted.org/packages/2f/56/d14c0185c8092abde1a60ad2bdd4480bb2ddb551ce71c6de1e6133a4d8d1/microsoft_kiota_serialization_json-1.9.10-py3-none-any.whl", hash = "sha256:0545ae910160b19caaa8c30c90c7416e1966294fbd6cc5af01f0e116a18f223a", size = 11452, upload-time = "2026-03-12T17:27:53.909Z" }, ] [[package]] name = "microsoft-kiota-serialization-multipart" -version = "1.10.3" +version = "1.9.10" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "microsoft-kiota-abstractions" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/05/aa/7cda18ec4dbf5ade90fd0ab7b5c40490fdb2107db9b80da1a4a44f2f8920/microsoft_kiota_serialization_multipart-1.10.3.tar.gz", hash = "sha256:916fc578522985876f615f35ba676ee4d1abdae26304bc0d248fb2e34212b897", size = 5161, upload-time = "2026-06-08T16:43:46.417Z" } +sdist = { url = "https://files.pythonhosted.org/packages/24/34/eadc15c2a3131e2a76126f3112c32b73502cb5a335e2e40cac2877e5d843/microsoft_kiota_serialization_multipart-1.9.10.tar.gz", hash = "sha256:8f2da4f93e79b09f9738b6889685e47acfafcca870db94ab1d4cd233d69e4268", size = 5167, upload-time = "2026-03-12T17:28:18.507Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/99/95/46aaa27f90f86e00e0c45cb7e0642cb7e2c7e830565de1a81818315d5997/microsoft_kiota_serialization_multipart-1.10.3-py3-none-any.whl", hash = "sha256:9153e944ff0018f6c1b650f9e79599d7d473932a8acd4713655be45a01f5a538", size = 6698, upload-time = "2026-06-08T16:43:47.19Z" }, + { url = "https://files.pythonhosted.org/packages/fa/40/345cbcee6c52b4261fedf4ae2ff8573aec47ce4ae2015ea8b57c75ef978b/microsoft_kiota_serialization_multipart-1.9.10-py3-none-any.whl", hash = "sha256:7cadc26483b567c738f926b044521569e0b797446053c9e8eab02269d4a81062", size = 6708, upload-time = "2026-03-12T17:28:19.397Z" }, ] [[package]] name = "microsoft-kiota-serialization-text" -version = "1.10.3" +version = "1.9.10" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "microsoft-kiota-abstractions" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/ff/69/2e135c222fffffc4ff42b7046da6e0be7c3ad91d946d313da70eb8a81815/microsoft_kiota_serialization_text-1.10.3.tar.gz", hash = "sha256:0db370ccbbfded4e9e01c2f967850478cd1198c748f3baef60abec0c10e58e0f", size = 7323, upload-time = "2026-06-08T16:43:28.159Z" } +sdist = { url = "https://files.pythonhosted.org/packages/74/a6/28a4a8d5c01f08e363135fc9585cab3c02d1b1a69c3c16032e6abb35dfed/microsoft_kiota_serialization_text-1.9.10.tar.gz", hash = "sha256:cfc433c2a95ea3c3ec43c8b09002fbf65c998c5c0571205df161fe0e9d5d8de7", size = 7326, upload-time = "2026-03-12T17:28:01.621Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/5c/92/f55e69d723fd237f02e6291c9dfecfde3e5aed26ce65f8069e03589b2822/microsoft_kiota_serialization_text-1.10.3-py3-none-any.whl", hash = "sha256:4ffca348d9af69431a455a5778929398d4cba78178906b0ad31db95fb3418aea", size = 8887, upload-time = "2026-06-08T16:43:29.041Z" }, + { url = "https://files.pythonhosted.org/packages/dd/bf/dd36e4a6d1cff3f2d30f03e2479cd38210e32d4715bb6a9f0e2737f13604/microsoft_kiota_serialization_text-1.9.10-py3-none-any.whl", hash = "sha256:742890cfd4450d12f58d42da7cfa474fe1ee5d6442e016bf70ab76e5c876c0ea", size = 8896, upload-time = "2026-03-12T17:28:02.328Z" }, ] [[package]] @@ -2518,26 +2538,26 @@ wheels = [ [[package]] name = "msgpack" -version = "1.2.0" +version = "1.2.1" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/92/23/6139781ca7aadf656fa8e384fa84693ffb13f299e6931b6526427fe5e297/msgpack-1.2.0.tar.gz", hash = "sha256:8e17af38197bf58e7e819041678f6178f4491493f5b8c8580414f40f7c2c3c41", size = 183017, upload-time = "2026-06-11T04:16:10.775Z" } +sdist = { url = "https://files.pythonhosted.org/packages/31/f9/c0a1c127f9049db9155afc316952ea571720dd01833ff5e4d7e8e6352dbb/msgpack-1.2.1.tar.gz", hash = "sha256:04c721c2c7448767e9e3f2520a475663d8ee0f09c31890f6d2bd70fd636a9647", size = 183960, upload-time = "2026-06-18T16:13:52.594Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/7d/26/2902c6946ab5c8fe1e46e40842dfc32b8824464ad5cd4725364fd83f7a58/msgpack-1.2.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:3a1d30df1f302f2b7a7404afbac2ab76d510036c34cf34dffb01f704a7288e45", size = 82621, upload-time = "2026-06-11T04:15:23.844Z" }, - { url = "https://files.pythonhosted.org/packages/c9/59/7e6b812629d2f919e586041bffc130e1af32079f71bb20699eed54ed6d92/msgpack-1.2.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:581e317112260d8ca488d490cad9290a5682276f309c41c7de237a85ed8799c8", size = 81866, upload-time = "2026-06-11T04:15:25.032Z" }, - { url = "https://files.pythonhosted.org/packages/31/13/8c291196e60aafdbae38f482205d79432297749ac5d412fe638154fb6f1d/msgpack-1.2.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c6827d12eacc16873eba62408a1b7bbe8ecfb4a8f7ed78a631ae9bae6ad43cf2", size = 405618, upload-time = "2026-06-11T04:15:26.235Z" }, - { url = "https://files.pythonhosted.org/packages/fb/63/68f5d0ea81e167db5f59ddb94dc6f837667062113feff1c73fabf8907061/msgpack-1.2.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a186027e4279efa4c8bf06ce30605498d7d0d3af0fba0b9799dce85a3fd4a93c", size = 416468, upload-time = "2026-06-11T04:15:27.732Z" }, - { url = "https://files.pythonhosted.org/packages/73/58/567dddf5c5a2790f673bcd7d80c83466d68e5ee9a9674ebca3db8101c0c8/msgpack-1.2.0-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:a96142c14a11cf1a509e8b9aaf72858a3b742b7613e095ce646913e88ce7bd99", size = 374464, upload-time = "2026-06-11T04:15:29.286Z" }, - { url = "https://files.pythonhosted.org/packages/0d/30/0c2342fc9092e4498045f5f60bca6ccbe4f4d87789778c2300e6fd6efe82/msgpack-1.2.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:50c220579b68a6085b95408b2eaa486b259520f55d8e363ddc9b5d7ba5a6ac6d", size = 395879, upload-time = "2026-06-11T04:15:30.973Z" }, - { url = "https://files.pythonhosted.org/packages/b9/11/9565b29b58ce3c33e177b490478b7aaeb8f726ecaaeda26d815893c1db5a/msgpack-1.2.0-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:4dcb9d12ab100ecacdfaaf37a3d72fe8392eacc7054afc1916b12d1b747c8446", size = 371749, upload-time = "2026-06-11T04:15:32.418Z" }, - { url = "https://files.pythonhosted.org/packages/f2/da/7bade19d60b73e2ef73fb76aaf4504c112a70cb760951b7202a0c64b5111/msgpack-1.2.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:a804727188ab0ebb237fadb303b743f04925a69d8c3247292d1e33e679767c15", size = 410416, upload-time = "2026-06-11T04:15:34.053Z" }, - { url = "https://files.pythonhosted.org/packages/6d/14/c0c619571c02432208a5977a8dbdd3fc65fe1369f8226ca4b6d08cca87d8/msgpack-1.2.0-cp313-cp313-win32.whl", hash = "sha256:1a1ac6ae1fe23298f79380e7b144c8a454e5d05616b0096584f353ba2d750114", size = 64357, upload-time = "2026-06-11T04:15:35.535Z" }, - { url = "https://files.pythonhosted.org/packages/50/a5/de06718460909aa965737fec4cfe8a15dedc6544a8c55feeb6956fa0d6e3/msgpack-1.2.0-cp313-cp313-win_amd64.whl", hash = "sha256:1c3c80949d79578f9dc85fd9fb91edfe6694e8a729cd5744634d59d8455fdde3", size = 71057, upload-time = "2026-06-11T04:15:36.83Z" }, - { url = "https://files.pythonhosted.org/packages/c7/52/73446b0141c94a856e22b787c56709c0815fc34f185326577e15b26d8cfe/msgpack-1.2.0-cp313-cp313-win_arm64.whl", hash = "sha256:fcf8f76fa587c2395fd0057c7232dbf071241f9ad280b235adb7ab585289989e", size = 64490, upload-time = "2026-06-11T04:15:38.001Z" }, + { url = "https://files.pythonhosted.org/packages/b0/ac/dcddcab6f6c20ecb387ca5e980371cdb3f87ff69aeca388be97eebc4c074/msgpack-1.2.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:0a70e3cf2804a300d921bb0940426e35f4e489a23adfb77a808892241db0a064", size = 83151, upload-time = "2026-06-18T16:13:12.173Z" }, + { url = "https://files.pythonhosted.org/packages/64/71/fbcfa83a1d6a9c6091942d1cfd070962244664b87427a9a49a6897b1b219/msgpack-1.2.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:491cc39455ca765fad51fb451bf2915eb2cf41192ab5801ce8d67c1d614fe056", size = 82351, upload-time = "2026-06-18T16:13:13.194Z" }, + { url = "https://files.pythonhosted.org/packages/e3/10/ddf7b06db879e8792d13934ddda09ff20bd2a583fd84c9b59aae9b0e650b/msgpack-1.2.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f310233ef7fb9c14e201c93639fe5f5260b005f56f0b29048e999c30935596cc", size = 407518, upload-time = "2026-06-18T16:13:14.233Z" }, + { url = "https://files.pythonhosted.org/packages/79/d3/36a46a8ed992b781acbc05928bd5bee3c810cb0c3563bf81a7b0c04a1a76/msgpack-1.2.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:787c9bebb5833e8f6fc8abca3c0597683d8d87f56a8842b6b89c75a5f3176e2d", size = 416405, upload-time = "2026-06-18T16:13:15.435Z" }, + { url = "https://files.pythonhosted.org/packages/f9/84/e8e9598b557c0ba6ddae901a73780a4c75ac667dddf59414b1e56a42fb34/msgpack-1.2.1-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:dc871b997a9370d855b7394465f2f350e847a5b806dd38dcc9c989e7d87da155", size = 376257, upload-time = "2026-06-18T16:13:17.022Z" }, + { url = "https://files.pythonhosted.org/packages/40/16/738fe6d875ad7e2a9429c165322a4ec088f4f273cdfae63d96a89c467961/msgpack-1.2.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:85f57e960d877f2977f6430896191b04a21f8901b3b4baf2e4604329f4db5402", size = 397469, upload-time = "2026-06-18T16:13:18.287Z" }, + { url = "https://files.pythonhosted.org/packages/ca/be/6d5952df75a7f24f35833af764c3a6860780364cb3a0030beb8099e1b2b4/msgpack-1.2.1-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:1233ee2dd0cefba127583de50ea654677277047d238303521db35def3d7b2e7c", size = 372802, upload-time = "2026-06-18T16:13:19.685Z" }, + { url = "https://files.pythonhosted.org/packages/e1/39/e2ef7dbf0473bcb8dc7c50bf782a892d67414877b63e47fc88eb189ef5e6/msgpack-1.2.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:e3dc2feb0876209d9c38aa56cb1de169bd6c4348f1aa48271f241226590993e6", size = 411273, upload-time = "2026-06-18T16:13:21.028Z" }, + { url = "https://files.pythonhosted.org/packages/ef/c5/133f4512a56e983a93445c836c9d94d88f3bc2e0980ff4b9e577bd8416ce/msgpack-1.2.1-cp313-cp313-win32.whl", hash = "sha256:6d09badf350af2be9d189184e04e64cf54ad93569ab3d96fca58bd3e84aad707", size = 64471, upload-time = "2026-06-18T16:13:22.293Z" }, + { url = "https://files.pythonhosted.org/packages/e2/98/577e10b055096a7dd40732358cabaf7180a20c79ed1dcdbb618e4b9deac7/msgpack-1.2.1-cp313-cp313-win_amd64.whl", hash = "sha256:33f14fba63278b714efe6ad07e50ea5f03d91537aa6a1c5f1ceca4cf44013ca9", size = 71274, upload-time = "2026-06-18T16:13:23.455Z" }, + { url = "https://files.pythonhosted.org/packages/ba/ee/0c0048e7cfbef23c6a94791b8959ab28155232e7956de8a305b5ff588f05/msgpack-1.2.1-cp313-cp313-win_arm64.whl", hash = "sha256:afc5febcd4c99effbc02b528e49d6fd0760b2b7d48c05239e345a5fa6e743d9a", size = 64795, upload-time = "2026-06-18T16:13:24.687Z" }, ] [[package]] name = "msgraph-core" -version = "1.4.0" +version = "1.3.8" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "httpx", extra = ["http2"] }, @@ -2545,9 +2565,9 @@ dependencies = [ { name = "microsoft-kiota-authentication-azure" }, { name = "microsoft-kiota-http" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/b6/92/e74e204ac240a1817817d50074599af1e0331608c5ee58a1836e40f39c2e/msgraph_core-1.4.0.tar.gz", hash = "sha256:5f0dee9564a0e20edfb2eb7137fe189d7d204a80a87d6d83d69d31269376e1b1", size = 25534, upload-time = "2026-05-20T00:30:07.761Z" } +sdist = { url = "https://files.pythonhosted.org/packages/68/4e/123f9530ec43b306c597bb830c62bedab830ffa76e0edf33ea88a26f756e/msgraph_core-1.3.8.tar.gz", hash = "sha256:6e883f9d4c4ad57501234749e07b010478c1a5f19550ef4cf005bbcac4a63ae7", size = 25506, upload-time = "2025-09-11T22:46:57.267Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/7a/9e/bea07e8eea0fa7d7a6665eb6e11d83db69a35f2603e5ace060893ea46de6/msgraph_core-1.4.0-py3-none-any.whl", hash = "sha256:a325285728df106386094bec13f6e6a9df690560578f72012f691343295a649c", size = 34472, upload-time = "2026-05-20T00:30:06.503Z" }, + { url = "https://files.pythonhosted.org/packages/cf/4d/01432f60727ae452787014cad0d5bc9e035c6e11a670f12c23f7fc926d90/msgraph_core-1.3.8-py3-none-any.whl", hash = "sha256:86d83edcf62119946f201d13b7e857c947ef67addb088883940197081de85bea", size = 34473, upload-time = "2025-09-11T22:46:56.026Z" }, ] [[package]] @@ -2730,18 +2750,18 @@ wheels = [ [[package]] name = "numba" -version = "0.65.1" +version = "0.64.0" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "llvmlite" }, { name = "numpy" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/f6/c5/db2ac3685833d626c0dcae6bd2330cd68433e1fd248d15f70998160d3ad7/numba-0.65.1.tar.gz", hash = "sha256:19357146c32fe9ed25059ab915e8465fb13951cf6b0aace3826b76886373ab23", size = 2765600, upload-time = "2026-04-24T02:02:56.551Z" } +sdist = { url = "https://files.pythonhosted.org/packages/23/c9/a0fb41787d01d621046138da30f6c2100d80857bf34b3390dd68040f27a3/numba-0.64.0.tar.gz", hash = "sha256:95e7300af648baa3308127b1955b52ce6d11889d16e8cfe637b4f85d2fca52b1", size = 2765679, upload-time = "2026-02-18T18:41:20.974Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/79/37/14a4579049c1eb673afd0de0cb4842982acd55b9ce2643e763db858bcea0/numba-0.65.1-cp313-cp313-macosx_12_0_arm64.whl", hash = "sha256:1735c15c1134a5108b4d6a5c77fc0947924ea066a738dc09a52008c13df9cad3", size = 2681344, upload-time = "2026-04-24T02:02:33.65Z" }, - { url = "https://files.pythonhosted.org/packages/a0/22/b8d873f6466b20aa563fc9b33acd48dec89a07803ddaa2f1c8ca1cd33126/numba-0.65.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:c09f49117ef255e1f1c6dad0c7a1ed39868243862a73be5706793241a3755f1b", size = 3810619, upload-time = "2026-04-24T02:02:36.041Z" }, - { url = "https://files.pythonhosted.org/packages/62/08/e16a8b5d9a018962ebb5c66be662317cde32b9f5dab08441f90bed5522fb/numba-0.65.1-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:594a8680b3fadac99e97e489b1fd89007177e5336713745c3b769528c635a464", size = 3509783, upload-time = "2026-04-24T02:02:38.245Z" }, - { url = "https://files.pythonhosted.org/packages/fd/a5/03c970d57f4c1741354837353ce39fb5206952ae1dba8922d29c86f64805/numba-0.65.1-cp313-cp313-win_amd64.whl", hash = "sha256:85be74c0d036842699a30058f82fb88fc5ffdc59f7615cab5792ea92914c9b62", size = 2750534, upload-time = "2026-04-24T02:02:39.903Z" }, + { url = "https://files.pythonhosted.org/packages/52/80/2734de90f9300a6e2503b35ee50d9599926b90cbb7ac54f9e40074cd07f1/numba-0.64.0-cp313-cp313-macosx_12_0_arm64.whl", hash = "sha256:3bab2c872194dcd985f1153b70782ec0fbbe348fffef340264eacd3a76d59fd6", size = 2683392, upload-time = "2026-02-18T18:41:06.563Z" }, + { url = "https://files.pythonhosted.org/packages/42/e8/14b5853ebefd5b37723ef365c5318a30ce0702d39057eaa8d7d76392859d/numba-0.64.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:703a246c60832cad231d2e73c1182f25bf3cc8b699759ec8fe58a2dbc689a70c", size = 3812245, upload-time = "2026-02-18T18:41:07.963Z" }, + { url = "https://files.pythonhosted.org/packages/8a/a2/f60dc6c96d19b7185144265a5fbf01c14993d37ff4cd324b09d0212aa7ce/numba-0.64.0-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7e2e49a7900ee971d32af7609adc0cfe6aa7477c6f6cccdf6d8138538cf7756f", size = 3511328, upload-time = "2026-02-18T18:41:09.504Z" }, + { url = "https://files.pythonhosted.org/packages/9c/2a/fe7003ea7e7237ee7014f8eaeeb7b0d228a2db22572ca85bab2648cf52cb/numba-0.64.0-cp313-cp313-win_amd64.whl", hash = "sha256:396f43c3f77e78d7ec84cdfc6b04969c78f8f169351b3c4db814b97e7acf4245", size = 2752668, upload-time = "2026-02-18T18:41:11.455Z" }, ] [[package]] @@ -3042,41 +3062,42 @@ wheels = [ [[package]] name = "opentelemetry-api" -version = "1.42.1" +version = "1.40.0" source = { registry = "https://pypi.org/simple" } dependencies = [ + { name = "importlib-metadata" }, { name = "typing-extensions" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/b4/1c/125e1c936c0873796771b7f04f6c93b9f1bf5d424cea90fda94a99f61da8/opentelemetry_api-1.42.1.tar.gz", hash = "sha256:56c63bea9f77b62856be8c47600474acad853b2924b99b1687c4cb6297166716", size = 72296, upload-time = "2026-05-21T16:32:49.335Z" } +sdist = { url = "https://files.pythonhosted.org/packages/2c/1d/4049a9e8698361cc1a1aa03a6c59e4fa4c71e0c0f94a30f988a6876a2ae6/opentelemetry_api-1.40.0.tar.gz", hash = "sha256:159be641c0b04d11e9ecd576906462773eb97ae1b657730f0ecf64d32071569f", size = 70851, upload-time = "2026-03-04T14:17:21.555Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/a3/ca/9520cc1f3dfbbd03ac5903bbf55833e257bc64b1cf30fa8b0d6df374d821/opentelemetry_api-1.42.1-py3-none-any.whl", hash = "sha256:51a69edacadbc03a8950ace1c4c21099cacc538820ac2c9e36277e78cebba714", size = 61311, upload-time = "2026-05-21T16:32:28.822Z" }, + { url = "https://files.pythonhosted.org/packages/5f/bf/93795954016c522008da367da292adceed71cca6ee1717e1d64c83089099/opentelemetry_api-1.40.0-py3-none-any.whl", hash = "sha256:82dd69331ae74b06f6a874704be0cfaa49a1650e1537d4a813b86ecef7d0ecf9", size = 68676, upload-time = "2026-03-04T14:17:01.24Z" }, ] [[package]] name = "opentelemetry-sdk" -version = "1.42.1" +version = "1.40.0" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "opentelemetry-api" }, { name = "opentelemetry-semantic-conventions" }, { name = "typing-extensions" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/40/f7/b390bd9bfd703bf98a68fea1f27786c6872331fd617164a54b8a59bdc008/opentelemetry_sdk-1.42.1.tar.gz", hash = "sha256:8c834e8f8c9ba4171d4ec843d0cb8a67e4c7394d3f9e9297e582cbd9456ddbf7", size = 239262, upload-time = "2026-05-21T16:33:04.641Z" } +sdist = { url = "https://files.pythonhosted.org/packages/58/fd/3c3125b20ba18ce2155ba9ea74acb0ae5d25f8cd39cfd37455601b7955cc/opentelemetry_sdk-1.40.0.tar.gz", hash = "sha256:18e9f5ec20d859d268c7cb3c5198c8d105d073714db3de50b593b8c1345a48f2", size = 184252, upload-time = "2026-03-04T14:17:31.87Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/8f/6b/4287766cfbde577ae2272e8884abac325aeaac0d64f41c61d5b8cc595105/opentelemetry_sdk-1.42.1-py3-none-any.whl", hash = "sha256:083cd4bbfaa5aa7b5a9e552430d9951219967cfb27aa61feb13a77aba1fc839d", size = 170907, upload-time = "2026-05-21T16:32:45.894Z" }, + { url = "https://files.pythonhosted.org/packages/2c/c5/6a852903d8bfac758c6dc6e9a68b015d3c33f2f1be5e9591e0f4b69c7e0a/opentelemetry_sdk-1.40.0-py3-none-any.whl", hash = "sha256:787d2154a71f4b3d81f20524a8ce061b7db667d24e46753f32a7bc48f1c1f3f1", size = 141951, upload-time = "2026-03-04T14:17:17.961Z" }, ] [[package]] name = "opentelemetry-semantic-conventions" -version = "0.63b1" +version = "0.61b0" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "opentelemetry-api" }, { name = "typing-extensions" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/93/99/4d7dd6df64795951413ce6e815f8cf1eb191daf7196ae86574589643d5f3/opentelemetry_semantic_conventions-0.63b1.tar.gz", hash = "sha256:3daf963611334b365e98a57438183eb012d3bfb40b2d931a9af613476b8701a9", size = 148340, upload-time = "2026-05-21T16:33:05.455Z" } +sdist = { url = "https://files.pythonhosted.org/packages/6d/c0/4ae7973f3c2cfd2b6e321f1675626f0dab0a97027cc7a297474c9c8f3d04/opentelemetry_semantic_conventions-0.61b0.tar.gz", hash = "sha256:072f65473c5d7c6dc0355b27d6c9d1a679d63b6d4b4b16a9773062cb7e31192a", size = 145755, upload-time = "2026-03-04T14:17:32.664Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/cb/7a/7fe66f5f3682b1dd47d88cc4e11f1c6c0966b737de2d16671146e23c39a5/opentelemetry_semantic_conventions-0.63b1-py3-none-any.whl", hash = "sha256:dfe5ef4dee82586b746f522b818ceb298d00b3d59f660042bd79404bff8d0682", size = 203713, upload-time = "2026-05-21T16:32:47.016Z" }, + { url = "https://files.pythonhosted.org/packages/b2/37/cc6a55e448deaa9b27377d087da8615a3416d8ad523d5960b78dbeadd02a/opentelemetry_semantic_conventions-0.61b0-py3-none-any.whl", hash = "sha256:fa530a96be229795f8cef353739b618148b0fe2b4b3f005e60e262926c4d38e2", size = 231621, upload-time = "2026-03-04T14:17:19.33Z" }, ] [[package]] @@ -3169,11 +3190,11 @@ wheels = [ [[package]] name = "parso" -version = "0.8.7" +version = "0.8.6" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/30/4b/90c937815137d43ce71ba043cd3566221e9df6b9c805f24b5d138c9d40a7/parso-0.8.7.tar.gz", hash = "sha256:eaaac4c9fdd5e9e8852dc778d2d7405897ec510f2a298071453e5e3a07914bb1", size = 401824, upload-time = "2026-05-01T23:13:02.138Z" } +sdist = { url = "https://files.pythonhosted.org/packages/81/76/a1e769043c0c0c9fe391b702539d594731a4362334cdf4dc25d0c09761e7/parso-0.8.6.tar.gz", hash = "sha256:2b9a0332696df97d454fa67b81618fd69c35a7b90327cbe6ba5c92d2c68a7bfd", size = 401621, upload-time = "2026-02-09T15:45:24.425Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/99/5d/8268b644392ee874ee82a635cd0df1773de230bde356c38de28e298392cc/parso-0.8.7-py2.py3-none-any.whl", hash = "sha256:a8926eb2a1b915486941fdbd31e86a4baf88fe8c210f25f2f35ecec5b574ca1c", size = 107025, upload-time = "2026-05-01T23:12:58.867Z" }, + { url = "https://files.pythonhosted.org/packages/b6/61/fae042894f4296ec49e3f193aff5d7c18440da9e48102c3315e1bc4519a7/parso-0.8.6-py2.py3-none-any.whl", hash = "sha256:2c549f800b70a5c4952197248825584cb00f033b29c692671d3bf08bf380baff", size = 106894, upload-time = "2026-02-09T15:45:21.391Z" }, ] [[package]] @@ -3191,11 +3212,11 @@ wheels = [ [[package]] name = "pathspec" -version = "1.1.1" +version = "1.0.4" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/5a/82/42f767fc1c1143d6fd36efb827202a2d997a375e160a71eb2888a925aac1/pathspec-1.1.1.tar.gz", hash = "sha256:17db5ecd524104a120e173814c90367a96a98d07c45b2e10c2f3919fff91bf5a", size = 135180, upload-time = "2026-04-27T01:46:08.907Z" } +sdist = { url = "https://files.pythonhosted.org/packages/fa/36/e27608899f9b8d4dff0617b2d9ab17ca5608956ca44461ac14ac48b44015/pathspec-1.0.4.tar.gz", hash = "sha256:0210e2ae8a21a9137c0d470578cb0e595af87edaa6ebf12ff176f14a02e0e645", size = 131200, upload-time = "2026-01-27T03:59:46.938Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/f1/d9/7fb5aa316bc299258e68c73ba3bddbc499654a07f151cba08f6153988714/pathspec-1.1.1-py3-none-any.whl", hash = "sha256:a00ce642f577bf7f473932318056212bc4f8bfdf53128c78bbd5af0b9b20b189", size = 57328, upload-time = "2026-04-27T01:46:07.06Z" }, + { url = "https://files.pythonhosted.org/packages/ef/3c/2c197d226f9ea224a9ab8d197933f9da0ae0aac5b6e0f884e2b8d9c8e9f7/pathspec-1.0.4-py3-none-any.whl", hash = "sha256:fb6ae2fd4e7c921a165808a552060e722767cfa526f99ca5156ed2ce45a5c723", size = 55206, upload-time = "2026-01-27T03:59:45.137Z" }, ] [[package]] @@ -3225,7 +3246,7 @@ wheels = [ [[package]] name = "peft" -version = "0.19.1" +version = "0.18.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "accelerate" }, @@ -3239,9 +3260,9 @@ dependencies = [ { name = "tqdm" }, { name = "transformers" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/86/cf/037f1e3d5186496c05513a6754639e2dab3038a05f384284d49a9bd06a2d/peft-0.19.1.tar.gz", hash = "sha256:0d97542fe96dcdaa20d3b81c06f26f988618f416a73544ab23c3618ccb674a40", size = 763738, upload-time = "2026-04-16T15:46:45.105Z" } +sdist = { url = "https://files.pythonhosted.org/packages/d8/48/147b3ea999560b40a34fd78724c7777aa9d18409c2250bdcaf9c4f2db7fc/peft-0.18.1.tar.gz", hash = "sha256:2dd0d6bfce936d1850e48aaddbd250941c5c02fc8ef3237cd8fd5aac35e0bae2", size = 635030, upload-time = "2026-01-09T13:08:01.136Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/e8/b6/f54d676ed93cc2dd2234c3b172ea9c8c3d7d29361e66b1b23dec57a67465/peft-0.19.1-py3-none-any.whl", hash = "sha256:2113f72a81621b5913ef28f9022204c742df111890c5f49d812716a4a301e356", size = 680692, upload-time = "2026-04-16T15:46:42.886Z" }, + { url = "https://files.pythonhosted.org/packages/b3/14/b4e3f574acf349ae6f61f9c000a77f97a3b315b4bb6ad03791e79ae4a568/peft-0.18.1-py3-none-any.whl", hash = "sha256:0bf06847a3551e3019fc58c440cffc9a6b73e6e2962c95b52e224f77bbdb50f1", size = 556960, upload-time = "2026-01-09T13:07:55.865Z" }, ] [[package]] @@ -3330,11 +3351,11 @@ wheels = [ [[package]] name = "platformdirs" -version = "4.10.0" +version = "4.9.4" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/d7/47/e4501f49c178ae1d9f4a75073fda4204f52647993f075a9db4d14930e0c5/platformdirs-4.10.0.tar.gz", hash = "sha256:31e761a6a0ca04faf7353ea759bdba55652be214725111e5aac52dfa29d4bef7", size = 31224, upload-time = "2026-05-28T03:32:53.587Z" } +sdist = { url = "https://files.pythonhosted.org/packages/19/56/8d4c30c8a1d07013911a8fdbd8f89440ef9f08d07a1b50ab8ca8be5a20f9/platformdirs-4.9.4.tar.gz", hash = "sha256:1ec356301b7dc906d83f371c8f487070e99d3ccf9e501686456394622a01a934", size = 28737, upload-time = "2026-03-05T18:34:13.271Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/81/e6/cd9575ac904136b3cbf7aa7ee819ef86eedb7274e46f230e94ea4342e729/platformdirs-4.10.0-py3-none-any.whl", hash = "sha256:fb516cdb12eb0d857d0cd85a7c57cea4d060bee4578d6cf5a14dfdf8cbf8784a", size = 22743, upload-time = "2026-05-28T03:32:52.175Z" }, + { url = "https://files.pythonhosted.org/packages/63/d7/97f7e3a6abb67d8080dd406fd4df842c2be0efaf712d1c899c32a075027c/platformdirs-4.9.4-py3-none-any.whl", hash = "sha256:68a9a4619a666ea6439f2ff250c12a853cd1cbd5158d258bd824a7df6be2f868", size = 21216, upload-time = "2026-03-05T18:34:12.172Z" }, ] [[package]] @@ -3499,24 +3520,24 @@ wheels = [ [[package]] name = "pyarrow" -version = "24.0.0" +version = "23.0.1" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/91/13/13e1069b351bdc3881266e11147ffccf687505dbb0ea74036237f5d454a5/pyarrow-24.0.0.tar.gz", hash = "sha256:85fe721a14dd823aca09127acbb06c3ca723efbd436c004f16bca601b04dcc83", size = 1180261, upload-time = "2026-04-21T10:51:25.837Z" } +sdist = { url = "https://files.pythonhosted.org/packages/88/22/134986a4cc224d593c1afde5494d18ff629393d74cc2eddb176669f234a4/pyarrow-23.0.1.tar.gz", hash = "sha256:b8c5873e33440b2bc2f4a79d2b47017a89c5a24116c055625e6f2ee50523f019", size = 1167336, upload-time = "2026-02-16T10:14:12.39Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/6f/d3/a1abf004482026ddc17f4503db227787fa3cfe41ec5091ff20e4fea55e57/pyarrow-24.0.0-cp313-cp313-macosx_12_0_arm64.whl", hash = "sha256:02b001b3ed4723caa44f6cd1af2d5c86aa2cf9971dacc2ffa55b21237713dfba", size = 34976759, upload-time = "2026-04-21T10:48:07.258Z" }, - { url = "https://files.pythonhosted.org/packages/4f/4a/34f0a36d28a2dd32225301b79daad44e243dc1a2bb77d43b60749be255c4/pyarrow-24.0.0-cp313-cp313-macosx_12_0_x86_64.whl", hash = "sha256:04920d6a71aabd08a0417709efce97d45ea8e6fb733d9ca9ecffb13c67839f68", size = 36658471, upload-time = "2026-04-21T10:48:13.347Z" }, - { url = "https://files.pythonhosted.org/packages/1f/78/543b94712ae8bb1a6023bcc1acf1a740fbff8286747c289cd9468fced2a5/pyarrow-24.0.0-cp313-cp313-manylinux_2_28_aarch64.whl", hash = "sha256:a964266397740257f16f7bb2e4f08a0c81454004beab8ff59dd531b73610e9f2", size = 45675981, upload-time = "2026-04-21T10:48:20.201Z" }, - { url = "https://files.pythonhosted.org/packages/84/9f/8fb7c222b100d314137fa40ec050de56cd8c6d957d1cfff685ce72f15b17/pyarrow-24.0.0-cp313-cp313-manylinux_2_28_x86_64.whl", hash = "sha256:6f066b179d68c413374294bc1735f68475457c933258df594443bb9d88ddc2a0", size = 48859172, upload-time = "2026-04-21T10:48:27.541Z" }, - { url = "https://files.pythonhosted.org/packages/a7/d3/1ea72538e6c8b3b475ed78d1049a2c518e655761ea50fe1171fc855fcab7/pyarrow-24.0.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:1183baeb14c5f587b1ec52831e665718ce632caab84b7cd6b85fd44f96114495", size = 49385733, upload-time = "2026-04-21T10:48:34.7Z" }, - { url = "https://files.pythonhosted.org/packages/c3/be/c3d8b06a1ba35f2260f8e1f771abbee7d5e345c0937aab90675706b1690a/pyarrow-24.0.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:806f24b4085453c197a5078218d1ee08783ebbba271badd153d1ae22a3ee804f", size = 51934335, upload-time = "2026-04-21T10:48:42.099Z" }, - { url = "https://files.pythonhosted.org/packages/9c/62/89e07a1e7329d2cde3e3c6994ba0839a24977a2beda8be6005ea3d860b99/pyarrow-24.0.0-cp313-cp313-win_amd64.whl", hash = "sha256:e4505fc6583f7b05ab854934896bcac8253b04ac1171a77dfb73efef92076d91", size = 27271748, upload-time = "2026-04-21T10:49:42.532Z" }, - { url = "https://files.pythonhosted.org/packages/17/1a/cff3a59f80b5b1658549d46611b67163f65e0664431c076ad728bf9d5af4/pyarrow-24.0.0-cp313-cp313t-macosx_12_0_arm64.whl", hash = "sha256:1a4e45017efbf115032e4475ee876d525e0e36c742214fbe405332480ecd6275", size = 35238554, upload-time = "2026-04-21T10:48:48.526Z" }, - { url = "https://files.pythonhosted.org/packages/a8/99/cce0f42a327bfef2c420fb6078a3eb834826e5d6697bf3009fe11d2ad051/pyarrow-24.0.0-cp313-cp313t-macosx_12_0_x86_64.whl", hash = "sha256:7986f1fa71cee060ad00758bcc79d3a93bab8559bf978fab9e53472a2e25a17b", size = 36782301, upload-time = "2026-04-21T10:48:55.181Z" }, - { url = "https://files.pythonhosted.org/packages/2a/66/8e560d5ff6793ca29aca213c53eec0dd482dd46cb93b2819e5aab52e4252/pyarrow-24.0.0-cp313-cp313t-manylinux_2_28_aarch64.whl", hash = "sha256:d3e0b61e8efb24ed38898e5cdc5fffa9124be480008d401a1f8071500494ae42", size = 45721929, upload-time = "2026-04-21T10:49:03.676Z" }, - { url = "https://files.pythonhosted.org/packages/27/0c/a26e25505d030716e078d9f16eb74973cbf0b33b672884e9f9da1c83b871/pyarrow-24.0.0-cp313-cp313t-manylinux_2_28_x86_64.whl", hash = "sha256:55a3bc1e3df3b5567b7d27ef551b2283f0c68a5e86f1cd56abc569da4f31335b", size = 48825365, upload-time = "2026-04-21T10:49:11.714Z" }, - { url = "https://files.pythonhosted.org/packages/5f/eb/771f9ecb0c65e73fe9dccdd1717901b9594f08c4515d000c7c62df573811/pyarrow-24.0.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:641f795b361874ac9da5294f8f443dfdbee355cf2bd9e3b8d97aaac2306b9b37", size = 49451819, upload-time = "2026-04-21T10:49:21.474Z" }, - { url = "https://files.pythonhosted.org/packages/48/da/61ae89a88732f5a785646f3ec6125dbb640fa98a540eb2b9889caa561403/pyarrow-24.0.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:8adc8e6ce5fccf5dc707046ae4914fd537def529709cc0d285d37a7f9cd442ca", size = 51909252, upload-time = "2026-04-21T10:49:31.164Z" }, - { url = "https://files.pythonhosted.org/packages/cb/1a/8dd5cafab7b66573fa91c03d06d213356ad4edd71813aa75e08ce2b3a844/pyarrow-24.0.0-cp313-cp313t-win_amd64.whl", hash = "sha256:9b18371ad2f44044b81a8d23bc2d8a9b6a6226dca775e8e16cfee640473d6c5d", size = 27388127, upload-time = "2026-04-21T10:49:37.334Z" }, + { url = "https://files.pythonhosted.org/packages/47/10/2cbe4c6f0fb83d2de37249567373d64327a5e4d8db72f486db42875b08f6/pyarrow-23.0.1-cp313-cp313-macosx_12_0_arm64.whl", hash = "sha256:6b8fda694640b00e8af3c824f99f789e836720aa8c9379fb435d4c4953a756b8", size = 34210066, upload-time = "2026-02-16T10:10:45.487Z" }, + { url = "https://files.pythonhosted.org/packages/cb/4f/679fa7e84dadbaca7a65f7cdba8d6c83febbd93ca12fa4adf40ba3b6362b/pyarrow-23.0.1-cp313-cp313-macosx_12_0_x86_64.whl", hash = "sha256:8ff51b1addc469b9444b7c6f3548e19dc931b172ab234e995a60aea9f6e6025f", size = 35825526, upload-time = "2026-02-16T10:10:52.266Z" }, + { url = "https://files.pythonhosted.org/packages/f9/63/d2747d930882c9d661e9398eefc54f15696547b8983aaaf11d4a2e8b5426/pyarrow-23.0.1-cp313-cp313-manylinux_2_28_aarch64.whl", hash = "sha256:71c5be5cbf1e1cb6169d2a0980850bccb558ddc9b747b6206435313c47c37677", size = 44473279, upload-time = "2026-02-16T10:11:01.557Z" }, + { url = "https://files.pythonhosted.org/packages/b3/93/10a48b5e238de6d562a411af6467e71e7aedbc9b87f8d3a35f1560ae30fb/pyarrow-23.0.1-cp313-cp313-manylinux_2_28_x86_64.whl", hash = "sha256:9b6f4f17b43bc39d56fec96e53fe89d94bac3eb134137964371b45352d40d0c2", size = 47585798, upload-time = "2026-02-16T10:11:09.401Z" }, + { url = "https://files.pythonhosted.org/packages/5c/20/476943001c54ef078dbf9542280e22741219a184a0632862bca4feccd666/pyarrow-23.0.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:9fc13fc6c403d1337acab46a2c4346ca6c9dec5780c3c697cf8abfd5e19b6b37", size = 48179446, upload-time = "2026-02-16T10:11:17.781Z" }, + { url = "https://files.pythonhosted.org/packages/4b/b6/5dd0c47b335fcd8edba9bfab78ad961bd0fd55ebe53468cc393f45e0be60/pyarrow-23.0.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:5c16ed4f53247fa3ffb12a14d236de4213a4415d127fe9cebed33d51671113e2", size = 50623972, upload-time = "2026-02-16T10:11:26.185Z" }, + { url = "https://files.pythonhosted.org/packages/d5/09/a532297c9591a727d67760e2e756b83905dd89adb365a7f6e9c72578bcc1/pyarrow-23.0.1-cp313-cp313-win_amd64.whl", hash = "sha256:cecfb12ef629cf6be0b1887f9f86463b0dd3dc3195ae6224e74006be4736035a", size = 27540749, upload-time = "2026-02-16T10:12:23.297Z" }, + { url = "https://files.pythonhosted.org/packages/a5/8e/38749c4b1303e6ae76b3c80618f84861ae0c55dd3c2273842ea6f8258233/pyarrow-23.0.1-cp313-cp313t-macosx_12_0_arm64.whl", hash = "sha256:29f7f7419a0e30264ea261fdc0e5fe63ce5a6095003db2945d7cd78df391a7e1", size = 34471544, upload-time = "2026-02-16T10:11:32.535Z" }, + { url = "https://files.pythonhosted.org/packages/a3/73/f237b2bc8c669212f842bcfd842b04fc8d936bfc9d471630569132dc920d/pyarrow-23.0.1-cp313-cp313t-macosx_12_0_x86_64.whl", hash = "sha256:33d648dc25b51fd8055c19e4261e813dfc4d2427f068bcecc8b53d01b81b0500", size = 35949911, upload-time = "2026-02-16T10:11:39.813Z" }, + { url = "https://files.pythonhosted.org/packages/0c/86/b912195eee0903b5611bf596833def7d146ab2d301afeb4b722c57ffc966/pyarrow-23.0.1-cp313-cp313t-manylinux_2_28_aarch64.whl", hash = "sha256:cd395abf8f91c673dd3589cadc8cc1ee4e8674fa61b2e923c8dd215d9c7d1f41", size = 44520337, upload-time = "2026-02-16T10:11:47.764Z" }, + { url = "https://files.pythonhosted.org/packages/69/c2/f2a717fb824f62d0be952ea724b4f6f9372a17eed6f704b5c9526f12f2f1/pyarrow-23.0.1-cp313-cp313t-manylinux_2_28_x86_64.whl", hash = "sha256:00be9576d970c31defb5c32eb72ef585bf600ef6d0a82d5eccaae96639cf9d07", size = 47548944, upload-time = "2026-02-16T10:11:56.607Z" }, + { url = "https://files.pythonhosted.org/packages/84/a7/90007d476b9f0dc308e3bc57b832d004f848fd6c0da601375d20d92d1519/pyarrow-23.0.1-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:c2139549494445609f35a5cda4eb94e2c9e4d704ce60a095b342f82460c73a83", size = 48236269, upload-time = "2026-02-16T10:12:04.47Z" }, + { url = "https://files.pythonhosted.org/packages/b0/3f/b16fab3e77709856eb6ac328ce35f57a6d4a18462c7ca5186ef31b45e0e0/pyarrow-23.0.1-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:7044b442f184d84e2351e5084600f0d7343d6117aabcbc1ac78eb1ae11eb4125", size = 50604794, upload-time = "2026-02-16T10:12:11.797Z" }, + { url = "https://files.pythonhosted.org/packages/e9/a1/22df0620a9fac31d68397a75465c344e83c3dfe521f7612aea33e27ab6c0/pyarrow-23.0.1-cp313-cp313t-win_amd64.whl", hash = "sha256:a35581e856a2fafa12f3f54fce4331862b1cfb0bef5758347a858a4aa9d6bae8", size = 27660642, upload-time = "2026-02-16T10:12:17.746Z" }, ] [[package]] @@ -3633,20 +3654,20 @@ wheels = [ [[package]] name = "pygments" -version = "2.20.0" +version = "2.19.2" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/c3/b2/bc9c9196916376152d655522fdcebac55e66de6603a76a02bca1b6414f6c/pygments-2.20.0.tar.gz", hash = "sha256:6757cd03768053ff99f3039c1a36d6c0aa0b263438fcab17520b30a303a82b5f", size = 4955991, upload-time = "2026-03-29T13:29:33.898Z" } +sdist = { url = "https://files.pythonhosted.org/packages/b0/77/a5b8c569bf593b0140bde72ea885a803b82086995367bf2037de0159d924/pygments-2.19.2.tar.gz", hash = "sha256:636cb2477cec7f8952536970bc533bc43743542f70392ae026374600add5b887", size = 4968631, upload-time = "2025-06-21T13:39:12.283Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/f4/7e/a72dd26f3b0f4f2bf1dd8923c85f7ceb43172af56d63c7383eb62b332364/pygments-2.20.0-py3-none-any.whl", hash = "sha256:81a9e26dd42fd28a23a2d169d86d7ac03b46e2f8b59ed4698fb4785f946d0176", size = 1231151, upload-time = "2026-03-29T13:29:30.038Z" }, + { url = "https://files.pythonhosted.org/packages/c7/21/705964c7812476f378728bdf590ca4b771ec72385c533964653c68e86bdc/pygments-2.19.2-py3-none-any.whl", hash = "sha256:86540386c03d588bb81d44bc3928634ff26449851e99741617ecb9037ee5ec0b", size = 1225217, upload-time = "2025-06-21T13:39:07.939Z" }, ] [[package]] name = "pyjwt" -version = "2.13.0" +version = "2.12.1" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/3b/81/58d0ac84e1ef3a3843791d6954d94c0b33d526c75eeb1efbce9d0a4c4077/pyjwt-2.13.0.tar.gz", hash = "sha256:41571c89ca91598c79e8ef18a2d07367d4810fbbd6f637794879baf1b7703423", size = 107515, upload-time = "2026-05-21T19:54:36.618Z" } +sdist = { url = "https://files.pythonhosted.org/packages/c2/27/a3b6e5bf6ff856d2509292e95c8f57f0df7017cf5394921fc4e4ef40308a/pyjwt-2.12.1.tar.gz", hash = "sha256:c74a7a2adf861c04d002db713dd85f84beb242228e671280bf709d765b03672b", size = 102564, upload-time = "2026-03-13T19:27:37.25Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/a3/5e/ecf12fdb62546d64385c158514e9b2b671f7832108ef2ecd2020ce0af2d1/pyjwt-2.13.0-py3-none-any.whl", hash = "sha256:66adcc2aff09b3f1bbd95fc1e1577df8ac8723c978552fd43304c8a290ac5728", size = 31274, upload-time = "2026-05-21T19:54:35.362Z" }, + { url = "https://files.pythonhosted.org/packages/e5/7a/8dd906bd22e79e47397a61742927f6747fe93242ef86645ee9092e610244/pyjwt-2.12.1-py3-none-any.whl", hash = "sha256:28ca37c070cad8ba8cd9790cd940535d40274d22f80ab87f3ac6a713e6e8454c", size = 29726, upload-time = "2026-03-13T19:27:35.677Z" }, ] [package.optional-dependencies] @@ -3667,7 +3688,7 @@ sdist = { url = "https://files.pythonhosted.org/packages/eb/56/1d5ed36041e11c943 [[package]] name = "pyobjc" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, @@ -3832,118 +3853,118 @@ dependencies = [ { name = "pyobjc-framework-vision", marker = "platform_release >= '17.0'" }, { name = "pyobjc-framework-webkit" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/00/09/68336c2ed662cecc8dc71e3bdcde2666430f3eb981cbd86661e7aa260cab/pyobjc-12.2.tar.gz", hash = "sha256:7074dcb0999e611e456b12cf94b7289cf6327094359b2c21c5ae593048b909bf", size = 11841, upload-time = "2026-05-30T12:28:53.751Z" } +sdist = { url = "https://files.pythonhosted.org/packages/17/06/d77639ba166cc09aed2d32ae204811b47bc5d40e035cdc9bff7fff72ec5f/pyobjc-12.1.tar.gz", hash = "sha256:686d6db3eb3182fac9846b8ce3eedf4c7d2680b21b8b8d6e6df054a17e92a12d", size = 11345, upload-time = "2025-11-14T10:07:28.155Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/bf/25/f988de6a2028550fbd79f386938c4d99ac0f6b7652ad212cd8b74654924c/pyobjc-12.2-py3-none-any.whl", hash = "sha256:f3b0d4cdb7d0be242a37ff27c9f0b3ef182fe8ebdbac6ae0c40ef87539fe7d77", size = 4225, upload-time = "2026-05-30T09:44:22.344Z" }, + { url = "https://files.pythonhosted.org/packages/ef/00/1085de7b73abf37ec27ad59f7a1d7a406e6e6da45720bced2e198fdf1ddf/pyobjc-12.1-py3-none-any.whl", hash = "sha256:6f8c36cf87b1159d2ca1aa387ffc3efcd51cc3da13ef47c65f45e6d9fbccc729", size = 4226, upload-time = "2025-11-14T09:30:25.185Z" }, ] [[package]] name = "pyobjc-core" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/2a/e8/a6cc12669211e7c9b29e8f26bf2159e67c7a73555dc229018abf46d8167a/pyobjc_core-12.2.tar.gz", hash = "sha256:51d7de4cfa32f508c6a7aac31f131b12d5e196a8dcf588e6e8d7e6337224f66d", size = 1062064, upload-time = "2026-05-30T12:29:55.417Z" } +sdist = { url = "https://files.pythonhosted.org/packages/b8/b6/d5612eb40be4fd5ef88c259339e6313f46ba67577a95d86c3470b951fce0/pyobjc_core-12.1.tar.gz", hash = "sha256:2bb3903f5387f72422145e1466b3ac3f7f0ef2e9960afa9bcd8961c5cbf8bd21", size = 1000532, upload-time = "2025-11-14T10:08:28.292Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/d6/ed/6e62d038992bc7ef9091d95ec97c3c221686fe52a993a6501e961c757613/pyobjc_core-12.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:9287c7c46d6ae8676b4c6c0389a8f4b5381f42ae53a47151900c08b157e5a992", size = 6428611, upload-time = "2026-05-30T10:21:33.83Z" }, - { url = "https://files.pythonhosted.org/packages/bf/0b/d492110202f4d1050a5e590620ebd1e730cf89f9880a26cf18205e0f5800/pyobjc_core-12.2-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:515ecf2afe168301feb66a7230d700584ce2e4b8a0ac178e19450b8898384139", size = 6677992, upload-time = "2026-05-30T10:44:13.039Z" }, + { url = "https://files.pythonhosted.org/packages/f4/d2/29e5e536adc07bc3d33dd09f3f7cf844bf7b4981820dc2a91dd810f3c782/pyobjc_core-12.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:01c0cf500596f03e21c23aef9b5f326b9fb1f8f118cf0d8b66749b6cf4cbb37a", size = 677370, upload-time = "2025-11-14T09:33:05.273Z" }, + { url = "https://files.pythonhosted.org/packages/1b/f0/4b4ed8924cd04e425f2a07269943018d43949afad1c348c3ed4d9d032787/pyobjc_core-12.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:177aaca84bb369a483e4961186704f64b2697708046745f8167e818d968c88fc", size = 719586, upload-time = "2025-11-14T09:33:53.302Z" }, ] [[package]] name = "pyobjc-framework-accessibility" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-cocoa" }, { name = "pyobjc-framework-quartz" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/76/31/ddc59bea6388a37461e919f25d2120bd93df0b30f552c606fab2804c52c3/pyobjc_framework_accessibility-12.2.tar.gz", hash = "sha256:86f82cc21db65c73c72ae93b7536381f1e12a1c89d4c554a216217dacdf60bb3", size = 34357, upload-time = "2026-05-30T12:29:58.741Z" } +sdist = { url = "https://files.pythonhosted.org/packages/2d/87/8ca40428d05a668fecc638f2f47dba86054dbdc35351d247f039749de955/pyobjc_framework_accessibility-12.1.tar.gz", hash = "sha256:5ff362c3425edc242d49deec11f5f3e26e565cefb6a2872eda59ab7362149772", size = 29800, upload-time = "2025-11-14T10:08:31.949Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/d8/1d/d13365b48fc989b5217ef94facec719f7c7ab2878e573462cf822095cb3b/pyobjc_framework_accessibility-12.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:e60d910261d018770722ad0987291e94229e09aef0e919073c87a30cf677686d", size = 11564, upload-time = "2026-05-30T11:51:55.545Z" }, - { url = "https://files.pythonhosted.org/packages/28/22/2f3ebe592655f5106a072cf1f1fe331f7c9ba06b24ac8e3dcdc9e9294d03/pyobjc_framework_accessibility-12.2-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:535a3e2ccb36e707dd72ed54f7f1772ef41526cebe6fe52acc081d45a10ede15", size = 11732, upload-time = "2026-05-30T11:51:57.41Z" }, + { url = "https://files.pythonhosted.org/packages/40/71/aa9625b1b064f7d3e1bbc0b6b40cf92d1d46c7f798e0b345594d626f5510/pyobjc_framework_accessibility-12.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:44d872d8a1f9d1569da0590c5a9185d2c02dc2e08e410c84a03aa54ca6e05c2c", size = 11352, upload-time = "2025-11-14T09:35:32.967Z" }, + { url = "https://files.pythonhosted.org/packages/e9/d8/ff4c720d6140f7a20eaed15d5430af1fc8be372998674b82931993177261/pyobjc_framework_accessibility-12.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:4b9e2079ad0da736ba32a10e63698ff1db9667b5f6342a81220aa86cfa0de8c8", size = 11521, upload-time = "2025-11-14T09:35:35.112Z" }, ] [[package]] name = "pyobjc-framework-accounts" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-cocoa" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/d3/ec/aea64ed95dda48f2c1a049c638be39822f731e79ef9fb4202dd2b3d87b86/pyobjc_framework_accounts-12.2.tar.gz", hash = "sha256:823b61e3ed964efde365e6c83b605692f72cb7f7e0782dafea674f2de8e3f8ed", size = 16208, upload-time = "2026-05-30T12:30:00.949Z" } +sdist = { url = "https://files.pythonhosted.org/packages/65/10/f6fe336c7624d6753c1f6edac102310ce4434d49b548c479e8e6420d4024/pyobjc_framework_accounts-12.1.tar.gz", hash = "sha256:76d62c5e7b831eb8f4c9ca6abaf79d9ed961dfffe24d89a041fb1de97fe56a3e", size = 15202, upload-time = "2025-11-14T10:08:33.995Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/b2/fa/61661645bdc59e6aa9c92791731d688c76b84260362849f8c768e48558ea/pyobjc_framework_accounts-12.2-py2.py3-none-any.whl", hash = "sha256:a1638b7758e6371f59e7ea9f912922530062ce9640a0f1d1e66a0702bff7f8e3", size = 5104, upload-time = "2026-05-30T11:52:05.957Z" }, + { url = "https://files.pythonhosted.org/packages/ac/70/5f9214250f92fbe2e07f35778875d2771d612f313af2a0e4bacba80af28e/pyobjc_framework_accounts-12.1-py2.py3-none-any.whl", hash = "sha256:e1544ad11a2f889a7aaed649188d0e76d58595a27eec07ca663847a7adb21ae5", size = 5104, upload-time = "2025-11-14T09:35:40.246Z" }, ] [[package]] name = "pyobjc-framework-addressbook" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-cocoa" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/ba/03/76bd426954723343854c2f4da82bbcd61048eccce31c00381dbfb7677c85/pyobjc_framework_addressbook-12.2.tar.gz", hash = "sha256:5f763983c1c32e70f7b742e35a025530be4bf6742ff4ac98f71ab0bfeb5cf9bd", size = 47681, upload-time = "2026-05-30T12:30:04.791Z" } +sdist = { url = "https://files.pythonhosted.org/packages/18/28/0404af2a1c6fa8fd266df26fb6196a8f3fb500d6fe3dab94701949247bea/pyobjc_framework_addressbook-12.1.tar.gz", hash = "sha256:c48b740cf981103cef1743d0804a226d86481fcb839bd84b80e9a586187e8000", size = 44359, upload-time = "2025-11-14T10:08:37.687Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/81/bc/d3afc72e56b2e49580ada60dff250669f2b80ee1e2c59bdd3e577f32d0cd/pyobjc_framework_addressbook-12.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:37dbd5a712c2ff71ec80cc5a86d96c98b1d5e26eb2c7bc4d251f84eb1a3c8893", size = 12826, upload-time = "2026-05-30T11:52:13.667Z" }, - { url = "https://files.pythonhosted.org/packages/e9/a6/9d0a9433e3b76ee9e6d728d463377d1833389450315a6122342e4d42c5c1/pyobjc_framework_addressbook-12.2-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:899b19c7c2c4a8ee7020a20022a8c64daf86dccd163da03a41bbd585565d18ed", size = 12981, upload-time = "2026-05-30T11:52:15.771Z" }, + { url = "https://files.pythonhosted.org/packages/62/eb/de0d539bbf31685050dd9fe8894bd2dbc1632bf5311fc74c2c3c46ce61d0/pyobjc_framework_addressbook-12.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:f03312faeb3c381e040f965b288379468d567b1449c1cfe66d150885b48510a3", size = 12910, upload-time = "2025-11-14T09:35:49.694Z" }, + { url = "https://files.pythonhosted.org/packages/e7/59/720da201349f67bca9e6b577fea1a8a3344e88a6527c48933be898c9559d/pyobjc_framework_addressbook-12.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:3b6931f78e01a215df3d9a27d1a10aab04659e636b0836ac448f8dd7fc56a581", size = 13064, upload-time = "2025-11-14T09:35:51.664Z" }, ] [[package]] name = "pyobjc-framework-adservices" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-cocoa" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/04/05/fb43d284efe7e48b43abe2507f79b91a4c9ebce4f76c552fc228b647c0b9/pyobjc_framework_adservices-12.2.tar.gz", hash = "sha256:77a3cf0acdf5e83c29c26be60a63e35a31ad5076ac60188a52268fe53de7cee0", size = 12249, upload-time = "2026-05-30T12:30:06.574Z" } +sdist = { url = "https://files.pythonhosted.org/packages/19/04/1c3d3e0a1ac981664f30b33407dcdf8956046ecde6abc88832cf2aa535f4/pyobjc_framework_adservices-12.1.tar.gz", hash = "sha256:7a31fc8d5c6fd58f012db87c89ba581361fc905114bfb912e0a3a87475c02183", size = 11793, upload-time = "2025-11-14T10:08:39.56Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/53/2b/230ad0f52e7f960a560afbae80dacdfc831a01a3507989e1ee41755ab793/pyobjc_framework_adservices-12.2-py2.py3-none-any.whl", hash = "sha256:7c1b1f78689f66fa724c23fd20dac56e8ea3190e868d9859d08294a58e26cb33", size = 3485, upload-time = "2026-05-30T11:52:24.532Z" }, + { url = "https://files.pythonhosted.org/packages/ad/13/f7796469b25f50750299c4b0e95dc2f75c7c7fc4c93ef2c644f947f10529/pyobjc_framework_adservices-12.1-py2.py3-none-any.whl", hash = "sha256:9ca3c55e35b2abb3149a0bce5de9a1f7e8ee4f8642036910ca8586ab2e161538", size = 3492, upload-time = "2025-11-14T09:35:57.344Z" }, ] [[package]] name = "pyobjc-framework-adsupport" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-cocoa" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/9e/6d/6041af76d08da1ddae42804dfff3b5fb0fb27c2da8eb7a1a04ece4532e46/pyobjc_framework_adsupport-12.2.tar.gz", hash = "sha256:fe8e730c102a6579fe905b20e497423a080fd1f6a75eabf7356d2394467f64a4", size = 12112, upload-time = "2026-05-30T12:30:08.196Z" } +sdist = { url = "https://files.pythonhosted.org/packages/43/77/f26a2e9994d4df32e9b3680c8014e350b0f1c78d7673b3eba9de2e04816f/pyobjc_framework_adsupport-12.1.tar.gz", hash = "sha256:9a68480e76de567c339dca29a8c739d6d7b5cad30e1cd585ff6e49ec2fc283dd", size = 11645, upload-time = "2025-11-14T10:08:41.439Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/29/b7/956f2d841a8709ab7cae6726dcd953a54650768f9b78cf9821fb732c6cca/pyobjc_framework_adsupport-12.2-py2.py3-none-any.whl", hash = "sha256:39ca7e3c336c32c5d9d5780eba7606f4d53034bb53bc7b55c8a5a2e430ad7c66", size = 3402, upload-time = "2026-05-30T11:52:25.922Z" }, + { url = "https://files.pythonhosted.org/packages/cd/1a/3e90d5a09953bde7b60946cd09cca1411aed05dea855cb88cb9e944c7006/pyobjc_framework_adsupport-12.1-py2.py3-none-any.whl", hash = "sha256:97dcd8799dd61f047bb2eb788bbde81f86e95241b5e5173a3a61cfc05b5598b1", size = 3401, upload-time = "2025-11-14T09:35:59.039Z" }, ] [[package]] name = "pyobjc-framework-applescriptkit" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-cocoa" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/92/e8/1af0305da68a6923d269806f6f60b900e473b3ac03279a8614d71e224592/pyobjc_framework_applescriptkit-12.2.tar.gz", hash = "sha256:1e1f91966b42f902d954a570a2aab8a4e24af465833525863e30c8a5b47ee4f1", size = 11690, upload-time = "2026-05-30T12:30:09.765Z" } +sdist = { url = "https://files.pythonhosted.org/packages/cd/f1/e0c07b2a9eb98f1a2050f153d287a52a92f873eeddb41b74c52c144d8767/pyobjc_framework_applescriptkit-12.1.tar.gz", hash = "sha256:cb09f88cf0ad9753dedc02720065818f854b50e33eb4194f0ea34de6d7a3eb33", size = 11451, upload-time = "2025-11-14T10:08:43.328Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/45/2b/3abd0d61208205b5617590e6c9cc35f744a41a2bdb81b5e18eba7810b9ae/pyobjc_framework_applescriptkit-12.2-py2.py3-none-any.whl", hash = "sha256:4b2a2f02e159c3c13834c3a605c1445563592f41d57ef6cdca2bd39e6409270d", size = 4352, upload-time = "2026-05-30T11:52:27.452Z" }, + { url = "https://files.pythonhosted.org/packages/3b/70/6c399c6ebc37a4e48acf63967e0a916878aedfe420531f6d739215184c0c/pyobjc_framework_applescriptkit-12.1-py2.py3-none-any.whl", hash = "sha256:b955fc017b524027f635d92a8a45a5fd9fbae898f3e03de16ecd94aa4c4db987", size = 4352, upload-time = "2025-11-14T09:36:00.705Z" }, ] [[package]] name = "pyobjc-framework-applescriptobjc" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-cocoa" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/86/bc/4bcbb2fdae7a4526432619ec9a15fb7ee8ef22358be422e7b3c23c280f6f/pyobjc_framework_applescriptobjc-12.2.tar.gz", hash = "sha256:118abccae98c0af67e7c850058e4651748256eba52da382a2cd58e0e7c74418e", size = 11787, upload-time = "2026-05-30T12:30:11.487Z" } +sdist = { url = "https://files.pythonhosted.org/packages/c0/4b/e4d1592207cbe17355e01828bdd11dd58f31356108f6a49f5e0484a5df50/pyobjc_framework_applescriptobjc-12.1.tar.gz", hash = "sha256:dce080ed07409b0dda2fee75d559bd312ea1ef0243a4338606440f282a6a0f5f", size = 11588, upload-time = "2025-11-14T10:08:45.037Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/6b/a8/bb375c57509a1553e5ee51758caad3f946a98180577680b33a509f65bd9f/pyobjc_framework_applescriptobjc-12.2-py2.py3-none-any.whl", hash = "sha256:0a3019b16959dd8bef9fb581894901e89e027fa0b8b21b8515deda13a3cd9b34", size = 4452, upload-time = "2026-05-30T11:52:28.996Z" }, + { url = "https://files.pythonhosted.org/packages/3e/5f/9ce6706399706930eb29c5308037109c30cfb36f943a6df66fdf38cc842a/pyobjc_framework_applescriptobjc-12.1-py2.py3-none-any.whl", hash = "sha256:79068f982cc22471712ce808c0a8fd5deea11258fc8d8c61968a84b1962a3d10", size = 4454, upload-time = "2025-11-14T09:36:02.276Z" }, ] [[package]] name = "pyobjc-framework-applicationservices" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, @@ -3951,97 +3972,97 @@ dependencies = [ { name = "pyobjc-framework-coretext" }, { name = "pyobjc-framework-quartz" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/a9/ab/1776ac62687cb3d81e59517ca55970f26efa5a96bbf3ebcea57afcdd6b06/pyobjc_framework_applicationservices-12.2.tar.gz", hash = "sha256:4f6c4027405f709872e5b098f3cd86961bdf262fb80679a548725a02171bb0cf", size = 109325, upload-time = "2026-05-30T12:30:18.7Z" } +sdist = { url = "https://files.pythonhosted.org/packages/be/6a/d4e613c8e926a5744fc47a9e9fea08384a510dc4f27d844f7ad7a2d793bd/pyobjc_framework_applicationservices-12.1.tar.gz", hash = "sha256:c06abb74f119bc27aeb41bf1aef8102c0ae1288aec1ac8665ea186a067a8945b", size = 103247, upload-time = "2025-11-14T10:08:52.18Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/4b/28/8c85ef2dff09fb4c6adf2161bf1d32ff81dca497863682ba46107e38bbb9/pyobjc_framework_applicationservices-12.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:7119c75ad2c0e21b0bd44865641944e691e80abce0d5805fa344730238b16b15", size = 32754, upload-time = "2026-05-30T11:52:41.299Z" }, - { url = "https://files.pythonhosted.org/packages/61/ee/4be28e61319055092d3a963514c2fb4daba86785d4044f073a4135273bb0/pyobjc_framework_applicationservices-12.2-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:0492c478b175005f38c887523f895382a9ed47c0810ab786c6712d3fda245832", size = 33017, upload-time = "2026-05-30T11:52:44.534Z" }, + { url = "https://files.pythonhosted.org/packages/fc/21/79e42ee836f1010f5fe9e97d2817a006736bd287c15a3674c399190a2e77/pyobjc_framework_applicationservices-12.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:bd1f4dbb38234a24ae6819f5e22485cf7dd3dd4074ff3bf9a9fdb4c01a3b4a38", size = 32859, upload-time = "2025-11-14T09:36:15.208Z" }, + { url = "https://files.pythonhosted.org/packages/66/3a/0f1d4dcf2345e875e5ea9761d5a70969e241d24089133d21f008dde596f5/pyobjc_framework_applicationservices-12.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:8a5d2845249b6a85ba9e320a9848468c3f8cd6f59605a9a43f406a7810eaa830", size = 33115, upload-time = "2025-11-14T09:36:18.384Z" }, ] [[package]] name = "pyobjc-framework-apptrackingtransparency" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-cocoa" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/c6/08/28b67c30aae6b1d870aac62ef63e7f518f3507a5c8c34378ca2cd89d2f7d/pyobjc_framework_apptrackingtransparency-12.2.tar.gz", hash = "sha256:7887b9c574c8a4edafbf8e34649a77ea91aab93dcf92b22e272ab01341d9e404", size = 12778, upload-time = "2026-05-30T12:30:20.58Z" } +sdist = { url = "https://files.pythonhosted.org/packages/0d/de/f24348982ecab0cb13067c348fc5fbc882c60d704ca290bada9a2b3e594b/pyobjc_framework_apptrackingtransparency-12.1.tar.gz", hash = "sha256:e25bf4e4dfa2d929993ee8e852b28fdf332fa6cde0a33328fdc3b2f502fa50ec", size = 12407, upload-time = "2025-11-14T10:08:54.118Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/3a/65/1a2b950fb8c7c98ee6ab894e5466094039846ff10986ceb04d4c29ce3118/pyobjc_framework_apptrackingtransparency-12.2-py2.py3-none-any.whl", hash = "sha256:f0b51c30dc8c32882aa88e891ec13e52a0b339a3bb52ab7eed162a9640b76b4a", size = 3905, upload-time = "2026-05-30T11:52:57.929Z" }, + { url = "https://files.pythonhosted.org/packages/19/b2/90120b93ecfb099b6af21696c26356ad0f2182bdef72b6cba28aa6472ca6/pyobjc_framework_apptrackingtransparency-12.1-py2.py3-none-any.whl", hash = "sha256:23a98ade55495f2f992ecf62c3cbd8f648cbd68ba5539c3f795bf66de82e37ca", size = 3879, upload-time = "2025-11-14T09:36:26.425Z" }, ] [[package]] name = "pyobjc-framework-arkit" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-cocoa" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/2b/27/94cce926f3a8d95050bcfa14b1fe4e6d45ff86b93f3aa53f336a9eb3e5b6/pyobjc_framework_arkit-12.2.tar.gz", hash = "sha256:48f7241f07c03a5caad05b8998ee23210f9fd2395be69b635fdcd41d11329cf3", size = 40141, upload-time = "2026-05-30T12:30:23.719Z" } +sdist = { url = "https://files.pythonhosted.org/packages/c9/8b/843fe08e696bca8e7fc129344965ab6280f8336f64f01ba0a8862d219c3f/pyobjc_framework_arkit-12.1.tar.gz", hash = "sha256:0c5c6b702926179700b68ba29b8247464c3b609fd002a07a3308e72cfa953adf", size = 35814, upload-time = "2025-11-14T10:08:57.55Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/83/cf/7fc4248af3c7ef766137ffa831dbe999efeaef48df108e62d35099aa6b5e/pyobjc_framework_arkit-12.2-py2.py3-none-any.whl", hash = "sha256:6a8065f5e49c6efddfa9250f14845b5a5fc0cada5444a87d1f96fcf72ac71f19", size = 8305, upload-time = "2026-05-30T11:52:59.499Z" }, + { url = "https://files.pythonhosted.org/packages/21/1e/64c55b409243b3eb9abc7a99e7b27ad4e16b9e74bc4b507fb7e7b81fd41a/pyobjc_framework_arkit-12.1-py2.py3-none-any.whl", hash = "sha256:f6d39e28d858ee03f052d6780a552247e682204382dbc090f1d3192fa1b21493", size = 8302, upload-time = "2025-11-14T09:36:28.127Z" }, ] [[package]] name = "pyobjc-framework-audiovideobridging" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-cocoa" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/e3/cb/4e941fbd2e199b92accbee50839a7841dee74d63d6b199c0d37e7df0e40c/pyobjc_framework_audiovideobridging-12.2.tar.gz", hash = "sha256:7019abd29ab7b232618a5ab7135670e6f1e15744167b8d4f841133893914ebf5", size = 44219, upload-time = "2026-05-30T12:30:27.156Z" } +sdist = { url = "https://files.pythonhosted.org/packages/9f/51/f81581e7a3c5cb6c9254c6f1e1ee1d614930493761dec491b5b0d49544b9/pyobjc_framework_audiovideobridging-12.1.tar.gz", hash = "sha256:6230ace6bec1f38e8a727c35d054a7be54e039b3053f98e6dd8d08d6baee2625", size = 38457, upload-time = "2025-11-14T10:09:01.122Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/f9/d0/146911872702f1e2e25fd3274d29e796ace042d863f076947344158ffbca/pyobjc_framework_audiovideobridging-12.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:7b07278a182e177f0e6417d8252df6ad6b885e17d6b7d09965d35510983bf9c6", size = 11074, upload-time = "2026-05-30T11:53:07.266Z" }, - { url = "https://files.pythonhosted.org/packages/0a/48/3f73eba1e79e0eea83fe8504f64fe62688178c51ea6ec4b1f90aabeeaf3c/pyobjc_framework_audiovideobridging-12.2-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:46e962bda54b81fa0e84bd58ccd0284ee680689891c04b869542bdcbb7c3870e", size = 11249, upload-time = "2026-05-30T11:53:09.207Z" }, + { url = "https://files.pythonhosted.org/packages/9a/e7/d6436115ebb623dbc14283f5e76577245fa6460995e9f7981e79e97003d3/pyobjc_framework_audiovideobridging-12.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:a9901a88b6c8dbc982d8605c6b1ff0330ff80647a0a96a8187b6784249eb42dc", size = 11065, upload-time = "2025-11-14T09:36:36.69Z" }, + { url = "https://files.pythonhosted.org/packages/97/ca/d6740b0f666dca9fc28d4e08358a7a2fffaf879cf9c49d2c99c470b83ef8/pyobjc_framework_audiovideobridging-12.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:0c57fdf1762f616d10549c0eddf84e59c193800f4a7932aaa7d5f13c123609c0", size = 11239, upload-time = "2025-11-14T09:36:38.992Z" }, ] [[package]] name = "pyobjc-framework-authenticationservices" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-cocoa" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/93/a6/973aca6e96097cf2121027b09720d6e564d381c8f024ae0ebb67939d184b/pyobjc_framework_authenticationservices-12.2.tar.gz", hash = "sha256:c99c11082d5ac6c454d729142709552b10e385d99e34d8e631bedca1886c8b78", size = 75719, upload-time = "2026-05-30T12:30:32.521Z" } +sdist = { url = "https://files.pythonhosted.org/packages/6c/18/86218de3bf67fc1d810065f353d9df70c740de567ebee8550d476cb23862/pyobjc_framework_authenticationservices-12.1.tar.gz", hash = "sha256:cef71faeae2559f5c0ff9a81c9ceea1c81108e2f4ec7de52a98c269feff7a4b6", size = 58683, upload-time = "2025-11-14T10:09:06.003Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/e3/ef/4cd4e3648d0187aa06de7146eb7597a2ace07fe5007dab0d99d5565c1175/pyobjc_framework_authenticationservices-12.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:98e3b27b9033bb21e12efe89700d0d4cc1b72a90a98ded4d19c3af7edcf8eb50", size = 21376, upload-time = "2026-05-30T11:53:25.564Z" }, - { url = "https://files.pythonhosted.org/packages/d4/ba/b1b41b65dcd3ee357fc3716e5f241ead2da57c9a8984b6a7b8c71f160d3e/pyobjc_framework_authenticationservices-12.2-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:0a0e966a24d0c1b9a8c6c94751c05e2cd4f4a47a06ec53822aa626677f52959b", size = 21620, upload-time = "2026-05-30T11:53:27.891Z" }, + { url = "https://files.pythonhosted.org/packages/23/2f/7016b3ca344b079932abe56d7d6216c88cac715d81ca687753aed4b749f7/pyobjc_framework_authenticationservices-12.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:4491a2352cd53a38c7d057d674b1aa40d05eddb8dd7a1a2f415d9f2858b52d40", size = 20746, upload-time = "2025-11-14T09:36:53.762Z" }, + { url = "https://files.pythonhosted.org/packages/5b/63/f2d1137e542b2badb5803e01628a61e9df8853b773513a6a066524c77903/pyobjc_framework_authenticationservices-12.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:a3957039eae3a82ada418ee475a347619e42ba10c45a57cd6ca83b1a0e61c2ad", size = 20994, upload-time = "2025-11-14T09:36:56.153Z" }, ] [[package]] name = "pyobjc-framework-automaticassessmentconfiguration" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-cocoa" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/2f/6c/1bb82a3487454624071fe1ba5d75e005dfd82770d1472a1cbb78e4508316/pyobjc_framework_automaticassessmentconfiguration-12.2.tar.gz", hash = "sha256:dbd96b6085cc9da3f5115d418b2e052a5807a8964e49422c0d7bf7196499f78c", size = 24753, upload-time = "2026-05-30T12:30:34.91Z" } +sdist = { url = "https://files.pythonhosted.org/packages/e4/24/080afe8189c47c4bb3daa191ccfd962400ca31a67c14b0f7c2d002c2e249/pyobjc_framework_automaticassessmentconfiguration-12.1.tar.gz", hash = "sha256:2b732c02d9097682ca16e48f5d3b10056b740bc091e217ee4d5715194c8970b1", size = 21895, upload-time = "2025-11-14T10:09:08.779Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/cd/d9/7b56f64006c83a65b38e7b58d0a2d3d499f8633d066617c5c0e1ac338970/pyobjc_framework_automaticassessmentconfiguration-12.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:a045df9bf1224d30727db4af8ceabc2f227356e494e93db69b4abc058b4e4edf", size = 9368, upload-time = "2026-05-30T11:53:44.189Z" }, - { url = "https://files.pythonhosted.org/packages/98/82/1846574b7a414d29f0d81344be71a25f4d18ec5e02ad1fcf1db7c2af68c4/pyobjc_framework_automaticassessmentconfiguration-12.2-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:052e81f7a83ddb45ce5c4aeb01dc57f3cc42a5496e6117eb4174d195a2c45752", size = 9522, upload-time = "2026-05-30T11:53:45.772Z" }, + { url = "https://files.pythonhosted.org/packages/52/85/42cf8718bbfef47e67228a39d4f25b86b6fa9676f5ca5904af21ae42ad43/pyobjc_framework_automaticassessmentconfiguration-12.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:467739e70ddbc259bf453056cc9ce4ed96de8e6aad8122fa4035d2e6ecf9fc9c", size = 9344, upload-time = "2025-11-14T09:37:09.02Z" }, + { url = "https://files.pythonhosted.org/packages/09/ec/a889dd812adfa446238853cf3cf6a7a2691e3096247a7ef75970d135e5bb/pyobjc_framework_automaticassessmentconfiguration-12.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:b4ea4b00f70bf242a5d8ce9c420987239dbc74285588c141ac1e0d6bd71fcd4c", size = 9501, upload-time = "2025-11-14T09:37:10.684Z" }, ] [[package]] name = "pyobjc-framework-automator" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-cocoa" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/a9/3f/65daacfdd38b6936cebae9c27f25b5bcb97e4de813488caaa066c80013a7/pyobjc_framework_automator-12.2.tar.gz", hash = "sha256:bf38231f0ad38115473e853e6419c5d0511f4fe6dd904ea380160da91cf27bea", size = 188951, upload-time = "2026-05-30T12:30:46.654Z" } +sdist = { url = "https://files.pythonhosted.org/packages/7e/08/362bf6ac2bba393c46cf56078d4578b692b56857c385e47690637a72f0dd/pyobjc_framework_automator-12.1.tar.gz", hash = "sha256:7491a99347bb30da3a3f744052a03434ee29bee3e2ae520576f7e796740e4ba7", size = 186068, upload-time = "2025-11-14T10:09:20.82Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/16/56/1749bf5de1f138f68bfd498b639a480e06ac9b108c5e50a68cdf58379175/pyobjc_framework_automator-12.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:949f2d403d4d6d753122fa8ece9f9fd417b8b4afe6b65f64879259a03ca6f59e", size = 10056, upload-time = "2026-05-30T11:53:58.669Z" }, - { url = "https://files.pythonhosted.org/packages/ba/2f/de880591ffa058c8456157f5d618d5950ab8788b7f1e8f81d62ab8afe0d7/pyobjc_framework_automator-12.2-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:038ece9097bc9441554d48dac051bf445ed5496d4ced03962c5dca2ea46cfd29", size = 10201, upload-time = "2026-05-30T11:54:00.341Z" }, + { url = "https://files.pythonhosted.org/packages/1f/cd/666e44c8deb41e5c9dc5930abf8379edd80bff14eb4d0a56380cdbbbbf9a/pyobjc_framework_automator-12.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:cdda7b8c48c0f8e15cbb97600ac848fd76cf9837ca3353286a7c02281e9c17a3", size = 10045, upload-time = "2025-11-14T09:37:22.179Z" }, + { url = "https://files.pythonhosted.org/packages/08/92/75fa03ad8673336689bd663ba153b378e070f159122d8478deb0940039c0/pyobjc_framework_automator-12.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:e9962ea45875fda6a648449015ccc26cc1229fdbd0166556a7271c60ba6d9011", size = 10192, upload-time = "2025-11-14T09:37:24.836Z" }, ] [[package]] name = "pyobjc-framework-avfoundation" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, @@ -4050,58 +4071,58 @@ dependencies = [ { name = "pyobjc-framework-coremedia" }, { name = "pyobjc-framework-quartz" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/f5/d4/88d226694f8e598138fbc26808bb2d3a0637500691e42d15c64f3a8c1258/pyobjc_framework_avfoundation-12.2.tar.gz", hash = "sha256:d06443acf26f3f3e16e8a9bfad42db900af3b8c3ca34c5676343d2f8e001f56b", size = 410281, upload-time = "2026-05-30T12:31:11.224Z" } +sdist = { url = "https://files.pythonhosted.org/packages/cd/42/c026ab308edc2ed5582d8b4b93da6b15d1b6557c0086914a4aabedd1f032/pyobjc_framework_avfoundation-12.1.tar.gz", hash = "sha256:eda0bb60be380f9ba2344600c4231dd58a3efafa99fdc65d3673ecfbb83f6fcb", size = 310047, upload-time = "2025-11-14T10:09:40.069Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/42/f5/54bcdd1543663f7e90560adc2ea4daf2ed6bd7ab92f734816cec79cd2244/pyobjc_framework_avfoundation-12.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:67320d3c7cb0fe1caf019d29eea38e39ede81458e3f4c13c5483892dc66f3b3a", size = 85606, upload-time = "2026-05-30T11:54:32.113Z" }, - { url = "https://files.pythonhosted.org/packages/c9/ef/f69dc23071b4b7f7a996dbeafee8afbd9be21fe2b651de2eab5d513d6622/pyobjc_framework_avfoundation-12.2-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:4b45994d9230d2751590928d0421fb7d0b7e8988e52ec1d9ab3f1d57cb869a6b", size = 86054, upload-time = "2026-05-30T11:54:38.113Z" }, + { url = "https://files.pythonhosted.org/packages/b3/d4/ade88067deff45858b457648dd82c9363977eb1915efd257232cd06bdac1/pyobjc_framework_avfoundation-12.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:f8ac7f7e0884ac8f12009cdb9d4fefc2f269294ab2ccfd84520a560859b69cec", size = 83413, upload-time = "2025-11-14T09:37:53.759Z" }, + { url = "https://files.pythonhosted.org/packages/a7/3a/fa699d748d6351fa0aeca656ea2f9eacc36e31203dfa56bc13c8a3d26d7d/pyobjc_framework_avfoundation-12.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:51aba2c6816badfb1fb5a2de1b68b33a23f065bf9e3b99d46ede0c8c774ac7a4", size = 83860, upload-time = "2025-11-14T09:38:00.051Z" }, ] [[package]] name = "pyobjc-framework-avkit" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-cocoa" }, { name = "pyobjc-framework-quartz" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/de/5e/baee189b339f0249b35da67ff07004412abd4fbf74fbcb63b0208534991b/pyobjc_framework_avkit-12.2.tar.gz", hash = "sha256:e93667aa0d1283e692c6709b79212438e5fc7eb621371f573a7eccf3ecaa57ee", size = 33572, upload-time = "2026-05-30T12:31:14.31Z" } +sdist = { url = "https://files.pythonhosted.org/packages/34/a9/e44db1a1f26e2882c140f1d502d508b1f240af9048909dcf1e1a687375b4/pyobjc_framework_avkit-12.1.tar.gz", hash = "sha256:a5c0ddb0cb700f9b09c8afeca2c58952d554139e9bb078236d2355b1fddfb588", size = 28473, upload-time = "2025-11-14T10:09:43.105Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/ec/58/d1737715102c83c82789fd8f68c323ef4571de79d4bc619800287af5b6a4/pyobjc_framework_avkit-12.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:a9867e4eb5d84c88f962118cb22a74c594909dedd3d45eea85ead9450c397e76", size = 12365, upload-time = "2026-05-30T11:55:10.836Z" }, - { url = "https://files.pythonhosted.org/packages/53/f3/f5a8f8d154b023930534a77b2039729968d0ade2136fc1c1672b40f3500a/pyobjc_framework_avkit-12.2-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:ad719d907340151ff5c3d9b067e8c152a8a23c6d18fc8256fdbc1431b40cf7d6", size = 12557, upload-time = "2026-05-30T11:55:12.539Z" }, + { url = "https://files.pythonhosted.org/packages/11/f2/4a55fdc8baca23dd315dab39479203396db54468a4c5a3e2480748ac68af/pyobjc_framework_avkit-12.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:c0241548fc7ca3fcd335da05c3dd15d7314fe58debd792317a725d8ae9cf90fa", size = 11620, upload-time = "2025-11-14T09:38:21.904Z" }, + { url = "https://files.pythonhosted.org/packages/d7/37/76d67c86db80f13f0746b493ae025482cb407b875f3138fc6a6e1fd3d5e3/pyobjc_framework_avkit-12.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:869fd54ccdac097abe36d7d4ef8945c80b9c886d881173f590b382f6c743ff12", size = 11824, upload-time = "2025-11-14T09:38:23.777Z" }, ] [[package]] name = "pyobjc-framework-avrouting" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-cocoa" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/55/5f/dcb7d6a4615c0f4b80492b0ba778f0b49aba6c6b4c3a727d0bf38696aa28/pyobjc_framework_avrouting-12.2.tar.gz", hash = "sha256:78affe0c4335ff47f186fed21965f8a381e46429c1a52794044cf2835b48dd4f", size = 20872, upload-time = "2026-05-30T12:31:16.386Z" } +sdist = { url = "https://files.pythonhosted.org/packages/6e/83/15bf6c28ec100dae7f92d37c9e117b3b4ee6b4873db062833e16f1cfd6c4/pyobjc_framework_avrouting-12.1.tar.gz", hash = "sha256:6a6c5e583d14f6501df530a9d0559a32269a821fc8140e3646015f097155cd1c", size = 20031, upload-time = "2025-11-14T10:09:45.701Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/43/51/2a34dab903467a34377de5ddc111b33506eb297fa1103a433e00a4352c80/pyobjc_framework_avrouting-12.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:72a6408801282037ded8a852c5d266d0e99b637496ef3aee1ac179cdd89b8d76", size = 8496, upload-time = "2026-05-30T11:55:26.359Z" }, - { url = "https://files.pythonhosted.org/packages/96/28/015dca6d3acabb21f3e93942aff5cb4420f82ded98e2761d13d932837f35/pyobjc_framework_avrouting-12.2-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:feee657352beaa05d98a00d5e744d1d7a95572baa2df34f55496ee70bfc74d35", size = 8649, upload-time = "2026-05-30T11:55:28.273Z" }, + { url = "https://files.pythonhosted.org/packages/3b/a4/cdbbe5745a49c9c5f5503dbbdd1b90084d4be83bd8503c998db160bb378e/pyobjc_framework_avrouting-12.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:18c62af1ce9ac99b04c36f66959ca64530d51b62aa0e6f00400dea600112e370", size = 8465, upload-time = "2025-11-14T09:38:37.638Z" }, + { url = "https://files.pythonhosted.org/packages/29/d7/c709d277e872495f452fe797c619d9b202cd388b655ccf7196724dbbb600/pyobjc_framework_avrouting-12.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:e5a1d2e4e431aae815e38b75dbe644aa1fd495f8ec1e2194fc175132d7cfc1d3", size = 8630, upload-time = "2025-11-14T09:38:39.284Z" }, ] [[package]] name = "pyobjc-framework-backgroundassets" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-cocoa" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/cf/3c/b344ae79feea1d4169c2e95684d9cd8b938391371b3db8f24abb98501c12/pyobjc_framework_backgroundassets-12.2.tar.gz", hash = "sha256:6df332f129cc025843f5ba6affe651bbf6499b6be35d781fbb12b52250adba9e", size = 29362, upload-time = "2026-05-30T12:31:19.017Z" } +sdist = { url = "https://files.pythonhosted.org/packages/34/d1/e917fba82790495152fd3508c5053827658881cf7e9887ba60def5e3f221/pyobjc_framework_backgroundassets-12.1.tar.gz", hash = "sha256:8da34df9ae4519c360c429415477fdaf3fbba5addbc647b3340b8783454eb419", size = 26210, upload-time = "2025-11-14T10:09:48.792Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/02/a9/b68ebcab2895a659cc18dcb9890aff8fb2f19f9f4e97dee2197de5608671/pyobjc_framework_backgroundassets-12.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:9f40f72349412f7fe9b55e083de77f1ade5c33de8be529633727c83689421a21", size = 10943, upload-time = "2026-05-30T11:55:41.4Z" }, - { url = "https://files.pythonhosted.org/packages/68/31/5e8d83b4a2269a6b8ba98a342852c5fcd6715390396c5a088e9efa88d9f3/pyobjc_framework_backgroundassets-12.2-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:1cdb5e2c45786a6a36dea60fddc90251c6482bb6d1c05b499258ecd2a6972d05", size = 11192, upload-time = "2026-05-30T11:55:43.007Z" }, + { url = "https://files.pythonhosted.org/packages/04/9b/872f9ff0593ffb9dbc029dc775390b0e45fe3278068b28aade8060503003/pyobjc_framework_backgroundassets-12.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:a089a71b2db471f5af703e35f7a61060164d61eb60a3f482076826dfa5697c7c", size = 10803, upload-time = "2025-11-14T09:38:49.996Z" }, + { url = "https://files.pythonhosted.org/packages/cc/44/4afc2e8bcf16919b1ab82eaf88067469ea255b0a3390d353fec1002dbd0a/pyobjc_framework_backgroundassets-12.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:e8c560f1aaa7a4bf6e336806749ce0a20f2a792ab924d9424714e299a59b3edf", size = 11058, upload-time = "2025-11-14T09:38:51.743Z" }, ] [[package]] name = "pyobjc-framework-browserenginekit" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, @@ -4110,82 +4131,82 @@ dependencies = [ { name = "pyobjc-framework-coremedia" }, { name = "pyobjc-framework-quartz" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/22/57/b5529f648215f9abf7f7bb5f57737b75d2cb12936a28907258d6ce2846e8/pyobjc_framework_browserenginekit-12.2.tar.gz", hash = "sha256:f38924bc5e8ab80d1248b00554015b4a86ec3c3c17c779a3e43a0179671e4d69", size = 32610, upload-time = "2026-05-30T12:31:21.925Z" } +sdist = { url = "https://files.pythonhosted.org/packages/5d/b9/39f9de1730e6f8e73be0e4f0c6087cd9439cbe11645b8052d22e1fb8e69b/pyobjc_framework_browserenginekit-12.1.tar.gz", hash = "sha256:6a1a34a155778ab55ab5f463e885f2a3b4680231264e1fe078e62ddeccce49ed", size = 29120, upload-time = "2025-11-14T10:09:51.582Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/8b/c4/34535b9a061dc619a2f3910d15fde604210187cda07bba4c720fedc77d26/pyobjc_framework_browserenginekit-12.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:e500aa3ad0c9ef5787bc72a42474d58f8b3355d16f8944dabbe5db2f15a4634d", size = 11760, upload-time = "2026-05-30T11:55:56.77Z" }, - { url = "https://files.pythonhosted.org/packages/63/05/c0c40325e75fbcf70372b7bea10eb875b24ced3582f580205d5a58ef72e4/pyobjc_framework_browserenginekit-12.2-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:88b2b6d5cf7b1e91029e3f32fa950bbed2cf43228ef6a0869bde915caf841152", size = 11927, upload-time = "2026-05-30T11:55:58.441Z" }, + { url = "https://files.pythonhosted.org/packages/5b/2c/d39ab696b0316e1faf112a3aee24ef3bcb5fb42eb5db18ba2d74264a41a8/pyobjc_framework_browserenginekit-12.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:1aa2da131bbdf81748894c18d253cd2711dc535f1711263c6c604e20cdc094a6", size = 11567, upload-time = "2025-11-14T09:39:02.811Z" }, + { url = "https://files.pythonhosted.org/packages/0e/dd/624d273beea036ec20e16f8bdaaca6b062da647b785dedf90fa2a92a8cc0/pyobjc_framework_browserenginekit-12.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:657d78bb5c1a51097560cb3219692321640d0d5c8e57e9160765e1ecfb3fe7ef", size = 11738, upload-time = "2025-11-14T09:39:04.651Z" }, ] [[package]] name = "pyobjc-framework-businesschat" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-cocoa" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/8b/1a/9ad0a1f52f5c670948a71eceb295b6273fa7b3422651f660f9eaac5c3078/pyobjc_framework_businesschat-12.2.tar.gz", hash = "sha256:77809904d62b18377e0764458044f30ba380f462f616cb69628431814afb6f14", size = 12403, upload-time = "2026-05-30T12:31:23.707Z" } +sdist = { url = "https://files.pythonhosted.org/packages/4d/da/bc09b6ed19e9ea38ecca9387c291ca11fa680a8132d82b27030f82551c23/pyobjc_framework_businesschat-12.1.tar.gz", hash = "sha256:f6fa3a8369a1a51363e1757530128741d9d09ed90692a1d6777a4c0fbad25868", size = 12055, upload-time = "2025-11-14T10:09:53.436Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/6b/19/5b9e89bf4c62bfe4ab844027f75786d171aee623fb4ca0c4dc46e67ffd7a/pyobjc_framework_businesschat-12.2-py2.py3-none-any.whl", hash = "sha256:c96bceb6796f1fb82edafcda75d5abb59e165aa0f55a6e646638ab56d94ceaa3", size = 3477, upload-time = "2026-05-30T11:56:06.861Z" }, + { url = "https://files.pythonhosted.org/packages/53/88/4c727424b05efa33ed7f6c45e40333e5a8a8dc5bb238e34695addd68463b/pyobjc_framework_businesschat-12.1-py2.py3-none-any.whl", hash = "sha256:f66ce741507b324de3c301d72ba0cfa6aaf7093d7235972332807645c118cc29", size = 3474, upload-time = "2025-11-14T09:39:10.771Z" }, ] [[package]] name = "pyobjc-framework-calendarstore" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-cocoa" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/06/ae/e6ab01011033d45501d96e388eff16185152ce2459174b13e22d90c721a1/pyobjc_framework_calendarstore-12.2.tar.gz", hash = "sha256:26fd412f9c4b9bf5243d44f87b03e24c80562012f6db4ec88c78cc2ffe63e7bd", size = 54421, upload-time = "2026-05-30T12:31:27.857Z" } +sdist = { url = "https://files.pythonhosted.org/packages/88/41/ae955d1c44dcc18b5b9df45c679e9a08311a0f853b9d981bca760cf1eef2/pyobjc_framework_calendarstore-12.1.tar.gz", hash = "sha256:f9a798d560a3c99ad4c0d2af68767bc5695d8b1aabef04d8377861cd1d6d1670", size = 52272, upload-time = "2025-11-14T10:09:58.48Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/15/f7/356d958ef979f1dc7c01c0a94f0a0b0bf409919308b69e5eee750772f480/pyobjc_framework_calendarstore-12.2-py2.py3-none-any.whl", hash = "sha256:cc9b0cee139d0552d8b924aca13c8ea3a51caa0e2bbf57540d84f249decd3846", size = 5288, upload-time = "2026-05-30T11:56:08.493Z" }, + { url = "https://files.pythonhosted.org/packages/fa/70/f68aebdb7d3fa2dec2e9da9e9cdaa76d370de326a495917dbcde7bb7711e/pyobjc_framework_calendarstore-12.1-py2.py3-none-any.whl", hash = "sha256:18533e0fcbcdd29ee5884dfbd30606710f65df9b688bf47daee1438ee22e50cc", size = 5285, upload-time = "2025-11-14T09:39:12.473Z" }, ] [[package]] name = "pyobjc-framework-callkit" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-cocoa" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/c7/63/f050271956d5742acde26d04ec6e602af9c39e6ac338c161cdd44b083016/pyobjc_framework_callkit-12.2.tar.gz", hash = "sha256:862c4e7475cfc2ee6c663f042fc4a025cbf07edb7608aa8556e64a0591e070fe", size = 32654, upload-time = "2026-05-30T12:31:30.748Z" } +sdist = { url = "https://files.pythonhosted.org/packages/1a/c0/1859d4532d39254df085309aff55b85323576f00a883626325af40da4653/pyobjc_framework_callkit-12.1.tar.gz", hash = "sha256:fd6dc9688b785aab360139d683be56f0844bf68bf5e45d0eb770cb68221083cc", size = 29171, upload-time = "2025-11-14T10:10:01.336Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/87/7a/4ac154b5bef806a770de93ff5bd5cb67ac92ddb92ceef697222919a8dcfe/pyobjc_framework_callkit-12.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:09f8e08298a46ceb53e50c1e17c5dd9e06ac2096f1bda2f956f2ba8693e91ca6", size = 11376, upload-time = "2026-05-30T11:56:15.663Z" }, - { url = "https://files.pythonhosted.org/packages/f8/f3/72f5b9a00b7adea3cda7d911414c8deaf0bf37e0396c9c918147fa002005/pyobjc_framework_callkit-12.2-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:b7242585de40273f82c084fe00a1658f34b0357695f008c8c468ef08c50cc2d4", size = 11590, upload-time = "2026-05-30T11:56:17.342Z" }, + { url = "https://files.pythonhosted.org/packages/37/30/f434921c17a59d8db06783189ca98ccf291d5366be364f96439e987c1b13/pyobjc_framework_callkit-12.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:b8909402f8690ea2fe8fa7c0256b5c491435f20881832808b86433f526ff28f8", size = 11347, upload-time = "2025-11-14T09:39:20.412Z" }, + { url = "https://files.pythonhosted.org/packages/f0/b8/c6a52c3c2e1e0bd23a84fef0d2cb089c456d62add59f87d8510ffe871068/pyobjc_framework_callkit-12.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:9ec6635b6a6fecde6e5252ceff76c71d699ed8e0f3ebc6fd220a351dc653040b", size = 11558, upload-time = "2025-11-14T09:39:22.266Z" }, ] [[package]] name = "pyobjc-framework-carbon" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-cocoa" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/35/ee/91f41ac1e637b999ba80ee3d5d2ceafaef8d8709012dbb8d0a904136ad76/pyobjc_framework_carbon-12.2.tar.gz", hash = "sha256:965a291f5d5db032057e00666b5a6baed66c564451db66e005fd88be17ed8e27", size = 39741, upload-time = "2026-05-30T12:31:33.954Z" } +sdist = { url = "https://files.pythonhosted.org/packages/0c/0f/9ab8e518a4e5ac4a1e2fdde38a054c32aef82787ff7f30927345c18b7765/pyobjc_framework_carbon-12.1.tar.gz", hash = "sha256:57a72807db252d5746caccc46da4bd20ff8ea9e82109af9f72735579645ff4f0", size = 37293, upload-time = "2025-11-14T10:10:04.464Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/0c/6c/4600816c385ad52f748bf527c4ed15a15d51fb79770bb0a5d6642c4f49a3/pyobjc_framework_carbon-12.2-py2.py3-none-any.whl", hash = "sha256:2420af5872473b91080b8000a50ab2e5053611dc68c094e257b75939f3fddef4", size = 4624, upload-time = "2026-05-30T11:56:25.712Z" }, + { url = "https://files.pythonhosted.org/packages/a4/9e/91853c8f98b9d5bccf464113908620c94cc12c2a3e4625f3ce172e3ea4bc/pyobjc_framework_carbon-12.1-py2.py3-none-any.whl", hash = "sha256:f8b719b3c7c5cf1d61ac7c45a8a70b5e5e5a83fa02f5194c2a48a7e81a3d1b7f", size = 4625, upload-time = "2025-11-14T09:39:27.937Z" }, ] [[package]] name = "pyobjc-framework-cfnetwork" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-cocoa" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/ce/01/3976ae7dca6f2f35659c364c2e8454a678f730f96f50d41f8ff53cb00d8d/pyobjc_framework_cfnetwork-12.2.tar.gz", hash = "sha256:d50078305b840d1c4f9d47c7c7cb66508766189f9aec6683f4207fccd6d096ee", size = 47633, upload-time = "2026-05-30T12:31:37.914Z" } +sdist = { url = "https://files.pythonhosted.org/packages/d2/6a/f5f0f191956e187db85312cbffcc41bf863670d121b9190b4a35f0d36403/pyobjc_framework_cfnetwork-12.1.tar.gz", hash = "sha256:2d16e820f2d43522c793f55833fda89888139d7a84ca5758548ba1f3a325a88d", size = 44383, upload-time = "2025-11-14T10:10:08.428Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/07/fe/f89406f7cadd648eccb03d2777860b748f04db3245fd4bc7b1355cb00cca/pyobjc_framework_cfnetwork-12.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:0b4c2eba6d1060b3e0e7d63bb67d2d14b46a7e51fa8ab2c2e7767cee266f548a", size = 20145, upload-time = "2026-05-30T11:56:34.838Z" }, - { url = "https://files.pythonhosted.org/packages/2d/5d/3bb11f406df581059d65a7807dd986796aa388a33da1c816b37238c2b889/pyobjc_framework_cfnetwork-12.2-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:f4d6db3702593b2a93cf9b793f3eaac6c0fa7d128a5abcf9f8b7a65079930e5c", size = 20449, upload-time = "2026-05-30T11:56:37.185Z" }, + { url = "https://files.pythonhosted.org/packages/f4/36/d6b95a5b156de5e2c071ecb7f7056f0badb3a0d09e0dbcf0d8d35743f822/pyobjc_framework_cfnetwork-12.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:86cc3f650d3169cd8ce4a1438219aa750accac0efc29539920ab0a7e75e25ab4", size = 19135, upload-time = "2025-11-14T09:39:39.95Z" }, + { url = "https://files.pythonhosted.org/packages/4b/23/ff66133af4592e123320337f443aa6e36993cc48d6c10f6e7436e01678b1/pyobjc_framework_cfnetwork-12.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:5ff3e246e5186b9bad23b2e4e856ca87eaa9329f5904643c5484510059a07e24", size = 19412, upload-time = "2025-11-14T09:39:42.412Z" }, ] [[package]] name = "pyobjc-framework-cinematic" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, @@ -4194,28 +4215,28 @@ dependencies = [ { name = "pyobjc-framework-coremedia" }, { name = "pyobjc-framework-metal" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/e2/dc/afc97af264e477fea0f95b54f13350119d69d6eeeb68a6698452295576ed/pyobjc_framework_cinematic-12.2.tar.gz", hash = "sha256:2bec1954c5241e5c8dbefcab6d5b300e62f76eb3907a177840357f9de8474d7a", size = 24960, upload-time = "2026-05-30T12:31:40.317Z" } +sdist = { url = "https://files.pythonhosted.org/packages/67/4e/f4cc7f9f7f66df0290c90fe445f1ff5aa514c6634f5203fe049161053716/pyobjc_framework_cinematic-12.1.tar.gz", hash = "sha256:795068c30447548c0e8614e9c432d4b288b13d5614622ef2f9e3246132329b06", size = 21215, upload-time = "2025-11-14T10:10:10.795Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/ca/b6/97ff3fa5efbd7b80d40ab5be590f92b7a7ed711ce01812bd0a0a3c0453d8/pyobjc_framework_cinematic-12.2-py2.py3-none-any.whl", hash = "sha256:8df478081b8248a32e91aa2981806e05c551bc6f9ec1286b5ca2d1c64e981f6a", size = 5101, upload-time = "2026-05-30T11:56:47.469Z" }, + { url = "https://files.pythonhosted.org/packages/c9/a0/cd85c827ce5535c08d936e5723c16ee49f7ff633f2e9881f4f58bf83e4ce/pyobjc_framework_cinematic-12.1-py2.py3-none-any.whl", hash = "sha256:c003543bb6908379680a93dfd77a44228686b86c118cf3bc930f60241d0cd141", size = 5031, upload-time = "2025-11-14T09:39:49.003Z" }, ] [[package]] name = "pyobjc-framework-classkit" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-cocoa" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/6e/35/40a13933e42581a127334faebba2d352a01d3baab02693b31ca4622073bc/pyobjc_framework_classkit-12.2.tar.gz", hash = "sha256:41ca16e92a844bed689b634707a07ebd38bf53e1a0793bcb1005347221889d7e", size = 28943, upload-time = "2026-05-30T12:31:42.786Z" } +sdist = { url = "https://files.pythonhosted.org/packages/ac/ef/67815278023b344a79c7e95f748f647245d6f5305136fc80615254ad447c/pyobjc_framework_classkit-12.1.tar.gz", hash = "sha256:8d1e9dd75c3d14938ff533d88b72bca2d34918e4461f418ea323bfb2498473b4", size = 26298, upload-time = "2025-11-14T10:10:13.406Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/cf/54/bb0db5a07037e4745deb8f0176cf78b03e4176bcd965693998fec86f5b4e/pyobjc_framework_classkit-12.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:168c875649e7e43192ef2961569fdf2ac77f662a29417991a99dff5a44dd9881", size = 8940, upload-time = "2026-05-30T11:56:54.141Z" }, - { url = "https://files.pythonhosted.org/packages/91/93/d6581548debc49ce93d94eb909d663ab1bbf15439f3febd5ba7cfda91481/pyobjc_framework_classkit-12.2-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:b593774ad4809c896d735fe3c0d69664cc74d3abe56d1a5fee809a7c05646ea6", size = 9090, upload-time = "2026-05-30T11:56:55.714Z" }, + { url = "https://files.pythonhosted.org/packages/a5/47/f89917b4683a8f61c64d5d30d64ed0a5c1cfd9f0dd9dfb099b3465c73bcf/pyobjc_framework_classkit-12.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:0ac959a4e91a40865f12f041c083fa8862672f13e596c983f2b99afc8c67bc4e", size = 8890, upload-time = "2025-11-14T09:39:56.65Z" }, + { url = "https://files.pythonhosted.org/packages/b4/9b/8a0dc753e73001026663fe8556895b23fbf6c238a705bfc86d8ce191eee3/pyobjc_framework_classkit-12.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:61fdac9e3bad384b47725587b77f932dbed71d0ae63b749eddfa390791eed4a2", size = 9043, upload-time = "2025-11-14T09:39:58.684Z" }, ] [[package]] name = "pyobjc-framework-cloudkit" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, @@ -4224,907 +4245,907 @@ dependencies = [ { name = "pyobjc-framework-coredata" }, { name = "pyobjc-framework-corelocation" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/19/57/418b22c326c62f03341e7a974852c5a5bae4dfce1ec88a570e22f14c662d/pyobjc_framework_cloudkit-12.2.tar.gz", hash = "sha256:7849629cc7c726c1a3e16b3324d9fac57f72b938a66f10d480f52e381bef1223", size = 71957, upload-time = "2026-05-30T12:31:47.863Z" } +sdist = { url = "https://files.pythonhosted.org/packages/2d/09/762ee4f3ae8568b8e0e5392c705bc4aa1929aa454646c124ca470f1bf9fc/pyobjc_framework_cloudkit-12.1.tar.gz", hash = "sha256:1dddd38e60863f88adb3d1d37d3b4ccb9cbff48c4ef02ab50e36fa40c2379d2f", size = 53730, upload-time = "2025-11-14T10:10:17.831Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/cc/01/1ad78a6eebbbac6381aa1163028dfe74ccc4111444ecfc1954b4d02a53b1/pyobjc_framework_cloudkit-12.2-py2.py3-none-any.whl", hash = "sha256:1e00a6d02ac005a4dd31aa0aa5e22fdd3e05f8324f91a175dfae7fd45d85afd1", size = 11412, upload-time = "2026-05-30T11:57:04.221Z" }, + { url = "https://files.pythonhosted.org/packages/35/71/cbef7179bf1a594558ea27f1e5ad18f5c17ef71a8a24192aae16127bc849/pyobjc_framework_cloudkit-12.1-py2.py3-none-any.whl", hash = "sha256:875e37bf1a2ce3d05c2492692650104f2d908b56b71a0aedf6620bc517c6c9ca", size = 11090, upload-time = "2025-11-14T09:40:04.207Z" }, ] [[package]] name = "pyobjc-framework-cocoa" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/6d/cc/927169225e72bab9c9b44285656768fb75052a0bc85fdbca62740e1ca43c/pyobjc_framework_cocoa-12.2.tar.gz", hash = "sha256:20b392e2b7241caad0538dfde12143343e5dfe48f72e7df660a7548e635903dc", size = 3125555, upload-time = "2026-05-30T12:35:09.273Z" } +sdist = { url = "https://files.pythonhosted.org/packages/02/a3/16ca9a15e77c061a9250afbae2eae26f2e1579eb8ca9462ae2d2c71e1169/pyobjc_framework_cocoa-12.1.tar.gz", hash = "sha256:5556c87db95711b985d5efdaaf01c917ddd41d148b1e52a0c66b1a2e2c5c1640", size = 2772191, upload-time = "2025-11-14T10:13:02.069Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/3f/3b/1af2be2bf5204bbcfc94de215d5f87d35348c9982d9b05f54ceefbc53b8f/pyobjc_framework_cocoa-12.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:f0bbe0abedfb24b11ff6c71e26cdefb0df001c6482f95591fad40c2688c16498", size = 388154, upload-time = "2026-05-30T11:58:38.547Z" }, - { url = "https://files.pythonhosted.org/packages/41/cb/c0435d64f1199210af36141b90aea2ae3344719f7313d4160b8b0dd527db/pyobjc_framework_cocoa-12.2-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:46b6681e2b21b099ed095339c140f2c8137d6ac5658653166ee90722f9e3c621", size = 392245, upload-time = "2026-05-30T11:59:02.436Z" }, + { url = "https://files.pythonhosted.org/packages/ad/31/0c2e734165abb46215797bd830c4bdcb780b699854b15f2b6240515edcc6/pyobjc_framework_cocoa-12.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:5a3dcd491cacc2f5a197142b3c556d8aafa3963011110102a093349017705118", size = 384689, upload-time = "2025-11-14T09:41:41.478Z" }, + { url = "https://files.pythonhosted.org/packages/23/3b/b9f61be7b9f9b4e0a6db18b3c35c4c4d589f2d04e963e2174d38c6555a92/pyobjc_framework_cocoa-12.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:914b74328c22d8ca261d78c23ef2befc29776e0b85555973927b338c5734ca44", size = 388843, upload-time = "2025-11-14T09:42:05.719Z" }, ] [[package]] name = "pyobjc-framework-collaboration" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-cocoa" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/ed/72/f84e5835a01f42a8b14c165490e24ba72839ed411a24bd7217f4d37c7d54/pyobjc_framework_collaboration-12.2.tar.gz", hash = "sha256:77707156f677c502fa973bbb3028ad1cea8557875e75f1a03f605678c881289a", size = 15069, upload-time = "2026-05-30T12:35:11.891Z" } +sdist = { url = "https://files.pythonhosted.org/packages/64/21/77fe64b39eae98412de1a0d33e9c735aa9949d53fff6b2d81403572b410b/pyobjc_framework_collaboration-12.1.tar.gz", hash = "sha256:2afa264d3233fc0a03a56789c6fefe655ffd81a2da4ba1dc79ea0c45931ad47b", size = 14299, upload-time = "2025-11-14T10:13:04.631Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/49/d8/a1eb9888ca7ee599bc484feb78c43453f8c154c986bdc0daff4948fe39c7/pyobjc_framework_collaboration-12.2-py2.py3-none-any.whl", hash = "sha256:219f8e5b1f0cc25dc48460ca909c09127eb80b3aa0262cb50139cd46c84b63d1", size = 4853, upload-time = "2026-05-30T12:00:39.271Z" }, + { url = "https://files.pythonhosted.org/packages/2a/66/1507de01f1e2b309f8e11553a52769e4e2e9939ed770b5b560ef5bc27bc1/pyobjc_framework_collaboration-12.1-py2.py3-none-any.whl", hash = "sha256:182d6e6080833b97f9bef61738ae7bacb509714538f0d7281e5f0814c804b315", size = 4907, upload-time = "2025-11-14T09:42:55.781Z" }, ] [[package]] name = "pyobjc-framework-colorsync" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-cocoa" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/d0/7c/eefce8ea94a1817842b54a1d6d472ae184749ca6ad8d84386436b10ac757/pyobjc_framework_colorsync-12.2.tar.gz", hash = "sha256:b403820f3504b0e728f883575637c217a2043fafca5c0b315f03c88805d37958", size = 26911, upload-time = "2026-05-30T12:35:14.46Z" } +sdist = { url = "https://files.pythonhosted.org/packages/c0/b4/706e4cc9db25b400201fc90f3edfaa1ab2d51b400b19437b043a68532078/pyobjc_framework_colorsync-12.1.tar.gz", hash = "sha256:d69dab7df01245a8c1bd536b9231c97993a5d1a2765d77692ce40ebbe6c1b8e9", size = 25269, upload-time = "2025-11-14T10:13:07.522Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/e0/c7/0562840adbfaa21c37ced637653e4ade70618e911a151974c53d25c8f5d9/pyobjc_framework_colorsync-12.2-py2.py3-none-any.whl", hash = "sha256:5d2ce9acd7ec28133facf0af900fc4a5d36971083811eb6da775be4b659f9b77", size = 6006, upload-time = "2026-05-30T12:00:40.915Z" }, + { url = "https://files.pythonhosted.org/packages/e8/e1/82e45c712f43905ee1e6d585180764e8fa6b6f1377feb872f9f03c8c1fb8/pyobjc_framework_colorsync-12.1-py2.py3-none-any.whl", hash = "sha256:41e08d5b9a7af4b380c9adab24c7ff59dfd607b3073ae466693a3e791d8ffdc9", size = 6020, upload-time = "2025-11-14T09:42:57.504Z" }, ] [[package]] name = "pyobjc-framework-compositorservices" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-cocoa" }, { name = "pyobjc-framework-metal" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/c1/da/0f975d3bb2efbcd305d76f9c8869b5918116731e739cf071630ac3e1f818/pyobjc_framework_compositorservices-12.2.tar.gz", hash = "sha256:2c1e940959270aeded95b573ed57c9edd7d3da0ccd45fb5be262c93cc62e2704", size = 24919, upload-time = "2026-05-30T12:35:16.745Z" } +sdist = { url = "https://files.pythonhosted.org/packages/54/c5/0ba31d7af7e464b7f7ece8c2bd09112bdb0b7260848402e79ba6aacc622c/pyobjc_framework_compositorservices-12.1.tar.gz", hash = "sha256:028e357bbee7fbd3723339a321bbe14e6da5a772708a661a13eea5f17c89e4ab", size = 23292, upload-time = "2025-11-14T10:13:10.392Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/ad/86/f172e0a687dec40e7809e1efdffeb666c8d369cb73c7e50cb6f84d0b49cf/pyobjc_framework_compositorservices-12.2-py2.py3-none-any.whl", hash = "sha256:486f5e70250892122ba90f2923dc955a3622c4a047536ee3a0b15bd3568cd171", size = 5972, upload-time = "2026-05-30T12:00:42.699Z" }, + { url = "https://files.pythonhosted.org/packages/f9/34/5a2de8d531dbb88023898e0b5d2ce8edee14751af6c70e6103f6aa31a669/pyobjc_framework_compositorservices-12.1-py2.py3-none-any.whl", hash = "sha256:9ef22d4eacd492e13099b9b8936db892cdbbef1e3d23c3484e0ed749f83c4984", size = 5910, upload-time = "2025-11-14T09:42:59.154Z" }, ] [[package]] name = "pyobjc-framework-contacts" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-cocoa" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/3d/fd/b1569ca626fef30123f0fa5d3cb6126e171cea0900434e4b629f15c5f403/pyobjc_framework_contacts-12.2.tar.gz", hash = "sha256:117989ffed4f41d0bbf7e81dde8154a31995d2adf1fe898c2917bc6e9c1dc122", size = 48703, upload-time = "2026-05-30T12:35:20.347Z" } +sdist = { url = "https://files.pythonhosted.org/packages/4b/a0/ce0542d211d4ea02f5cbcf72ee0a16b66b0d477a4ba5c32e00117703f2f0/pyobjc_framework_contacts-12.1.tar.gz", hash = "sha256:89bca3c5cf31404b714abaa1673577e1aaad6f2ef49d4141c6dbcc0643a789ad", size = 42378, upload-time = "2025-11-14T10:13:14.203Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/b9/79/609e55416da80222dbce2ca761f70ced7e45c85244f7b66e8713eb26dae8/pyobjc_framework_contacts-12.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:1ee92445cb2c5168df0b25bb6d897b1389d55571eb6bba229431c1d933940a7a", size = 12164, upload-time = "2026-05-30T12:00:50.096Z" }, - { url = "https://files.pythonhosted.org/packages/18/36/701eff1da16bb3d89dc28d0db6acf5604650dad6b722cbcba2ad9c8a6233/pyobjc_framework_contacts-12.2-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:91748bc3a42723d088f7ded819cf0155868b9bca16ed8cd753695bc71710f45d", size = 12325, upload-time = "2026-05-30T12:00:51.734Z" }, + { url = "https://files.pythonhosted.org/packages/25/43/e322dd14c77eada5a4f327f5bc094061c90efabc774b30396d1155a69c44/pyobjc_framework_contacts-12.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:62d985098aa86a86d23bff408aac47389680da4edc61f6acf10b2197efcbd0e0", size = 12177, upload-time = "2025-11-14T09:43:06.957Z" }, + { url = "https://files.pythonhosted.org/packages/0a/37/53eba15f2e31950056c63b78732b73379ddbf946c5e6681f3b2773dcf282/pyobjc_framework_contacts-12.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:ab1d78f363dfede16bd5d951327332564bae86f68834d1e657dd18fe4dc12082", size = 12346, upload-time = "2025-11-14T09:43:08.865Z" }, ] [[package]] name = "pyobjc-framework-contactsui" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-cocoa" }, { name = "pyobjc-framework-contacts" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/e1/e1/8f51114ec751ad746cd0aaefcb130f5dd3b09537a326425b4c8f47fc1345/pyobjc_framework_contactsui-12.2.tar.gz", hash = "sha256:ca1ab431b8838240877d8c8c1776d58c7eae9f9a7b193b0cc761162f6baf58bb", size = 19347, upload-time = "2026-05-30T12:35:22.591Z" } +sdist = { url = "https://files.pythonhosted.org/packages/cd/0c/7bb7f898456a81d88d06a1084a42e374519d2e40a668a872b69b11f8c1f9/pyobjc_framework_contactsui-12.1.tar.gz", hash = "sha256:aaeca7c9e0c9c4e224d73636f9a558f9368c2c7422155a41fd4d7a13613a77c1", size = 18769, upload-time = "2025-11-14T10:13:16.301Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/8c/e9/e4433cf42edaf26aaec04a4c059733b98ad9c0982a5e72da192309fbe391/pyobjc_framework_contactsui-12.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:8ac61436333c416fada5053c9d8b1879f82efa9bd96fbd5027da6ffcde0728b4", size = 7903, upload-time = "2026-05-30T12:01:05.63Z" }, - { url = "https://files.pythonhosted.org/packages/db/c2/cc3c32d9811798adf6404b8204731f855714869dd0e0476b6b4d6302ef42/pyobjc_framework_contactsui-12.2-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:2c7a4f5e89a22eafc056a52caa07e96f35b82a628b42a9c47d0720634ee01099", size = 8051, upload-time = "2026-05-30T12:01:07.166Z" }, + { url = "https://files.pythonhosted.org/packages/fd/9c/c9a71681e2ad8695222dbdbbe740af22cc354e9130df6108f9bfe90a4100/pyobjc_framework_contactsui-12.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:2ee2eccb633bc772ecb49dba7199546154efc2db5727992229cdf84b3f6ac84f", size = 7907, upload-time = "2025-11-14T09:43:20.409Z" }, + { url = "https://files.pythonhosted.org/packages/a0/54/abdb4c5f53323edc1e02bd0916133c4e6b82ad268eded668ef7b40a1e6c9/pyobjc_framework_contactsui-12.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:c9d64bbc4cfae0f082627b57f7e29e71b924af970f344b106b17fb68e13f7da0", size = 8056, upload-time = "2025-11-14T09:43:22Z" }, ] [[package]] name = "pyobjc-framework-coreaudio" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-cocoa" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/c3/d0/6e4adb375b81c06fbf28d758ea60281cf78f5675a68f7f3613d5ca28aa71/pyobjc_framework_coreaudio-12.2.tar.gz", hash = "sha256:1990be9a9311869b551e6a997ee84bee12ea38fc978d5fa7fc0119caff2f9ba5", size = 78669, upload-time = "2026-05-30T12:35:28.189Z" } +sdist = { url = "https://files.pythonhosted.org/packages/84/d1/0b884c5564ab952ff5daa949128c64815300556019c1bba0cf2ca752a1a0/pyobjc_framework_coreaudio-12.1.tar.gz", hash = "sha256:a9e72925fcc1795430496ce0bffd4ddaa92c22460a10308a7283ade830089fe1", size = 75077, upload-time = "2025-11-14T10:13:22.345Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/14/3a/d2905ed8f0bfd74d7284e4018e11bf22f027e3ce7921a3298322d2273b4b/pyobjc_framework_coreaudio-12.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:505564f35227b6bf3bcfcc950edeae81628724202eb2a49f4bf213be39589521", size = 35423, upload-time = "2026-05-30T12:01:25.959Z" }, - { url = "https://files.pythonhosted.org/packages/1d/33/cf17a929f444bca49a88f4c059868eda4ecf94ab7ab89e4d47b943d5a824/pyobjc_framework_coreaudio-12.2-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:1640bf44b001c960ae7ae84a43382141711bfbee439c88dea3872c64556e0308", size = 38179, upload-time = "2026-05-30T12:01:29.23Z" }, + { url = "https://files.pythonhosted.org/packages/3d/ce/45808618fefc760e2948c363e0a3402ff77690c8934609cd07b19bc5b15f/pyobjc_framework_coreaudio-12.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:3d8ef424850c8ae2146f963afaec6c4f5bf0c2e412871e68fb6ecfb209b8376f", size = 36935, upload-time = "2025-11-14T09:43:39.414Z" }, + { url = "https://files.pythonhosted.org/packages/bf/f6/0d74d9464bfb4f39451abf745174ec0c4d5c5ebf1c2fcb7556263ae3f75a/pyobjc_framework_coreaudio-12.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:6552624df39dbc68ff9328f244ba56f59234ecbde8455db1e617a71bc4f3dd3a", size = 38390, upload-time = "2025-11-14T09:43:43.194Z" }, ] [[package]] name = "pyobjc-framework-coreaudiokit" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-cocoa" }, { name = "pyobjc-framework-coreaudio" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/c1/d0/189f067979cd117cfb1464dac24bd64e1d4127b09366fbf17a9bec84984b/pyobjc_framework_coreaudiokit-12.2.tar.gz", hash = "sha256:cb743400fff2cc0ee5837d124c1665135559d8505d28996423ed4a609221614c", size = 20916, upload-time = "2026-05-30T12:35:30.615Z" } +sdist = { url = "https://files.pythonhosted.org/packages/41/1c/5c7e39b9361d4eec99b9115b593edd9825388acd594cb3b4519f8f1ac12c/pyobjc_framework_coreaudiokit-12.1.tar.gz", hash = "sha256:b83624f8de3068ab2ca279f786be0804da5cf904ff9979d96007b69ef4869e1e", size = 20137, upload-time = "2025-11-14T10:13:24.611Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/f6/e4/d59c8bc9f0dc3c953887fa9b5be06ffb6b007e3fe931b4faebb533c10e1b/pyobjc_framework_coreaudiokit-12.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:1da5bdab7f4d3c3f6b420f3d57e28a05c620e71cd3310499d415db0bb1f65c7f", size = 7286, upload-time = "2026-05-30T12:01:48.762Z" }, - { url = "https://files.pythonhosted.org/packages/06/69/e46f04648626f8c70cfb5e024fd52a3ab3c832e40039b7d125fe62d2a49c/pyobjc_framework_coreaudiokit-12.2-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:baaa6b2c32fe2cd2d554f0503b773710f21e061ad544773c86d7df95ddd983ab", size = 7449, upload-time = "2026-05-30T12:01:50.363Z" }, + { url = "https://files.pythonhosted.org/packages/81/9a/6cb91461b07c38b2db7918ee756f05fd704120b75ddc1a759e04af50351b/pyobjc_framework_coreaudiokit-12.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:dc1589cda7a4ae0560bf73e1a0623bb710de09ef030d585035f8a428a3e8d6a1", size = 7284, upload-time = "2025-11-14T09:43:57.109Z" }, + { url = "https://files.pythonhosted.org/packages/21/d8/1418fb222c6502ce2a99c415982895b510f6c48bdf60ca0dbed9897d96df/pyobjc_framework_coreaudiokit-12.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:6ec70b69d21925e02602cc22c5e0132daedc15ce65b7e3cc863fdb5f13cc23e3", size = 7446, upload-time = "2025-11-14T09:43:58.714Z" }, ] [[package]] name = "pyobjc-framework-corebluetooth" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-cocoa" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/52/df/bee7ba216f9fb513710aac1701b78c97b087b37fca8ec1806f8572e0bbb3/pyobjc_framework_corebluetooth-12.2.tar.gz", hash = "sha256:8b4e5ca99953c360c391a695b0782a5328fcecafd56fdf790ad709e932feb306", size = 37552, upload-time = "2026-05-30T12:35:33.863Z" } +sdist = { url = "https://files.pythonhosted.org/packages/4b/25/d21d6cb3fd249c2c2aa96ee54279f40876a0c93e7161b3304bf21cbd0bfe/pyobjc_framework_corebluetooth-12.1.tar.gz", hash = "sha256:8060c1466d90bbb9100741a1091bb79975d9ba43911c9841599879fc45c2bbe0", size = 33157, upload-time = "2025-11-14T10:13:28.064Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/25/eb/04f0ea541e6df3b7a328fe63ed1f508898d84910be66ae0f4d08103ad5a1/pyobjc_framework_corebluetooth-12.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:b43a21eb9388453c867ce82bf5d475cfce4fe2ceaea974474071f1cfd178f40f", size = 13205, upload-time = "2026-05-30T12:02:03.831Z" }, - { url = "https://files.pythonhosted.org/packages/cd/b7/502b1e5ff1feede7fbed1f28e1fd14604cf564e4a4f5d4f33c93a4706739/pyobjc_framework_corebluetooth-12.2-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:162623f74c85041bb8a2c9a8862cee6674531d603ad7a8d65a3efc81619f84c5", size = 13389, upload-time = "2026-05-30T12:02:05.647Z" }, + { url = "https://files.pythonhosted.org/packages/e0/6c/831139ebf6a811aed36abfdfad846bc380dcdf4e6fb751a310ce719ddcfd/pyobjc_framework_corebluetooth-12.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:5a894f695e6c672f0260327103a31ad8b98f8d4fb9516a0383db79a82a7e58dc", size = 13229, upload-time = "2025-11-14T09:44:10.463Z" }, + { url = "https://files.pythonhosted.org/packages/09/3c/3a6fe259a9e0745aa4612dee86b61b4fd7041c44b62642814e146b654463/pyobjc_framework_corebluetooth-12.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:1daf07a0047c3ed89fab84ad5f6769537306733b6a6e92e631581a0f419e3f32", size = 13409, upload-time = "2025-11-14T09:44:12.438Z" }, ] [[package]] name = "pyobjc-framework-coredata" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-cocoa" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/dc/67/e3eb3661c72ee1bd97eab9f6fc5121987f8f8f78f47d07418c1ef6f8fd1c/pyobjc_framework_coredata-12.2.tar.gz", hash = "sha256:1942049d656e264f47177c2fbd84314839bf55f61a825ae49f4fc7b0ebb078da", size = 143296, upload-time = "2026-05-30T12:35:43.03Z" } +sdist = { url = "https://files.pythonhosted.org/packages/3e/c5/8cd46cd4f1b7cf88bdeed3848f830ea9cdcc4e55cd0287a968a2838033fb/pyobjc_framework_coredata-12.1.tar.gz", hash = "sha256:1e47d3c5e51fdc87a90da62b97cae1bc49931a2bb064db1305827028e1fc0ffa", size = 124348, upload-time = "2025-11-14T10:13:36.435Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/26/44/0cec6323ea515dd5a8b5382f78e871f905aa295858716b53d4db8162d645/pyobjc_framework_coredata-12.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:36c1fa33a8221339983eef98c2bc9894813a51f650c30e92fbd3cd1e9f51921d", size = 16539, upload-time = "2026-05-30T12:02:21.888Z" }, - { url = "https://files.pythonhosted.org/packages/3d/a7/844e5e193cd8a5ac4620f40fb40d1d039282e17cdc19e1f50addf36e415a/pyobjc_framework_coredata-12.2-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:4ed76ef3c44a0f7f488ac445fe06878e90fedd55c6077841efbded1b125f33ea", size = 16694, upload-time = "2026-05-30T12:02:24.118Z" }, + { url = "https://files.pythonhosted.org/packages/f8/12/a22773c3a590d4923c74990d6714c4463bd1e183daaa67d6b00c9f325b33/pyobjc_framework_coredata-12.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:79f68577a7e96c57559ec844a129a5edce6827cdfafe49bf31524a488d715a37", size = 16420, upload-time = "2025-11-14T09:44:26.179Z" }, + { url = "https://files.pythonhosted.org/packages/a6/32/9595f0c8727d6ac312d18d23fc4a327c34c6ab873d2b760bbc40cf063726/pyobjc_framework_coredata-12.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:279b39bdb2a9c5e4d0377c1e81263b7d137bf2be37e15d6b5b2403598596f0e3", size = 16576, upload-time = "2025-11-14T09:44:28.266Z" }, ] [[package]] name = "pyobjc-framework-corehaptics" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-cocoa" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/38/c0/fa97c71176260bf0fb764809034e2ac4a6f3e47701d7526ff5844da8a1cf/pyobjc_framework_corehaptics-12.2.tar.gz", hash = "sha256:d55b39ea4d998dd50f980e8c1800df2558099b96a99f25813bed702ebc2bf43e", size = 24902, upload-time = "2026-05-30T12:35:45.559Z" } +sdist = { url = "https://files.pythonhosted.org/packages/3a/2f/74a3da79d9188b05dd4be4428a819ea6992d4dfaedf7d629027cf1f57bfc/pyobjc_framework_corehaptics-12.1.tar.gz", hash = "sha256:521dd2986c8a4266d583dd9ed9ae42053b11ae7d3aa89bf53fbee88307d8db10", size = 22164, upload-time = "2025-11-14T10:13:38.941Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/59/19/b4842ca6182d754360289384aa3b4adf3775a6c4ec30818c8b8c1c473792/pyobjc_framework_corehaptics-12.2-py2.py3-none-any.whl", hash = "sha256:c04c64212e7e7a0859b23b939a4375a349176317cb2b11553d388965d9a8fec8", size = 5413, upload-time = "2026-05-30T12:02:34.2Z" }, + { url = "https://files.pythonhosted.org/packages/25/f4/f469d6a9cac7c195f3d08fa65f94c32dd1dcf97a54b481be648fb3a7a5f3/pyobjc_framework_corehaptics-12.1-py2.py3-none-any.whl", hash = "sha256:a3b07d36ddf5c86a9cdaa411ab53d09553d26ea04fc7d4f82d21a84f0fc05fc0", size = 5382, upload-time = "2025-11-14T09:44:34.725Z" }, ] [[package]] name = "pyobjc-framework-corelocation" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-cocoa" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/b1/81/f074ac32e9af964ba873ac646ceac9d372057ff8d1db01d31e8f5586a1f6/pyobjc_framework_corelocation-12.2.tar.gz", hash = "sha256:1e0f389140707ece2bb4d08def421e25b792dcc2a34000dfb128dec2e685d725", size = 60306, upload-time = "2026-05-30T12:35:57.942Z" } +sdist = { url = "https://files.pythonhosted.org/packages/cc/79/b75885e0d75397dc2fe1ed9ca80be2b64c18b817f5fb924277cb1bf7b163/pyobjc_framework_corelocation-12.1.tar.gz", hash = "sha256:3674e9353f949d91dde6230ad68f6d5748a7f0424751e08a2c09d06050d66231", size = 53511, upload-time = "2025-11-14T10:13:43.384Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/eb/af/a8cf57caa11c1ce96bb19855ff02fd17a7e7f1d1ba3a890369be1f731f72/pyobjc_framework_corelocation-12.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:8b355dcc544a2ab525744b777431cb902c951fbbf2281350b86323eb64c4b409", size = 12843, upload-time = "2026-05-30T12:02:41.759Z" }, - { url = "https://files.pythonhosted.org/packages/11/f8/4d1aa9f9736efa013cb73022df9f58beca9639d922613be0f2be16e0c709/pyobjc_framework_corelocation-12.2-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:7515eda941b03c4e4f1e6d596383d4788997a05e30ce210ae250326ca418f240", size = 12969, upload-time = "2026-05-30T12:02:43.671Z" }, + { url = "https://files.pythonhosted.org/packages/9f/09/3da1947a5908d70461596eda5a0dc486ae807dc1c5a1ce2bf98567b474be/pyobjc_framework_corelocation-12.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:616eec0ccfcdcff7696bccf88c1aa39935387e595b22dd4c14842567aa0986a6", size = 12736, upload-time = "2025-11-14T09:44:42.977Z" }, + { url = "https://files.pythonhosted.org/packages/5d/9a/e5e11ec90500ce2c809a46113d3ebd70dd4b4ce450072db9a85f86e9a30f/pyobjc_framework_corelocation-12.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:0a80ba8e8d9120eb80486235c483a0c734cb451265e5aa81bcf315f0e644eb00", size = 12867, upload-time = "2025-11-14T09:44:44.89Z" }, ] [[package]] name = "pyobjc-framework-coremedia" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-cocoa" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/6e/63/9b25f9abb14e8faee219e72953c3cc4bed48b0de4b86f767f073fd2fdc35/pyobjc_framework_coremedia-12.2.tar.gz", hash = "sha256:95ed2063cc48d73f6eb06f4e603372515b5b009bd2d6e547f90bbe9e64217206", size = 98236, upload-time = "2026-05-30T12:36:10.943Z" } +sdist = { url = "https://files.pythonhosted.org/packages/da/7d/5ad600ff7aedfef8ba8f51b11d9aaacdf247b870bd14045d6e6f232e3df9/pyobjc_framework_coremedia-12.1.tar.gz", hash = "sha256:166c66a9c01e7a70103f3ca44c571431d124b9070612ef63a1511a4e6d9d84a7", size = 89566, upload-time = "2025-11-14T10:13:49.788Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/d5/00/412b4b98b6c6b266a73be2862453d98a6f7f95e911c216ad2117831d2b18/pyobjc_framework_coremedia-12.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:e992147e7b0c8c435f1bb786c8c610511453cf54bdf6c6b4a17e05936bacc44b", size = 29412, upload-time = "2026-05-30T12:03:02.254Z" }, - { url = "https://files.pythonhosted.org/packages/2e/61/e3285f4b7a889a334ba06c6daef78f32e39de40ca7b061443e39e0faf42a/pyobjc_framework_coremedia-12.2-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:d9586fb8ae22ab1a500e812e5c16dde09b3ea75613a8b5ed61d17cd9ba75c809", size = 29472, upload-time = "2026-05-30T12:03:04.911Z" }, + { url = "https://files.pythonhosted.org/packages/a5/ea/aee26a475b4af8ed4152d3c50b1b8955241b8e95ae789aa9ee296953bc6a/pyobjc_framework_coremedia-12.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:98e885b7a092083fceaef0a7fc406a01ba7bcd3318fb927e59e055931c99cac8", size = 29414, upload-time = "2025-11-14T09:45:01.336Z" }, + { url = "https://files.pythonhosted.org/packages/db/9d/5ff10ee0ff539e125c96b8cff005457558766f942919814c968c3367cc32/pyobjc_framework_coremedia-12.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:d2b84149c1b3e65ec9050a3e5b617e6c0b4cdad2ab622c2d8c5747a20f013e16", size = 29477, upload-time = "2025-11-14T09:45:04.218Z" }, ] [[package]] name = "pyobjc-framework-coremediaio" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-cocoa" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/40/24/7c8b41310cb874bd308c875252ec6872198f19f3be27aacdafcd98a4b27e/pyobjc_framework_coremediaio-12.2.tar.gz", hash = "sha256:38f656ebe897262463277d4551fc6cca4ac766629476576f040b34e84c956506", size = 56592, upload-time = "2026-05-30T12:36:15.218Z" } +sdist = { url = "https://files.pythonhosted.org/packages/08/8e/23baee53ccd6c011c965cff62eb55638b4088c3df27d2bf05004105d6190/pyobjc_framework_coremediaio-12.1.tar.gz", hash = "sha256:880b313b28f00b27775d630174d09e0b53d1cdbadb74216618c9dd5b3eb6806a", size = 51100, upload-time = "2025-11-14T10:13:54.277Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/bd/4b/65ed6a4af11af67ee64b5fafbf12ef2d56dd38020e88d9b67aed2128703c/pyobjc_framework_coremediaio-12.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:95cfaa7b8a0c970cfacdc620991345a3b55ba641a8091a1467a94310fc11b279", size = 17306, upload-time = "2026-05-30T12:03:24.356Z" }, - { url = "https://files.pythonhosted.org/packages/51/6a/4b04551647534735d788919a8a62b5261b249654b6e427f27d12f7e5377f/pyobjc_framework_coremediaio-12.2-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:f03e5f735b99508706f9ccf5233eaae4c53399459b6c87670112dcf1c0cd791c", size = 17627, upload-time = "2026-05-30T12:03:26.42Z" }, + { url = "https://files.pythonhosted.org/packages/6d/d1/0267ec27841ee96458e6b669ce5b0c67d040ef3d5de90fa4e945ff989c48/pyobjc_framework_coremediaio-12.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:85ae768294ec307d5b502c075aeae1c53a731afc2f7f0307c9bef785775e26a6", size = 17249, upload-time = "2025-11-14T09:45:20.42Z" }, + { url = "https://files.pythonhosted.org/packages/ca/4e/bd0114aa052aaffc250b0c00567b42df8c7cb35517488c3238bcc964d016/pyobjc_framework_coremediaio-12.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:6136a600a1435b9e798427984088a7bd5e68778e1bcf48a23a0eb9bc946a06f0", size = 17573, upload-time = "2025-11-14T09:45:22.572Z" }, ] [[package]] name = "pyobjc-framework-coremidi" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-cocoa" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/a9/ca/ccc156899161481cc2c22529645d590a6f570c0583567ab6ba4a0df71bbf/pyobjc_framework_coremidi-12.2.tar.gz", hash = "sha256:a00e1d906f1a1fca302c867406ed8e1e23651b1551ce1943e9495e7665b6b0d3", size = 63475, upload-time = "2026-05-30T12:36:19.463Z" } +sdist = { url = "https://files.pythonhosted.org/packages/75/96/2d583060a71a73c8a7e6d92f2a02675621b63c1f489f2639e020fae34792/pyobjc_framework_coremidi-12.1.tar.gz", hash = "sha256:3c6f1fd03997c3b0f20ab8545126b1ce5f0cddcc1587dffacad876c161da8c54", size = 55587, upload-time = "2025-11-14T10:13:58.903Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/8f/a5/b87175347becf46c8ade3593da8fc660d46a5fbf2794f5d7fcb0ca4694b6/pyobjc_framework_coremidi-12.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:86c7114af6e06650a84eeb781b90bfb3569304f36a40e38eb2e6113e72385444", size = 24584, upload-time = "2026-05-30T12:03:44.625Z" }, - { url = "https://files.pythonhosted.org/packages/fb/d8/2953bc296baaed3a4207131d9b90797b6a12ebee204c92addc14b6c7ac8b/pyobjc_framework_coremidi-12.2-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:ae8c2e5113fe8a4afa4ce9c5231a5bf8a2c25dccc909b80d0fdd9ca0996e6d1d", size = 24734, upload-time = "2026-05-30T12:03:47.053Z" }, + { url = "https://files.pythonhosted.org/packages/a9/2a/093ec8366d5f9e6c45e750310121ea572b8696518c51c4bbcf1623c01cf1/pyobjc_framework_coremidi-12.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:69720f38cfeea4299f31cb3e15d07e5d43e55127605f95e001794c7850c1c637", size = 24333, upload-time = "2025-11-14T09:45:37.577Z" }, + { url = "https://files.pythonhosted.org/packages/0e/cf/f03a0b44d1cfcfa9837cdfd6385c1e7d1e42301076d376329a44b6cbec03/pyobjc_framework_coremidi-12.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:06e5bce0a28bac21f09bcfedda46d93b2152c138764380314d99f2370a8c00f2", size = 24493, upload-time = "2025-11-14T09:45:40.591Z" }, ] [[package]] name = "pyobjc-framework-coreml" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-cocoa" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/e5/a5/ee39e19017348fcba998de71f4f425abf0563b693fcf5bf7f4b84232d538/pyobjc_framework_coreml-12.2.tar.gz", hash = "sha256:884f1f68c7a74c56d26858051da8a1e19848be97f2c4b06b32ae93e505109583", size = 49266, upload-time = "2026-05-30T12:36:23.498Z" } +sdist = { url = "https://files.pythonhosted.org/packages/30/2d/baa9ea02cbb1c200683cb7273b69b4bee5070e86f2060b77e6a27c2a9d7e/pyobjc_framework_coreml-12.1.tar.gz", hash = "sha256:0d1a4216891a18775c9e0170d908714c18e4f53f9dc79fb0f5263b2aa81609ba", size = 40465, upload-time = "2025-11-14T10:14:02.265Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/b3/42/93b24114d5334d7a1a5031788947f14f487c0aec4529ccfd7f78611c69b9/pyobjc_framework_coreml-12.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:64b66797b9cc1b20d726476f78ee2e69540fad60676d5dbb120530fbd429d3c7", size = 11966, upload-time = "2026-05-30T12:04:04.368Z" }, - { url = "https://files.pythonhosted.org/packages/08/da/ccec3d91d7a740156d720056002befda423f3960691e4290460910d352e3/pyobjc_framework_coreml-12.2-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:774a28259888c1bc247e8ed5ad14d7fc8baa975591c89669cd952e1756cd7d48", size = 12188, upload-time = "2026-05-30T12:04:06.09Z" }, + { url = "https://files.pythonhosted.org/packages/ae/3f/3749964aa3583f8c30d9996f0d15541120b78d307bb3070f5e47154ef38d/pyobjc_framework_coreml-12.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:48fa3bb4a03fa23e0e36c93936dca2969598e4102f4b441e1663f535fc99cd31", size = 11371, upload-time = "2025-11-14T09:45:54.105Z" }, + { url = "https://files.pythonhosted.org/packages/9c/c8/cf20ea91ae33f05f3b92dec648c6f44a65f86d1a64c1d6375c95b85ccb7c/pyobjc_framework_coreml-12.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:71de5b37e6a017e3ed16645c5d6533138f24708da5b56c35c818ae49d0253ee1", size = 11600, upload-time = "2025-11-14T09:45:55.976Z" }, ] [[package]] name = "pyobjc-framework-coremotion" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-cocoa" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/9d/38/90010239d5d6721d8670cbb0edb71c39a1abca0cf22cecbeba7cbd490de5/pyobjc_framework_coremotion-12.2.tar.gz", hash = "sha256:8a2a06809b78a72cad52f27aa830c883e19ca36b57f8418ccfaf29773c5dc5ac", size = 38055, upload-time = "2026-05-30T12:36:26.711Z" } +sdist = { url = "https://files.pythonhosted.org/packages/2c/eb/abef7d405670cf9c844befc2330a46ee59f6ff7bac6f199bf249561a2ca6/pyobjc_framework_coremotion-12.1.tar.gz", hash = "sha256:8e1b094d34084cc8cf07bedc0630b4ee7f32b0215011f79c9e3cd09d205a27c7", size = 33851, upload-time = "2025-11-14T10:14:05.619Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/c7/62/606ca7aa90686f1eeb48d9870409bb1132ade70afc185816f12f0bce8f30/pyobjc_framework_coremotion-12.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:554bd583a6c36c659e83102832b65e6829c9f4c5d7dfe30f76e4fc62ab2ae13a", size = 10449, upload-time = "2026-05-30T12:04:19.591Z" }, - { url = "https://files.pythonhosted.org/packages/f6/7b/b5a942442e0b716319c442dd7a8cc2232b682509034c832898bbb7ba3783/pyobjc_framework_coremotion-12.2-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:657fc69c6446878c0a6b5cc53f689f110a8c4bbf0d57ae87f1d19ebf7bfc2889", size = 10597, upload-time = "2026-05-30T12:04:21.265Z" }, + { url = "https://files.pythonhosted.org/packages/4d/dd/9a4cc56c55f7ffece2e100664503cb27b4f4265d57656d050a3af1c71d94/pyobjc_framework_coremotion-12.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:b7b0d47b5889ca0b6e3a687bd1f83a13d3bb59c07a1c4c37dcca380ede5d6e81", size = 10423, upload-time = "2025-11-14T09:46:07.051Z" }, + { url = "https://files.pythonhosted.org/packages/0d/4d/660b47e9e0bc10ae87f85bede39e3f922b8382e0f6ac273058183d0bdc2f/pyobjc_framework_coremotion-12.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:531ea82945266d78e23d1f35de0cae2391e18677ed54120b90a4b9dd19f32596", size = 10570, upload-time = "2025-11-14T09:46:09.047Z" }, ] [[package]] name = "pyobjc-framework-coreservices" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-cocoa" }, { name = "pyobjc-framework-fsevents" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/a2/3f/92b7df81848039fa9b3eaa0181d9969f42dd8a208e8ba8b8d4a648c2cd46/pyobjc_framework_coreservices-12.2.tar.gz", hash = "sha256:ea52c77e9a162b6823c3b364f391b4369d967365e5207a0d45cf6d0e37cec0e6", size = 399867, upload-time = "2026-05-30T12:36:50.614Z" } +sdist = { url = "https://files.pythonhosted.org/packages/4c/b3/52338a3ff41713f7d7bccaf63bef4ba4a8f2ce0c7eaff39a3629d022a79a/pyobjc_framework_coreservices-12.1.tar.gz", hash = "sha256:fc6a9f18fc6da64c166fe95f2defeb7ac8a9836b3b03bb6a891d36035260dbaa", size = 366150, upload-time = "2025-11-14T10:14:28.133Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/8e/ae/ca8c1386df09bcd7175f5fa8c37cf09f458b72549843e5454b2562db7194/pyobjc_framework_coreservices-12.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:c07effb4e1bff841eec4304b759fe3ef73301a7b2ae3e5e3e203efe6c45e2bde", size = 30332, upload-time = "2026-05-30T12:04:39.951Z" }, - { url = "https://files.pythonhosted.org/packages/58/5a/1413029dd792fec9e9c27c18c6a48fccaad3ec675698fc2db6eb46d5e51b/pyobjc_framework_coreservices-12.2-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:fb713264a7151a92bb11e6125da06af343037b96f6f8021e7cc8f8ff42897744", size = 30342, upload-time = "2026-05-30T12:04:42.727Z" }, + { url = "https://files.pythonhosted.org/packages/a7/6f/4a6eb2f2bbdbf66a1b35f272d8504ce6f098947f9343df474f0d15a2b507/pyobjc_framework_coreservices-12.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:96574fb24d2b8b507901ef7be7fcb70b7f49e110bd050a411b90874cc18c7c7b", size = 30226, upload-time = "2025-11-14T09:46:25.565Z" }, + { url = "https://files.pythonhosted.org/packages/60/6e/78a831834dc7f84a2d61efb47d212239f3ae3d16aa5512f1265a8f6c0162/pyobjc_framework_coreservices-12.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:227fb4144a87c6c97a5f737fb0c666293b33e54f0ffb500f2c420da6c110ba2d", size = 30229, upload-time = "2025-11-14T09:46:28.51Z" }, ] [[package]] name = "pyobjc-framework-corespotlight" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-cocoa" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/e2/c7/ea47b22b51e9e0bc69dc4f70bf19d18c9282df5d1c11343138ee01f7022f/pyobjc_framework_corespotlight-12.2.tar.gz", hash = "sha256:6aefcef43d3d3bf3e7cbcffca053a7dad07c434aa11b117dbb39d5cf596ee829", size = 45678, upload-time = "2026-05-30T12:36:54.364Z" } +sdist = { url = "https://files.pythonhosted.org/packages/99/d0/88ca73b0cf23847af463334989dd8f98e44f801b811e7e1d8a5627ec20b4/pyobjc_framework_corespotlight-12.1.tar.gz", hash = "sha256:57add47380cd0bbb9793f50a4a4b435a90d4ebd2a33698e058cb353ddfb0d068", size = 38002, upload-time = "2025-11-14T10:14:31.948Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/7c/bf/79508c58d3f68ce8a564146dfa29ae661d9970f64f2f8615b6cba0b866a8/pyobjc_framework_corespotlight-12.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:d35028c872a89c0450e067c021d64b29c013fe980617aa16e9d9778f566e167b", size = 10019, upload-time = "2026-05-30T12:05:01.117Z" }, - { url = "https://files.pythonhosted.org/packages/94/46/15463f342139c8c9d95efa0aa434494c3782472fad1ae6e0436f624eb34b/pyobjc_framework_corespotlight-12.2-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:c0d6b74f497e835f9de97aeacdab7a2c9a1544135dee1c9665b2074de44424a4", size = 10162, upload-time = "2026-05-30T12:05:02.737Z" }, + { url = "https://files.pythonhosted.org/packages/7b/ed/419ae27bdd17701404301ede1969daadeef6ef6dd8b4a8110a90a1d77df1/pyobjc_framework_corespotlight-12.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:37003bfea415ff21859d44403c3a13ac55f90b6dca92c69b81b61d96cee0c7be", size = 10012, upload-time = "2025-11-14T09:46:48.826Z" }, + { url = "https://files.pythonhosted.org/packages/a8/84/ebe1acb365958604465f83710772c1a08854f472896e607f7eedb5944e1b/pyobjc_framework_corespotlight-12.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:ede26027cfa577e6748b7dd0615e8a1bb379e48ad2324489b2c8d242cdf6fce8", size = 10152, upload-time = "2025-11-14T09:46:51.025Z" }, ] [[package]] name = "pyobjc-framework-coretext" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-cocoa" }, { name = "pyobjc-framework-quartz" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/1f/b0/e7ef99240f853d4dddde82c9c0114cc525de7355661b2bf2d5e04cfb1582/pyobjc_framework_coretext-12.2.tar.gz", hash = "sha256:82def2c281347e0677866315675124c84c36e9bc21651d62870cfdcecb7da34e", size = 97343, upload-time = "2026-05-30T12:37:00.996Z" } +sdist = { url = "https://files.pythonhosted.org/packages/29/da/682c9c92a39f713bd3c56e7375fa8f1b10ad558ecb075258ab6f1cdd4a6d/pyobjc_framework_coretext-12.1.tar.gz", hash = "sha256:e0adb717738fae395dc645c9e8a10bb5f6a4277e73cba8fa2a57f3b518e71da5", size = 90124, upload-time = "2025-11-14T10:14:38.596Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/cc/db/783ae8290da2edb57b479fc474c7d66a319f4fd5f1f32dd642af1fd962ec/pyobjc_framework_coretext-12.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:09daa6b6befea7c0d673a037d02ed13bb4443ed65d8948329ba6c8a08e06c763", size = 30087, upload-time = "2026-05-30T12:05:20.422Z" }, - { url = "https://files.pythonhosted.org/packages/0c/58/6d0a37fed6eee8ed4c950f71cc98355e8ce8d3a38c19aba1bf7ff6ac5441/pyobjc_framework_coretext-12.2-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:867e6f56c1c7703f27a7328d42d37cd184151657a3026cf46c0de207cc90a46c", size = 30635, upload-time = "2026-05-30T12:05:23.59Z" }, + { url = "https://files.pythonhosted.org/packages/20/a2/a3974e3e807c68e23a9d7db66fc38ac54f7ecd2b7a9237042006699a76e1/pyobjc_framework_coretext-12.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:7cbb2c28580e6704ce10b9a991ccd9563a22b3a75f67c36cf612544bd8b21b5f", size = 30110, upload-time = "2025-11-14T09:47:07.518Z" }, + { url = "https://files.pythonhosted.org/packages/0f/5d/85e059349e9cfbd57269a1f11f56747b3ff5799a3bcbd95485f363c623d8/pyobjc_framework_coretext-12.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:14100d1e39efb30f57869671fb6fce8d668f80c82e25e7930fb364866e5c0dab", size = 30697, upload-time = "2025-11-14T09:47:10.932Z" }, ] [[package]] name = "pyobjc-framework-corewlan" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-cocoa" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/de/82/0393b32be2551bbaf09211eff01f92c60f9c3f964d6ace23f14847d88550/pyobjc_framework_corewlan-12.2.tar.gz", hash = "sha256:e0d81a95f6923c3dea9b0ab34fb0b028f5838930a602b5aa4bf9546eb268be9d", size = 35525, upload-time = "2026-05-30T12:37:04.208Z" } +sdist = { url = "https://files.pythonhosted.org/packages/88/71/739a5d023566b506b3fd3d2412983faa95a8c16226c0dcd0f67a9294a342/pyobjc_framework_corewlan-12.1.tar.gz", hash = "sha256:a9d82ec71ef61f37e1d611caf51a4203f3dbd8caf827e98128a1afaa0fd2feb5", size = 32417, upload-time = "2025-11-14T10:14:41.921Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/d5/31/95f9eea9b71b724a239ca7445f666ec29cef9df7cc9ae3cfa77e1b9c875b/pyobjc_framework_corewlan-12.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:6b922017499d6921a760bf3d359b1705ef31b87a2c4cfe763452759f9dc5a91c", size = 10001, upload-time = "2026-05-30T12:05:41.401Z" }, - { url = "https://files.pythonhosted.org/packages/0a/07/461ecada55a3d164f095e6e103d1bf9011e00334d2e7ce973048a0050512/pyobjc_framework_corewlan-12.2-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:3435e7c086ae69522354ec4fb74bcb3bbaefbc4b895680dffe6fef634430d533", size = 10154, upload-time = "2026-05-30T12:05:42.982Z" }, + { url = "https://files.pythonhosted.org/packages/c0/a4/b691e4d1730c16f8ea2f883712054961a3e45f40e1471c0edfc30f061c07/pyobjc_framework_corewlan-12.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:aac949646953effdd36d2d21bc0ab645e58bb25deafe86c6e600b3cdcfc2228b", size = 9968, upload-time = "2025-11-14T09:47:24.454Z" }, + { url = "https://files.pythonhosted.org/packages/88/2e/dbba1674e1629839f479c9d14b90c37ed3b5f76d3b6b3ad56af48951c45b/pyobjc_framework_corewlan-12.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:dae63c36affcc933c9161980e4fe7333e0c59c968174a00a75cb5f6e4ede10c6", size = 10115, upload-time = "2025-11-14T09:47:26.152Z" }, ] [[package]] name = "pyobjc-framework-cryptotokenkit" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-cocoa" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/7e/73/f77f0dca70fee8a1999700dc878eea1e558d7d2e5088d3bce59e425f23e5/pyobjc_framework_cryptotokenkit-12.2.tar.gz", hash = "sha256:bf070e95f82db3bf8dcb0d67d459df3810bd9dfec63a31982adefba146d9e777", size = 38281, upload-time = "2026-05-30T12:37:07.321Z" } +sdist = { url = "https://files.pythonhosted.org/packages/6b/7c/d03ff4f74054578577296f33bc669fce16c7827eb1a553bb372b5aab30ca/pyobjc_framework_cryptotokenkit-12.1.tar.gz", hash = "sha256:c95116b4b7a41bf5b54aff823a4ef6f4d9da4d0441996d6d2c115026a42d82f5", size = 32716, upload-time = "2025-11-14T10:14:45.024Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/c5/ad/deaada5bb4b9f1463d3cc8b2be809818a911edf3f6618053cf6ae5307e09/pyobjc_framework_cryptotokenkit-12.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:240f79011ed7750a441f9d07e971ae262551bae3e6a455f7dc2dc8641fbde6c7", size = 12713, upload-time = "2026-05-30T12:05:57.068Z" }, - { url = "https://files.pythonhosted.org/packages/6a/c4/36dff9b7c73eccedc57ec8bf60948b9410a95eb27d7e94bfd4bd89586ba5/pyobjc_framework_cryptotokenkit-12.2-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:eeaa4be6eb2cc48a73a2444d5db1ad9f7c383e23d15efab12272cc66c3fc11c3", size = 12898, upload-time = "2026-05-30T12:05:58.89Z" }, + { url = "https://files.pythonhosted.org/packages/15/8d/3e24abc92a8ee8ee11386d4d9dfb2d6961d10814474053a8ebccfaff0d97/pyobjc_framework_cryptotokenkit-12.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:e65a8e4558e6cf1e46a9b4a52fcbf7b2ddd17958d675e9047d8a9f131d0a4d33", size = 12650, upload-time = "2025-11-14T09:47:37.633Z" }, + { url = "https://files.pythonhosted.org/packages/e9/eb/418afc27429922e73a05bd22198c71e1f6b3badebd73cad208eb9e922f64/pyobjc_framework_cryptotokenkit-12.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:cc9aa75e418376e92b1540d1edfa0c8097a027a1a241717983d0223cdad8e9ca", size = 12834, upload-time = "2025-11-14T09:47:40.27Z" }, ] [[package]] name = "pyobjc-framework-datadetection" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-cocoa" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/22/fa/eb20c36de2d038e2c65629b600dc0642727ae68e96f3bc9a692cf0b7184f/pyobjc_framework_datadetection-12.2.tar.gz", hash = "sha256:5fe732751662f119c8435c608785e86edff1b2ee394fbb9f010b5613bb6703d2", size = 12676, upload-time = "2026-05-30T12:37:09.09Z" } +sdist = { url = "https://files.pythonhosted.org/packages/db/97/9b03832695ec4d3008e6150ddfdc581b0fda559d9709a98b62815581259a/pyobjc_framework_datadetection-12.1.tar.gz", hash = "sha256:95539e46d3bc970ce890aa4a97515db10b2690597c5dd362996794572e5d5de0", size = 12323, upload-time = "2025-11-14T10:14:46.769Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/e0/8c/080a4c6ecffe45a64db10912ecc8c777f4368f4c5ad859a584a73e7243e9/pyobjc_framework_datadetection-12.2-py2.py3-none-any.whl", hash = "sha256:23246bea4dce73c702e176ed2be1ba26afc48a627c713a91417716c3d5915ec0", size = 3522, upload-time = "2026-05-30T12:06:08.013Z" }, + { url = "https://files.pythonhosted.org/packages/70/1c/5d2f941501e84da8fef8ef3fd378b5c083f063f083f97dd3e8a07f0404b3/pyobjc_framework_datadetection-12.1-py2.py3-none-any.whl", hash = "sha256:4dc8e1d386d655b44b2681a4a2341fb2fc9addbf3dda14cb1553cd22be6a5387", size = 3497, upload-time = "2025-11-14T09:47:45.826Z" }, ] [[package]] name = "pyobjc-framework-devicecheck" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-cocoa" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/6e/ed/0c173fbee96920addd4f2d9ad0e69dfc22b8080c16f52f6d75acd459692c/pyobjc_framework_devicecheck-12.2.tar.gz", hash = "sha256:2750bdfc7fa11e02c88fc8d681dcf202ce2f52c4eaafc55f0afa38df1bc66369", size = 13324, upload-time = "2026-05-30T12:37:10.846Z" } +sdist = { url = "https://files.pythonhosted.org/packages/cd/af/c676107c40d51f55d0a42043865d7246db821d01241b518ea1d3b3ef1394/pyobjc_framework_devicecheck-12.1.tar.gz", hash = "sha256:567e85fc1f567b3fe64ac1cdc323d989509331f64ee54fbcbde2001aec5adbdb", size = 12885, upload-time = "2025-11-14T10:14:48.804Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/54/58/8dbb51f3f462ce1d1a880f8fafc47980f56e0ad1b7472e2a500c81d6332f/pyobjc_framework_devicecheck-12.2-py2.py3-none-any.whl", hash = "sha256:77bbc267426dbdf80799d9a63ed17545c2c8332e765da8f5ce34f40be78e7776", size = 3684, upload-time = "2026-05-30T12:06:09.443Z" }, + { url = "https://files.pythonhosted.org/packages/c5/d8/1f1b13fa4775b6474c9ad0f4b823953eaeb6c11bd6f03fa8479429b36577/pyobjc_framework_devicecheck-12.1-py2.py3-none-any.whl", hash = "sha256:ffd58148bdef4a1ee8548b243861b7d97a686e73808ca0efac5bef3c430e4a15", size = 3684, upload-time = "2025-11-14T09:47:47.25Z" }, ] [[package]] name = "pyobjc-framework-devicediscoveryextension" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-cocoa" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/33/aa/848457f81670d784c3a0b35887f7d16fd76bad805ec06be21f9c15012b9a/pyobjc_framework_devicediscoveryextension-12.2.tar.gz", hash = "sha256:2f3f21f9f2c0e0f714bd38076d7082c923650ce180a15aab77f271575b4eef04", size = 15744, upload-time = "2026-05-30T12:37:12.525Z" } +sdist = { url = "https://files.pythonhosted.org/packages/91/b0/e6e2ed6a7f4b689746818000a003ff7ab9c10945df66398ae8d323ae9579/pyobjc_framework_devicediscoveryextension-12.1.tar.gz", hash = "sha256:60e12445fad97ff1f83472255c943685a8f3a9d95b3126d887cfe769b7261044", size = 14718, upload-time = "2025-11-14T10:14:50.723Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/97/9a/eee0a7ed475068d2bc24f2fe6a8243da384a3d5c742f6b0c436322e0b592/pyobjc_framework_devicediscoveryextension-12.2-py2.py3-none-any.whl", hash = "sha256:d0f2187013cefb9dc3ff20abd8dd0260a257a6bd6cd661b4d5a364c877ee4ac7", size = 4322, upload-time = "2026-05-30T12:06:10.939Z" }, + { url = "https://files.pythonhosted.org/packages/7e/0c/005fe8db1e19135f493a3de8c8d38031e1ad2d626de4ef89f282acf4aff7/pyobjc_framework_devicediscoveryextension-12.1-py2.py3-none-any.whl", hash = "sha256:d6d6b606d27d4d88efc0bed4727c375e749149b360290c3ad2afc52337739a1b", size = 4321, upload-time = "2025-11-14T09:47:48.78Z" }, ] [[package]] name = "pyobjc-framework-dictionaryservices" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-coreservices" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/f0/f1/07b79048947dcd0ed0aa2582591a17990252a5649be725c094662ef9fbe5/pyobjc_framework_dictionaryservices-12.2.tar.gz", hash = "sha256:51e826c92fc04a0aa531bd04f092ca1edb6c470bce3f04c4eff84fbedb61d929", size = 10693, upload-time = "2026-05-30T12:37:14.263Z" } +sdist = { url = "https://files.pythonhosted.org/packages/7a/c0/daf03cdaf6d4e04e0cf164db358378c07facd21e4e3f8622505d72573e2c/pyobjc_framework_dictionaryservices-12.1.tar.gz", hash = "sha256:354158f3c55d66681fa903c7b3cb05a435b717fa78d0cef44d258d61156454a7", size = 10573, upload-time = "2025-11-14T10:14:53.961Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/3e/af/2b7cb4c630a0f9f0588a53a290d96898bb1fc8dcb2abf311c20e250d4924/pyobjc_framework_dictionaryservices-12.2-py2.py3-none-any.whl", hash = "sha256:9257ed93dad0b4bcf82c871bc587f994d7619e5916df3662cc2510fe8f85ed5c", size = 3931, upload-time = "2026-05-30T12:06:12.609Z" }, + { url = "https://files.pythonhosted.org/packages/e7/13/ab308e934146cfd54691ddad87e572cd1edb6659d795903c4c75904e2d7d/pyobjc_framework_dictionaryservices-12.1-py2.py3-none-any.whl", hash = "sha256:578854eec17fa473ac17ab30050a7bbb2ab69f17c5c49b673695254c3e88ad4b", size = 3930, upload-time = "2025-11-14T09:47:50.782Z" }, ] [[package]] name = "pyobjc-framework-discrecording" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-cocoa" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/ea/ae/ea8b74b528cb281555bea842abbaeed99db66e8270d9eec37a3b2f5a9bfa/pyobjc_framework_discrecording-12.2.tar.gz", hash = "sha256:0b1df1d250b892d1b48e1ce87c9c89e944c28a4bb708d43848f12ff2d69cc396", size = 61967, upload-time = "2026-05-30T12:37:18.532Z" } +sdist = { url = "https://files.pythonhosted.org/packages/c4/87/8bd4544793bfcdf507174abddd02b1f077b48fab0004b3db9a63142ce7e9/pyobjc_framework_discrecording-12.1.tar.gz", hash = "sha256:6defc8ea97fb33b4d43870c673710c04c3dc48be30cdf78ba28191a922094990", size = 55607, upload-time = "2025-11-14T10:14:58.276Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/85/18/da0b7c2bf4d4cc9f6a3863ef635d72206cd6c3959ac27471db0c6b5969d8/pyobjc_framework_discrecording-12.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:23e4012a55a51e5af9d5a9526697efc1a0d55a1234541c58a27b464c2fdd4e2e", size = 14567, upload-time = "2026-05-30T12:06:20.632Z" }, - { url = "https://files.pythonhosted.org/packages/2c/24/e9abce96b6f19979e9701dd1dada13ac0e344425e144ee2e684ae5e62bcd/pyobjc_framework_discrecording-12.2-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:067095747927b85baf7395d16c033be15db14a61c3fa8f6d2d6ce1b06ab36517", size = 14743, upload-time = "2026-05-30T12:06:22.564Z" }, + { url = "https://files.pythonhosted.org/packages/aa/29/0064a48b24694597890cb065f5d33f719eed2cfff2878f43f310f27485cc/pyobjc_framework_discrecording-12.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:8c682c458622db9b4ea8363335ee38f5dd98db6691680041a3fda73e26714346", size = 14567, upload-time = "2025-11-14T09:47:59.78Z" }, + { url = "https://files.pythonhosted.org/packages/de/78/b8b3f063ecda49d600548eeee0c29b47a0b7635623a68609038326bfa7e7/pyobjc_framework_discrecording-12.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:36e1ba4d37fe310bad2fbfeadd43c8ef001cfae9a2a0484d7318504c5dbefa3f", size = 14745, upload-time = "2025-11-14T09:48:02.271Z" }, ] [[package]] name = "pyobjc-framework-discrecordingui" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-cocoa" }, { name = "pyobjc-framework-discrecording" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/ad/a6/3f94dfd9508f98aa5d152f8e56dbcdd8a0ddf2bbb9f7e180a5561772a839/pyobjc_framework_discrecordingui-12.2.tar.gz", hash = "sha256:932175c1c2df93673ffd87e4d5270bd03591548e26e39664d813b5e1b0c0a47b", size = 19543, upload-time = "2026-05-30T12:37:20.559Z" } +sdist = { url = "https://files.pythonhosted.org/packages/30/63/8667f5bb1ecb556add04e86b278cb358dc1f2f03862705cae6f09097464c/pyobjc_framework_discrecordingui-12.1.tar.gz", hash = "sha256:6793d4a1a7f3219d063f39d87f1d4ebbbb3347e35d09194a193cfe16cba718a8", size = 16450, upload-time = "2025-11-14T10:15:00.254Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/5f/bc/3d75efba436c907629af9f17414f10bf105581e6e6803d20d0ab097a4b44/pyobjc_framework_discrecordingui-12.2-py2.py3-none-any.whl", hash = "sha256:4ae5d1ec84ff47cf041973c112024f7b3b7c6eb0d5cbd3cecc393998efa0f654", size = 4701, upload-time = "2026-05-30T12:06:31.841Z" }, + { url = "https://files.pythonhosted.org/packages/f2/4e/76016130c27b98943c5758a05beab3ba1bc9349ee881e1dfc509ea954233/pyobjc_framework_discrecordingui-12.1-py2.py3-none-any.whl", hash = "sha256:6544ef99cad3dee95716c83cb207088768b6ecd3de178f7e1b17df5997689dfd", size = 4702, upload-time = "2025-11-14T09:48:08.01Z" }, ] [[package]] name = "pyobjc-framework-diskarbitration" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-cocoa" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/4e/f8/aff13f6577bae073682c7e413ce725e51a11e2262c82956b5664621caadf/pyobjc_framework_diskarbitration-12.2.tar.gz", hash = "sha256:b5ce6750cec175066ed6dc6ccc9548201642f246130c1a82d01690747028505d", size = 18162, upload-time = "2026-05-30T12:37:22.608Z" } +sdist = { url = "https://files.pythonhosted.org/packages/3a/42/f75fcabec1a0033e4c5235cc8225773f610321d565b63bf982c10c6bbee4/pyobjc_framework_diskarbitration-12.1.tar.gz", hash = "sha256:6703bc5a09b38a720c9ffca356b58f7e99fa76fc988c9ec4d87112344e63dfc2", size = 17121, upload-time = "2025-11-14T10:15:02.223Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/51/c1/93db22bbc25358cf523e7a66a76de6fdfff4719ce60e86a87d368587520d/pyobjc_framework_diskarbitration-12.2-py2.py3-none-any.whl", hash = "sha256:9952012b50f8d87849ca74c56a8b6fcd9373e8b5aa4566f628165cd4a2458a25", size = 4889, upload-time = "2026-05-30T12:06:33.405Z" }, + { url = "https://files.pythonhosted.org/packages/48/65/c1f54c47af17cb6b923eab85e95f22396c52f90ee8f5b387acffad9a99ea/pyobjc_framework_diskarbitration-12.1-py2.py3-none-any.whl", hash = "sha256:54caf3079fe4ae5ac14466a9b68923ee260a1a88a8290686b4a2015ba14c2db6", size = 4877, upload-time = "2025-11-14T09:48:09.945Z" }, ] [[package]] name = "pyobjc-framework-dvdplayback" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-cocoa" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/64/87/6a2aa2a54df1b18f9543a2c64baa290be6e59d98b31b46559ea47b49b5d9/pyobjc_framework_dvdplayback-12.2.tar.gz", hash = "sha256:2f504e578a809ae8544e50d9958bc2101fbb0a35921f370c810b575b70d8096e", size = 34810, upload-time = "2026-05-30T12:37:25.641Z" } +sdist = { url = "https://files.pythonhosted.org/packages/cf/dd/7859a58e8dd336c77f83feb76d502e9623c394ea09322e29a03f5bc04d32/pyobjc_framework_dvdplayback-12.1.tar.gz", hash = "sha256:279345d4b5fb2c47dd8e5c2fd289e644b6648b74f5c25079805eeb61bfc4a9cd", size = 32332, upload-time = "2025-11-14T10:15:05.257Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/da/70/c7cbd09f8a84f1fc904206f855688c76feb02aaae1ab4efb6f1858f0ec0b/pyobjc_framework_dvdplayback-12.2-py2.py3-none-any.whl", hash = "sha256:37d0b460e0783c78c3099a653ae1a7db8158b12e4da6ca91d513ec708514baa6", size = 8244, upload-time = "2026-05-30T12:06:34.978Z" }, + { url = "https://files.pythonhosted.org/packages/29/7d/22c07c28fab1f15f0d364806e39a6ca63c737c645fe7e98e157878b5998c/pyobjc_framework_dvdplayback-12.1-py2.py3-none-any.whl", hash = "sha256:af911cc222272a55b46a1a02a46a355279aecfd8132231d8d1b279e252b8ad4c", size = 8243, upload-time = "2025-11-14T09:48:11.824Z" }, ] [[package]] name = "pyobjc-framework-eventkit" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-cocoa" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/fd/63/1acab761201e3ba2ddaa093470bb94373a11cee4f406587fb687e31062ab/pyobjc_framework_eventkit-12.2.tar.gz", hash = "sha256:c4e96235a1f0e43ea9699054c289369efb9d7645254a6169559c671b4ed21f86", size = 33759, upload-time = "2026-05-30T12:37:28.465Z" } +sdist = { url = "https://files.pythonhosted.org/packages/b6/42/4ec97e641fdcf30896fe76476181622954cb017117b1429f634d24816711/pyobjc_framework_eventkit-12.1.tar.gz", hash = "sha256:7c1882be2f444b1d0f71e9a0cd1e9c04ad98e0261292ab741fc9de0b8bbbbae9", size = 28538, upload-time = "2025-11-14T10:15:07.878Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/90/c0/257069ea9e34c3b0dc473f6ac9c03c95029e9b3c686875ae8f1c564eb0ac/pyobjc_framework_eventkit-12.2-py2.py3-none-any.whl", hash = "sha256:b56a736182365eff268b6a8c958a663d53432bac5befd3116570d3f1e4ec8b1a", size = 6924, upload-time = "2026-05-30T12:06:36.781Z" }, + { url = "https://files.pythonhosted.org/packages/f4/35/142f43227627d6324993869d354b9e57eb1e88c4e229e2271592254daf25/pyobjc_framework_eventkit-12.1-py2.py3-none-any.whl", hash = "sha256:3d2d36d5bd9e0a13887a6ac7cdd36675985ebe2a9cb3cdf8cec0725670c92c60", size = 6820, upload-time = "2025-11-14T09:48:14.035Z" }, ] [[package]] name = "pyobjc-framework-exceptionhandling" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-cocoa" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/6c/77/2ecf87e8ddffb3c43e0c79bba7e1113436b45c3bc30ee76a82e94f5028ec/pyobjc_framework_exceptionhandling-12.2.tar.gz", hash = "sha256:c11ab2b122b6f2d1dc4625d163a2c5713df5ec3b0372394d3b6ed875a49397f5", size = 17168, upload-time = "2026-05-30T12:37:30.505Z" } +sdist = { url = "https://files.pythonhosted.org/packages/f1/17/5c9d4164f7ccf6b9100be0ad597a7857395dd58ea492cba4f0e9c0b77049/pyobjc_framework_exceptionhandling-12.1.tar.gz", hash = "sha256:7f0719eeea6695197fce0e7042342daa462683dc466eb6a442aad897032ab00d", size = 16694, upload-time = "2025-11-14T10:15:10.173Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/c3/24/9ab5cba61d04445d36ef2bd52ff871056cedde22c3a2a4ff60f111d1f25b/pyobjc_framework_exceptionhandling-12.2-py2.py3-none-any.whl", hash = "sha256:14a76583bec99e18c5d0b0fd1db554d6f75b614f2912435836bc4abe6e1220c5", size = 7114, upload-time = "2026-05-30T12:06:38.383Z" }, + { url = "https://files.pythonhosted.org/packages/0b/ad/8e05acf3635f20ea7d878be30d58a484c8b901a8552c501feb7893472f86/pyobjc_framework_exceptionhandling-12.1-py2.py3-none-any.whl", hash = "sha256:2f1eae14cf0162e53a0888d9ffe63f047501fe583a23cdc9c966e89f48cf4713", size = 7113, upload-time = "2025-11-14T09:48:15.685Z" }, ] [[package]] name = "pyobjc-framework-executionpolicy" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-cocoa" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/f0/e6/ad5d770d04c5cd057c20362724246d1a7407883854e065c86122bcfdc272/pyobjc_framework_executionpolicy-12.2.tar.gz", hash = "sha256:9b527b0deede8057a6482a6837ad8b3f6c3117232b8c9f97a3244991c9d0449f", size = 13040, upload-time = "2026-05-30T12:37:32.139Z" } +sdist = { url = "https://files.pythonhosted.org/packages/95/11/db765e76e7b00e1521d7bb3a61ae49b59e7573ac108da174720e5d96b61b/pyobjc_framework_executionpolicy-12.1.tar.gz", hash = "sha256:682866589365cd01d3a724d8a2781794b5cba1e152411a58825ea52d7b972941", size = 12594, upload-time = "2025-11-14T10:15:12.077Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/9e/25/4b8994d6bc1b4647546a89225770e68121dad788e26fb2eba458e028d6fa/pyobjc_framework_executionpolicy-12.2-py2.py3-none-any.whl", hash = "sha256:a8b6177182c1cf316696db76de23dd40b47e41e8eebbe6fa204492055c8f1f3b", size = 3774, upload-time = "2026-05-30T12:06:39.998Z" }, + { url = "https://files.pythonhosted.org/packages/51/2c/f10352398f10f244401ab8f53cabd127dc3f5dbbfc8de83464661d716671/pyobjc_framework_executionpolicy-12.1-py2.py3-none-any.whl", hash = "sha256:c3a9eca3bd143cf202787dd5e3f40d954c198f18a5e0b8b3e2fcdd317bf33a52", size = 3739, upload-time = "2025-11-14T09:48:17.35Z" }, ] [[package]] name = "pyobjc-framework-extensionkit" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-cocoa" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/c2/37/d8578fa098ce7c4caf70bd02cc52ebae57dba3beeea260e27f10852ab738/pyobjc_framework_extensionkit-12.2.tar.gz", hash = "sha256:eb85b5ccea05f5bc41d5c134a2d199eae2a3bc4ee12cdddb94501272a45052e7", size = 19199, upload-time = "2026-05-30T12:37:34.066Z" } +sdist = { url = "https://files.pythonhosted.org/packages/9a/d4/e9b1f74d29ad9dea3d60468d59b80e14ed3a19f9f7a25afcbc10d29c8a1e/pyobjc_framework_extensionkit-12.1.tar.gz", hash = "sha256:773987353e8aba04223dbba3149253db944abfb090c35318b3a770195b75da6d", size = 18694, upload-time = "2025-11-14T10:15:14.104Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/4b/7f/21d173aed300819ff9e7ed9918c8817f6279c0c85687208fc5466e92efce/pyobjc_framework_extensionkit-12.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:e81277815e9b7ad6adb8141be1ddc794cbb92acbcb8b582f0b929100c6528ffc", size = 7943, upload-time = "2026-05-30T12:06:46.384Z" }, - { url = "https://files.pythonhosted.org/packages/a4/cf/c75dc1b6a171743eb45ba4a28f51eeb3d348727d2b85c7af32609e18847c/pyobjc_framework_extensionkit-12.2-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:7f480965e4c3d06f352116f9362ecfaee20337f16a832c3f39ec185ebfc87553", size = 8084, upload-time = "2026-05-30T12:06:48.235Z" }, + { url = "https://files.pythonhosted.org/packages/f5/75/63c304543fc3c5c0755521ab0535e3f81f6ab8de656a02598e23f687cb6c/pyobjc_framework_extensionkit-12.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:8f2a87bd4fbb8d14900bbe9c979b23b7532b23685c0f5022671b26db4fa3e515", size = 7946, upload-time = "2025-11-14T09:48:25.803Z" }, + { url = "https://files.pythonhosted.org/packages/bd/40/2dab02d8726abf586f253fbddc2d0d9b2abd5dbb4b24272eb48c886741fc/pyobjc_framework_extensionkit-12.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:570e8a89116380a27dd8df7ce28cd5f7296eb785aea4cb7dc6447954005360c2", size = 8086, upload-time = "2025-11-14T09:48:27.715Z" }, ] [[package]] name = "pyobjc-framework-externalaccessory" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-cocoa" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/ea/fd/8eaf82d13c74834007c716a13a10e6c2dfc0edaf62248c4801ad951e924f/pyobjc_framework_externalaccessory-12.2.tar.gz", hash = "sha256:0df5c2db52220753e3c7673fa3051fdf5d2890b9972dc3e140edc3dc16c7cd4d", size = 21989, upload-time = "2026-05-30T12:37:36.303Z" } +sdist = { url = "https://files.pythonhosted.org/packages/8e/35/86c097ae2fdf912c61c1276e80f3e090a3fc898c75effdf51d86afec456b/pyobjc_framework_externalaccessory-12.1.tar.gz", hash = "sha256:079f770a115d517a6ab87db1b8a62ca6cdf6c35ae65f45eecc21b491e78776c0", size = 20958, upload-time = "2025-11-14T10:15:16.419Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/bb/0b/bf64b437eb48e86078cd2e9303ff4f45f1ea43b2f0febdf2bd03f44708c3/pyobjc_framework_externalaccessory-12.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:c04313f4b68982d9f9f23d208f234b44d80472000b9945392459eddc44a61121", size = 8942, upload-time = "2026-05-30T12:07:01.214Z" }, - { url = "https://files.pythonhosted.org/packages/b2/98/2588a2e1888d91f1059ad0c3d1939a213f23fb5bfe0130828808eed3393a/pyobjc_framework_externalaccessory-12.2-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:e546bb0db0e6832a40ac4978a24117eb1f93c2f419f6f26d908fd4315f04bd8e", size = 9105, upload-time = "2026-05-30T12:07:02.797Z" }, + { url = "https://files.pythonhosted.org/packages/2d/bf/9e368e16edb94d9507c1034542379b943e0d9c3bcc0ce8062ac330216317/pyobjc_framework_externalaccessory-12.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:34858f06cd75fe4e358555961a6898eb8778fd2931058fd660fcd5d6cf31b162", size = 8944, upload-time = "2025-11-14T09:48:39.07Z" }, + { url = "https://files.pythonhosted.org/packages/71/5b/643a00fe334485b4100d7a68330b6c6c349fe27434e0dc0fdf2065984555/pyobjc_framework_externalaccessory-12.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:5551915fa82ff1eea8e5810f74c1298e5327aefe4ac90abeb9a7abd69ff33a22", size = 9100, upload-time = "2025-11-14T09:48:41.57Z" }, ] [[package]] name = "pyobjc-framework-fileprovider" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-cocoa" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/a3/a4/44d4f784ed0601800c80e06c53e892ccc39c2a5545bb1caa13b661fd6d83/pyobjc_framework_fileprovider-12.2.tar.gz", hash = "sha256:f9b146eab8a7f664f0e417310802bc2e31ad52b0f61951ce58e471a989ad4e71", size = 50565, upload-time = "2026-05-30T12:37:40.136Z" } +sdist = { url = "https://files.pythonhosted.org/packages/cc/9a/724b1fae5709f8860f06a6a2a46de568f9bb8bdb2e2aae45b4e010368f51/pyobjc_framework_fileprovider-12.1.tar.gz", hash = "sha256:45034e0d00ae153c991aa01cb1fd41874650a30093e77ba73401dcce5534c8ad", size = 43071, upload-time = "2025-11-14T10:15:19.989Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/57/b6/27766ae4419f64f654c7c0b1f9892a0f82baec01a298fabd45d4fef10dfa/pyobjc_framework_fileprovider-12.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:5718203d129eaf32dbf454b2a7a5f312f2dba108a4b49fa0536702537f93c961", size = 21080, upload-time = "2026-05-30T12:07:18.475Z" }, - { url = "https://files.pythonhosted.org/packages/3d/48/bb7466f3a3d990868eccee96c6eb02155af2aabb08b705f90302789848c1/pyobjc_framework_fileprovider-12.2-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:78c6528c5d59881f88b2fe657fb48aa75b652b830ca18f58cabc1ece2f308ff6", size = 21360, upload-time = "2026-05-30T12:07:20.798Z" }, + { url = "https://files.pythonhosted.org/packages/31/92/23deb9d12690a69599dd7a66f3f5a5a3c09824147d148759a33c5c2933fc/pyobjc_framework_fileprovider-12.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:a1a7a6ac3af1e93d23f5644b4c7140dc7edf5ff79419cc0bd25ce7001afc1cf6", size = 21018, upload-time = "2025-11-14T09:48:55.504Z" }, + { url = "https://files.pythonhosted.org/packages/a4/99/cec0a13ca8da9283d1a1bbaeeabdff7903be5c85cfb27a2bb7cc121cb529/pyobjc_framework_fileprovider-12.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:6d6744c8c4f915b6193a982365d947b63286cea605f990a2aaa3bb37069471f2", size = 21300, upload-time = "2025-11-14T09:48:57.948Z" }, ] [[package]] name = "pyobjc-framework-fileproviderui" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-fileprovider" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/1b/53/ce4fc44c62f813e6572426c0f66475f5a5e4804693001185faa80aa95af7/pyobjc_framework_fileproviderui-12.2.tar.gz", hash = "sha256:520974c2966057cd47206f8792d8066531551b3222c8a5824851cc19e9bba7f0", size = 12852, upload-time = "2026-05-30T12:37:41.84Z" } +sdist = { url = "https://files.pythonhosted.org/packages/50/00/234f9b93f75255845df81d9d5ea20cb83ecb5c0a4e59147168b622dd0b9d/pyobjc_framework_fileproviderui-12.1.tar.gz", hash = "sha256:15296429d9db0955abc3242b2920b7a810509a85118dbc185f3ac8234e5a6165", size = 12437, upload-time = "2025-11-14T10:15:22.044Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/d5/40/4514fc9cf9b9f20d2abe1dac66c4f94b8c20da9db7865ee9dec9dd6f3f65/pyobjc_framework_fileproviderui-12.2-py2.py3-none-any.whl", hash = "sha256:0874b16ea64d055f53d0c6ede6ba61b3dbe9d2b27a64db5c12b829391a510cb6", size = 3715, upload-time = "2026-05-30T12:07:31.596Z" }, + { url = "https://files.pythonhosted.org/packages/e8/65/cc4397511bd0af91993d6302a2aed205296a9ad626146eefdfc8a9624219/pyobjc_framework_fileproviderui-12.1-py2.py3-none-any.whl", hash = "sha256:521a914055089e28631018bd78df4c4f7416e98b4150f861d4a5bc97d5b1ffe4", size = 3715, upload-time = "2025-11-14T09:49:04.213Z" }, ] [[package]] name = "pyobjc-framework-findersync" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-cocoa" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/54/8c/dc4e185d054d422f0b24417dd0a340923f7cd317e70879dcbb740bfdd01c/pyobjc_framework_findersync-12.2.tar.gz", hash = "sha256:e8c8dbfd0c1e9a055d5778c8f65a72bfaabfb8c30ff9ef635ea25ee2d607dd75", size = 14210, upload-time = "2026-05-30T12:37:43.536Z" } +sdist = { url = "https://files.pythonhosted.org/packages/e4/63/c8da472e0910238a905bc48620e005a1b8ae7921701408ca13e5fb0bfb4b/pyobjc_framework_findersync-12.1.tar.gz", hash = "sha256:c513104cef0013c233bf8655b527df665ce6f840c8bc0b3781e996933d4dcfa6", size = 13507, upload-time = "2025-11-14T10:15:24.161Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/98/3f/cd17c17bd1e3baa57388d80c5343bceb02df455047a3cfb91498b32849cd/pyobjc_framework_findersync-12.2-py2.py3-none-any.whl", hash = "sha256:6f7a461df88f4fe0cd64c0ad326c77bf1a8f72afb1bdf1f42c1d7e02b7340dd4", size = 4887, upload-time = "2026-05-30T12:07:33.154Z" }, + { url = "https://files.pythonhosted.org/packages/6a/9f/ec7f393e3e2fd11cbdf930d884a0ba81078bdb61920b3cba4f264de8b446/pyobjc_framework_findersync-12.1-py2.py3-none-any.whl", hash = "sha256:e07abeca52c486cf14927f617afc27afa7a3828b99fab3ad02355105fb29203e", size = 4889, upload-time = "2025-11-14T09:49:05.763Z" }, ] [[package]] name = "pyobjc-framework-fsevents" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-cocoa" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/35/cb/f3fa1c24c2f7b3fc086b5cd0d7ec8bed1d5524e2b77d6e7b5c86d05284d5/pyobjc_framework_fsevents-12.2.tar.gz", hash = "sha256:c6599daed508605916fa31b23866c20ccc12565b568f61a43b5626d9b8bb8778", size = 27156, upload-time = "2026-05-30T12:37:45.922Z" } +sdist = { url = "https://files.pythonhosted.org/packages/43/17/21f45d2bca2efc72b975f2dfeae7a163dbeabb1236c1f188578403fd4f09/pyobjc_framework_fsevents-12.1.tar.gz", hash = "sha256:a22350e2aa789dec59b62da869c1b494a429f8c618854b1383d6473f4c065a02", size = 26487, upload-time = "2025-11-14T10:15:26.796Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/67/61/e5376e0c3a95b93a6f1a77f68ca7a454ffe892ff6c5f301f4b83231a26a4/pyobjc_framework_fsevents-12.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:b4adc50338dc4f9f50f3525e2f070e2ab4b469976f9d4762e373505f82068831", size = 13131, upload-time = "2026-05-30T12:07:40.621Z" }, - { url = "https://files.pythonhosted.org/packages/3d/14/f0fc106e63187438c783f2b8480470d43fba311355343856bda91899248c/pyobjc_framework_fsevents-12.2-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:a00440f1e79f6639ffd601bf973d6c7064d82174da8433999825c33617d9c053", size = 13496, upload-time = "2026-05-30T12:07:42.429Z" }, + { url = "https://files.pythonhosted.org/packages/19/41/f06d14020eb9ec10c0e36f5e3f836f8541b989dcde9f53ea172852a7c864/pyobjc_framework_fsevents-12.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:2b30c72239a9ced4e4604fcf265a1efee788cb47850982dd80fcbaafa7ee64f9", size = 13143, upload-time = "2025-11-14T09:49:14.019Z" }, + { url = "https://files.pythonhosted.org/packages/2b/3a/10c1576da38f7e39d6adb592f54fa1b058c859c7d38d03b0cdaf25e12f8d/pyobjc_framework_fsevents-12.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:05220368b0685783e0ae00c885e167169d47ff5cf66de7172ca8074682dfc330", size = 13511, upload-time = "2025-11-14T09:49:16.423Z" }, ] [[package]] name = "pyobjc-framework-fskit" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-cocoa" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/cc/46/9f5162cfde0340792043ab60d1a039f442a67b001f7bfc981b6837a9b07d/pyobjc_framework_fskit-12.2.tar.gz", hash = "sha256:a1a7f9678c55fa947783caa24325c91727cc3045b877c6770262790c00da3952", size = 49558, upload-time = "2026-05-30T12:37:49.685Z" } +sdist = { url = "https://files.pythonhosted.org/packages/a1/55/d00246d6e6d9756e129e1d94bc131c99eece2daa84b2696f6442b8a22177/pyobjc_framework_fskit-12.1.tar.gz", hash = "sha256:ec54e941cdb0b7d800616c06ca76a93685bd7119b8aa6eb4e7a3ee27658fc7ba", size = 42372, upload-time = "2025-11-14T10:15:30.411Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/5c/ce/6bec42dade6873cf440f62d18be277b342b326bdb0ee7835b5f79b2748dc/pyobjc_framework_fskit-12.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:fcc8db6cf9e9b0e731e056411976c184bb3861288da4e97dae91a3e3e8063ade", size = 20597, upload-time = "2026-05-30T12:07:59.189Z" }, - { url = "https://files.pythonhosted.org/packages/8d/ce/385a29b02bc81bb70169cc2a5d85b78d3af131a113acb2615d87f12c5f16/pyobjc_framework_fskit-12.2-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:1f3935499d00678da05b97a7baa46bdbecaef3fd61768fa5dd34bd3dd484ad55", size = 20826, upload-time = "2026-05-30T12:08:01.384Z" }, + { url = "https://files.pythonhosted.org/packages/ce/99/eb30b8b99a4d62ff90b8aa66c6074bf6e2732705a3a8f086ba623fcc642f/pyobjc_framework_fskit-12.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:528b988ea6af1274c81ff698f802bb55a12e32633862919dd4b303ec3b941fae", size = 20258, upload-time = "2025-11-14T09:49:30.893Z" }, + { url = "https://files.pythonhosted.org/packages/50/b6/0579127ff0ad03f6b8f26a7e856e5c9998c9b0efb7ac944b27e23136acf7/pyobjc_framework_fskit-12.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:55e3e00e51bc33d43ed57efb9ceb252abfceba0bd563dae07c7b462da7add849", size = 20491, upload-time = "2025-11-14T09:49:33.249Z" }, ] [[package]] name = "pyobjc-framework-gamecenter" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-cocoa" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/18/bf/71c09142969953637a524946c3609ddf472c0b4311d134223cc9c87dbf8f/pyobjc_framework_gamecenter-12.2.tar.gz", hash = "sha256:a1207696a547011094a4b8d2865a3a9018a622647a8a0371baf86a3e5959ef4f", size = 32153, upload-time = "2026-05-30T12:37:52.717Z" } +sdist = { url = "https://files.pythonhosted.org/packages/d2/f8/b5fd86f6b722d4259228922e125b50e0a6975120a1c4d957e990fb84e42c/pyobjc_framework_gamecenter-12.1.tar.gz", hash = "sha256:de4118f14c9cf93eb0316d49da410faded3609ce9cd63425e9ef878cebb7ea72", size = 31473, upload-time = "2025-11-14T10:15:33.38Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/41/77/2496866b618c96b3569da87385db6593688222f6fcaf733cc702abf0309f/pyobjc_framework_gamecenter-12.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:c5ff47f68b0f5f138fb91f03e5cc46dd12f00d95f795ed5b88f8b99c52e54e2f", size = 18868, upload-time = "2026-05-30T12:08:18.814Z" }, - { url = "https://files.pythonhosted.org/packages/5c/d0/6ec40754993e4f6f0366d7a13e5a19b6745b7c7d6395f2be0b3b60d5688e/pyobjc_framework_gamecenter-12.2-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:ee1890cc3e1266407d41475659b382067a08765bdbc62a0ae4eecec733491fec", size = 19153, upload-time = "2026-05-30T12:08:20.886Z" }, + { url = "https://files.pythonhosted.org/packages/cd/b4/d89eaeae9057e5fc6264ad47247739160650dfd02b1e85a84d45036f25f9/pyobjc_framework_gamecenter-12.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:16c885eae6ad29abb8d3ad17a9068c920f778622bff5401df31842fdbcebdd84", size = 18873, upload-time = "2025-11-14T09:49:47.072Z" }, + { url = "https://files.pythonhosted.org/packages/20/17/e5fe5a8f80288e61d70b6f9ccf05cffe6f1809736c11f172570af24216f6/pyobjc_framework_gamecenter-12.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:9112d7aa8807d4b18a3f7190f310d60380640faaf405a1d0a9fd066c6420ae5b", size = 19154, upload-time = "2025-11-14T09:49:49.26Z" }, ] [[package]] name = "pyobjc-framework-gamecontroller" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-cocoa" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/d1/4c/440ac9652cae2fc386702a39973008fe0fd18928f70b359728c1926f5350/pyobjc_framework_gamecontroller-12.2.tar.gz", hash = "sha256:130418999cb5e202c0775fc1587666c6b9fa1d9285341eb6cbd589ecbe758a64", size = 65272, upload-time = "2026-05-30T12:37:57.45Z" } +sdist = { url = "https://files.pythonhosted.org/packages/21/14/353bb1fe448cd833839fd199ab26426c0248088753e63c22fe19dc07530f/pyobjc_framework_gamecontroller-12.1.tar.gz", hash = "sha256:64ed3cc4844b67f1faeb540c7cc8d512c84f70b3a4bafdb33d4663a2b2a2b1d8", size = 54554, upload-time = "2025-11-14T10:15:37.591Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/65/54/519b19e43bb3fcb8058c9cf780d324e7b3532a1b8a317ff1831615993206/pyobjc_framework_gamecontroller-12.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:8a448b31594c68993da348c3f2f24c02323853905e999f930d7c5d0fa6b4468d", size = 21517, upload-time = "2026-05-30T12:08:39.214Z" }, - { url = "https://files.pythonhosted.org/packages/da/f3/11be9f022e2cc30f1ff2509bdb8405005b707beee2a01b70798054c52cdd/pyobjc_framework_gamecontroller-12.2-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:d5a5ea2c31f179c72dfbd1564aaca52fcce742c27f91e2c7af37ba1e4777c3fa", size = 21768, upload-time = "2026-05-30T12:08:41.309Z" }, + { url = "https://files.pythonhosted.org/packages/9d/7c/4553f7c37eedef4cd2e6f0d9b6c63da556ed2fbe7dd2a79735654e082932/pyobjc_framework_gamecontroller-12.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:2105b4309222e538b9bccf906d24f083c3cbf1cd1c18b3ae6876e842e84d2163", size = 20956, upload-time = "2025-11-14T09:50:04.123Z" }, + { url = "https://files.pythonhosted.org/packages/ad/ed/19e27404ce87256642431a60914ef2cb0578142727981714d494970e21c3/pyobjc_framework_gamecontroller-12.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:a772cc9fbe09bcc601abcc36855a70cbad4640bd3349c1d611c09fcc7e45b73b", size = 21226, upload-time = "2025-11-14T09:50:06.462Z" }, ] [[package]] name = "pyobjc-framework-gamekit" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-cocoa" }, { name = "pyobjc-framework-quartz" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/c6/e3/dfc67af937bdf98b92fc0f6518bd1ee17cf84025ded15bd64acb91f0db8f/pyobjc_framework_gamekit-12.2.tar.gz", hash = "sha256:d4f4f98539db6125d5fb249b845398a0534f8962e6db390822da808b91ece009", size = 82428, upload-time = "2026-05-30T12:38:03.157Z" } +sdist = { url = "https://files.pythonhosted.org/packages/52/7b/d625c0937557f7e2e64200fdbeb867d2f6f86b2f148b8d6bfe085e32d872/pyobjc_framework_gamekit-12.1.tar.gz", hash = "sha256:014d032c3484093f1409f8f631ba8a0fd2ff7a3ae23fd9d14235340889854c16", size = 63833, upload-time = "2025-11-14T10:15:42.842Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/7e/26/f1af94c102570afb8ed0e1461fcc752098d8ea12e88959cbc3cd25709005/pyobjc_framework_gamekit-12.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:06ac26311a602aa0674c21d6dbc3fb0a19e0d8cc385e2e80b689518c3737df8c", size = 22571, upload-time = "2026-05-30T12:09:00.597Z" }, - { url = "https://files.pythonhosted.org/packages/74/da/4020429066e04b02c1e40662dd546bba30adfbbbb19a3b87a4007bfe0244/pyobjc_framework_gamekit-12.2-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:d915b5a8e8073769f0c371aedbbce31152859ab6352f7488f815bd572e1a12da", size = 22864, upload-time = "2026-05-30T12:09:03.066Z" }, + { url = "https://files.pythonhosted.org/packages/8a/7d/65b16b18dc15283d6f56df5ebf30ae765eaf1f8e67e6eb30539581fe9749/pyobjc_framework_gamekit-12.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:ad14393ac496a4cb8008b6172d536f5c07fc11bb7b00fb541b044681cf9e4a34", size = 22505, upload-time = "2025-11-14T09:50:21.989Z" }, + { url = "https://files.pythonhosted.org/packages/98/19/433595ff873684e0df73067b32aba6fc4b360d3ed552444115285a5d969a/pyobjc_framework_gamekit-12.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:97e41b4800be30cb3e6a88007b6f741cb18935467d1631537ac23b918659900e", size = 22798, upload-time = "2025-11-14T09:50:24.583Z" }, ] [[package]] name = "pyobjc-framework-gameplaykit" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-cocoa" }, { name = "pyobjc-framework-spritekit" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/a8/72/df0abe840ebc9e62f8a04afefeb38997b7774ab2b68ceebe89a9dfb81b2d/pyobjc_framework_gameplaykit-12.2.tar.gz", hash = "sha256:27da2b7c4cdef038215246fc6c98e45e076f969ebb83d827095432a8213b57df", size = 50735, upload-time = "2026-05-30T12:38:06.977Z" } +sdist = { url = "https://files.pythonhosted.org/packages/e2/11/c310bbc2526f95cce662cc1f1359bb11e2458eab0689737b4850d0f6acb7/pyobjc_framework_gameplaykit-12.1.tar.gz", hash = "sha256:935ebd806d802888969357946245d35a304c530c86f1ffe584e2cf21f0a608a8", size = 41511, upload-time = "2025-11-14T10:15:46.529Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/68/47/58dbd455f2d3cd18598408a45b05580387e788104148993aa79b8f4749de/pyobjc_framework_gameplaykit-12.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:89a695937dff8a4a43ac9d389b5f3eb64ced06410e8fbeb6e04f1976ed7c8be5", size = 13624, upload-time = "2026-05-30T12:09:20.136Z" }, - { url = "https://files.pythonhosted.org/packages/5a/73/87d2d0f4b97942f1401fd8985e8d7b2191502ed210c945472da1e37a4d2a/pyobjc_framework_gameplaykit-12.2-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:db270f78befada566106e3557bdc7281fe2f2759cf81e664e9a45ff2ce709c72", size = 13839, upload-time = "2026-05-30T12:09:22.044Z" }, + { url = "https://files.pythonhosted.org/packages/08/c9/d90505bed51b487d7a8eff54a51dda0d9b8e2d76740a99924b5067b58062/pyobjc_framework_gameplaykit-12.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:947911902e0caf1d82dedae8842025891d57e91504714a7732dc7c4f80d486a1", size = 13164, upload-time = "2025-11-14T09:50:39.251Z" }, + { url = "https://files.pythonhosted.org/packages/ad/42/9d5ac9a4398f1d1566ce83f16f68aeaa174137de78bec4515ed927c24530/pyobjc_framework_gameplaykit-12.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:3218de7a56ac63a47ab7c50ce30592d626759196c937d20426a0ea74091e0614", size = 13383, upload-time = "2025-11-14T09:50:41.227Z" }, ] [[package]] name = "pyobjc-framework-gamesave" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-cocoa" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/49/fb/aed9853de0ac26c768c1bfefd7c32443367e489d16f5b5563043019aecf7/pyobjc_framework_gamesave-12.2.tar.gz", hash = "sha256:e272a1ec2fc84f680226abc6a4e034534509cbd545cb937fbc76b3a95d7b9e44", size = 13245, upload-time = "2026-05-30T12:38:08.719Z" } +sdist = { url = "https://files.pythonhosted.org/packages/1b/1f/8d05585c844535e75dbc242dd6bdfecfc613d074dcb700362d1c908fb403/pyobjc_framework_gamesave-12.1.tar.gz", hash = "sha256:eb731c97aa644e78a87838ed56d0e5bdbaae125bdc8854a7772394877312cc2e", size = 12654, upload-time = "2025-11-14T10:15:48.344Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/e1/da/570c14f8c63cda0a128084cfc53f729e9183987b4a5582cc5ce4b3dbc6b7/pyobjc_framework_gamesave-12.2-py2.py3-none-any.whl", hash = "sha256:766d6eede6e7f9ef1c43333127ce42fdfa9438e62ab94c9533d32d41eb79233a", size = 3729, upload-time = "2026-05-30T12:09:30.757Z" }, + { url = "https://files.pythonhosted.org/packages/59/ec/93d48cb048a1b35cea559cc9261b07f0d410078b3af029121302faa410d0/pyobjc_framework_gamesave-12.1-py2.py3-none-any.whl", hash = "sha256:432e69f8404be9290d42c89caba241a3156ed52013947978ac54f0f032a14ffd", size = 3689, upload-time = "2025-11-14T09:50:47.263Z" }, ] [[package]] name = "pyobjc-framework-healthkit" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-cocoa" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/7c/c8/fa1a309cabfa0d7190a6dc1f6194d349cdde0105b86683780190aa4e46ac/pyobjc_framework_healthkit-12.2.tar.gz", hash = "sha256:48bda5f86fff2da976c49d27c746cd190d62eebdfa6197305c3656c64a6fbf09", size = 116197, upload-time = "2026-05-30T12:38:16.268Z" } +sdist = { url = "https://files.pythonhosted.org/packages/af/67/436630d00ba1028ea33cc9df2fc28e081481433e5075600f2ea1ff00f45e/pyobjc_framework_healthkit-12.1.tar.gz", hash = "sha256:29c5e5de54b41080b7a4b0207698ac6f600dcb9149becc9c6b3a69957e200e5c", size = 91802, upload-time = "2025-11-14T10:15:54.661Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/5e/44/db40ed76d01e0a99820f56dd0792448dbc34d508d2235d9185ec0fbb3db8/pyobjc_framework_healthkit-12.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:489858fd2cf97747390d14bd5343448a9cf612383e96958fd70968d1d7e75d02", size = 22058, upload-time = "2026-05-30T12:09:40.434Z" }, - { url = "https://files.pythonhosted.org/packages/8b/88/839c556d8e8e75b65961e65b78f683113cca6637e1917c9c4c0e2f050249/pyobjc_framework_healthkit-12.2-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:c8d43159c2c40641f9306407ef909b338325028846d04feaf2b26673d6b1bb4d", size = 22228, upload-time = "2026-05-30T12:09:42.738Z" }, + { url = "https://files.pythonhosted.org/packages/40/f8/4bbaf71a11a99649a4aa9f4ac28d94a2bf357cd4c88fba91439000301cf0/pyobjc_framework_healthkit-12.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:c57ba8e3cce620665236d9f6b77482c9cfb16fe3372c8b6bbabc50222fb1b790", size = 20812, upload-time = "2025-11-14T09:50:57.238Z" }, + { url = "https://files.pythonhosted.org/packages/e9/ef/4461f34f42e8f78b941161df7045d27e48d73d203847a21921b5a36ffe68/pyobjc_framework_healthkit-12.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:b2a0890d920015b40afe8ecda6c541840d20b4ae6c7f2daaa9efbaafae8cc1bc", size = 20980, upload-time = "2025-11-14T09:50:59.644Z" }, ] [[package]] name = "pyobjc-framework-imagecapturecore" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-cocoa" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/d0/7b/fada6744e9409643f7ec948a9b8fd5632a8f935d2c1d53e8a9f443a613bb/pyobjc_framework_imagecapturecore-12.2.tar.gz", hash = "sha256:c2931ca0d40d6ffe159149e140d4d158d3f844f19b99dae35f57c34551434eea", size = 53438, upload-time = "2026-05-30T12:38:20.318Z" } +sdist = { url = "https://files.pythonhosted.org/packages/6d/a1/39347381fc7d3cd5ab942d86af347b25c73f0ddf6f5227d8b4d8f5328016/pyobjc_framework_imagecapturecore-12.1.tar.gz", hash = "sha256:c4776c59f4db57727389d17e1ffd9c567b854b8db52198b3ccc11281711074e5", size = 46397, upload-time = "2025-11-14T10:15:58.541Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/b8/39/23ab07b2cef5e26b017723f061d5941416a107679f19f5327b6576cf5df0/pyobjc_framework_imagecapturecore-12.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:12514630d46621acaeae0b921ee7c9c9e4a2bf81a936690b767a6b745e899812", size = 16055, upload-time = "2026-05-30T12:10:00.367Z" }, - { url = "https://files.pythonhosted.org/packages/13/d3/fed9ab9b40538711e3aba6c7b92a38c5439427510dd318923237f2280dc4/pyobjc_framework_imagecapturecore-12.2-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:56dbdee10d3d735fadfa15b3e7b9a11d3574493a4114fe9bf0eae86f55b43d2e", size = 16240, upload-time = "2026-05-30T12:10:02.684Z" }, + { url = "https://files.pythonhosted.org/packages/f9/32/2d936320147f299d83c14af4eb8e28821d226f2920d2df3f7a3b3daf61dc/pyobjc_framework_imagecapturecore-12.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:2ae57b54e7b92e2efb40b7346e12d7767f42ed2bcf8f050cd9a88a9926a1e387", size = 16025, upload-time = "2025-11-14T09:51:14.387Z" }, + { url = "https://files.pythonhosted.org/packages/09/5a/7bfa64b0561c7eb858dac9b2e0e3a50000e9dc50416451e8ae40b316eb8f/pyobjc_framework_imagecapturecore-12.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:08f8ed5434ee5cc7605e71227c284c0c3fa0a32a6d83e1862e7870543a65a630", size = 16213, upload-time = "2025-11-14T09:51:16.531Z" }, ] [[package]] name = "pyobjc-framework-inputmethodkit" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-cocoa" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/f4/8d/b9ba4cf37ef153584df3098cbc19ba668aef8469f18af53ff464eed1bd96/pyobjc_framework_inputmethodkit-12.2.tar.gz", hash = "sha256:63ab93867f25a3f54fc55e98b6b0540d0d23bf6f91a0a475ff742e4221a75917", size = 26270, upload-time = "2026-05-30T12:38:22.832Z" } +sdist = { url = "https://files.pythonhosted.org/packages/5d/b8/d33dd8b7306029bbbd80525bf833fc547e6a223c494bf69a534487283a28/pyobjc_framework_inputmethodkit-12.1.tar.gz", hash = "sha256:f63b6fe2fa7f1412eae63baea1e120e7865e3b68ccfb7d8b0a4aadb309f2b278", size = 23054, upload-time = "2025-11-14T10:16:01.464Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/49/88/e5fc011ab34970cc1c1cc56b866e2edac6d160d25aafad7e86b033826cbf/pyobjc_framework_inputmethodkit-12.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:160ba62082a30d76b9e4aec1a4d54c95152fe39217940fea597756ad49910dde", size = 9527, upload-time = "2026-05-30T12:10:17.693Z" }, - { url = "https://files.pythonhosted.org/packages/43/68/3c2fc27aab9cf228ede204ad7c8d1fe5f4e714aa4e478fe943dde6417258/pyobjc_framework_inputmethodkit-12.2-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:0b81fba64e92953ffc1788ec13c630a9d19447deacde34a7309c0eae6412d628", size = 9694, upload-time = "2026-05-30T12:10:19.292Z" }, + { url = "https://files.pythonhosted.org/packages/9e/ec/502019d314729e7e82a7fa187dd52b6f99a6097ac0ab6dc675ccd60b5677/pyobjc_framework_inputmethodkit-12.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:b5c7458082e3f7e8bb115ed10074ad862cc6566da7357540205d3cd1e24e2b9f", size = 9523, upload-time = "2025-11-14T09:51:30.751Z" }, + { url = "https://files.pythonhosted.org/packages/47/68/76a75461de5b9c195a6b5081179578fef7136f19ffc4990f6591cabae591/pyobjc_framework_inputmethodkit-12.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:a4e782edd8e59b1ea81ea688d27edbf98cc5c8262e081cb772cf8c36c74733df", size = 9694, upload-time = "2025-11-14T09:51:32.616Z" }, ] [[package]] name = "pyobjc-framework-installerplugins" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-cocoa" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/bf/31/4284cba4b8904d2b93738249bb888762115d06876b92d30b721dea91e014/pyobjc_framework_installerplugins-12.2.tar.gz", hash = "sha256:6de54ab966f5bb304f9f5036c41937675cfdf49c44f70a1078a87dee2520261a", size = 26005, upload-time = "2026-05-30T12:38:25.291Z" } +sdist = { url = "https://files.pythonhosted.org/packages/e7/60/ca4ab04eafa388a97a521db7d60a812e2f81a3c21c2372587872e6b074f9/pyobjc_framework_installerplugins-12.1.tar.gz", hash = "sha256:1329a193bd2e92a2320a981a9a421a9b99749bade3e5914358923e94fe995795", size = 25277, upload-time = "2025-11-14T10:16:04.379Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/2a/08/9b8bb5f74df7d23d83ec5ab954301c91b8239091767df064aaff5b54c7a9/pyobjc_framework_installerplugins-12.2-py2.py3-none-any.whl", hash = "sha256:358ef2faefe1b9938c0563e95551ad685c4c2097a7b8bc46dbf394765eb00674", size = 4814, upload-time = "2026-05-30T12:10:27.678Z" }, + { url = "https://files.pythonhosted.org/packages/99/1f/31dca45db3342882a628aa1b27707a283d4dc7ef558fddd2533175a0661a/pyobjc_framework_installerplugins-12.1-py2.py3-none-any.whl", hash = "sha256:d2201c81b05bdbe0abf0af25db58dc230802573463bea322f8b2863e37b511d5", size = 4813, upload-time = "2025-11-14T09:51:37.836Z" }, ] [[package]] name = "pyobjc-framework-instantmessage" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-cocoa" }, { name = "pyobjc-framework-quartz" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/02/20/2beaee41e71fcfe9bd3149277977aaef9510fae7d4ea3d70baecf2a978f3/pyobjc_framework_instantmessage-12.2.tar.gz", hash = "sha256:95a972697cc1c8c773d2e211815c7b4f3f11ad0aa114e46ec386d92f873d5533", size = 34017, upload-time = "2026-05-30T12:38:28.609Z" } +sdist = { url = "https://files.pythonhosted.org/packages/d4/67/66754e0d26320ba24a33608ca94d3f38e60ee6b2d2e094cb6269b346fdd4/pyobjc_framework_instantmessage-12.1.tar.gz", hash = "sha256:f453118d5693dc3c94554791bd2aaafe32a8b03b0e3d8ec3934b44b7fdd1f7e7", size = 31217, upload-time = "2025-11-14T10:16:07.693Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/a4/63/68356d5150c203b6b027dc93048b7e81d53c58d5d437b60dce914f861496/pyobjc_framework_instantmessage-12.2-py2.py3-none-any.whl", hash = "sha256:2fe9367f736b68557bf0c57a7da2c6a854cbf46ace9f6c5b161131309dc6b262", size = 5436, upload-time = "2026-05-30T12:10:29.334Z" }, + { url = "https://files.pythonhosted.org/packages/c1/38/6ae95b5c87d887c075bd5f4f7cca3d21dafd0a77cfdde870e87ca17579eb/pyobjc_framework_instantmessage-12.1-py2.py3-none-any.whl", hash = "sha256:cd91d38e8f356afd726b6ea8c235699316ea90edfd3472965c251efbf4150bc9", size = 5436, upload-time = "2025-11-14T09:51:39.557Z" }, ] [[package]] name = "pyobjc-framework-intents" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-cocoa" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/70/a1/2544e2b1e4fc794bc09b16651e967cbe11a17bf75f6d13c34a261e49a13f/pyobjc_framework_intents-12.2.tar.gz", hash = "sha256:441acf32738c8a4fa21458467ce451ce6880d0bac71b6e63e2e6634775f603b6", size = 187703, upload-time = "2026-05-30T12:38:40.353Z" } +sdist = { url = "https://files.pythonhosted.org/packages/f1/a1/3bab6139e94b97eca098e1562f5d6840e3ff10ea1f7fd704a17111a97d5b/pyobjc_framework_intents-12.1.tar.gz", hash = "sha256:bd688c3ab34a18412f56e459e9dae29e1f4152d3c2048fcacdef5fc49dfb9765", size = 132262, upload-time = "2025-11-14T10:16:16.428Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/22/4b/74dc067c2475881c4c93a2f4d6f460733a963a3f687de9f413b1280e40d0/pyobjc_framework_intents-12.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:1786dd54d1c570ca6be16383e653b897ad4c1b0c3df9be60ac5f8e0096d4a181", size = 35268, upload-time = "2026-05-30T12:10:42.054Z" }, - { url = "https://files.pythonhosted.org/packages/e7/8d/d6cb87fdc7df4bc81b61cb184d5fed3f55cc2cd30eed90033f434a32716e/pyobjc_framework_intents-12.2-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:9d697dca29ce2c282dafc4db9c0a0f165802e8d056a68f809bee0521ca47ff24", size = 35512, upload-time = "2026-05-30T12:10:45.295Z" }, + { url = "https://files.pythonhosted.org/packages/74/83/6b03ac6d5663be41d76ab69412a21f94eff69c67ffa13516a91e4b946890/pyobjc_framework_intents-12.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:1da8d1501c8c85198dfbc4623ea18db96077f9947f6e1fe5ffa2ed06935e8a3b", size = 32168, upload-time = "2025-11-14T09:51:52.888Z" }, + { url = "https://files.pythonhosted.org/packages/d9/f8/1fd0a75de415d335a1aa43e9c86e468960b3a4d969a87aa4a70084452277/pyobjc_framework_intents-12.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:50ab244f2a9ad4c94bbc1dd81421f8553f59121d4e0ad0c894a927a878319843", size = 32413, upload-time = "2025-11-14T09:51:56.057Z" }, ] [[package]] name = "pyobjc-framework-intentsui" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-intents" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/4b/10/cdd1d80716e9970f5190517daa613a2d16bfec532b3fc9bd8f987c00a178/pyobjc_framework_intentsui-12.2.tar.gz", hash = "sha256:46292de2f2e915ddff88a060639adb175e0b3b2452a45f00e440dc04acbe0e70", size = 20742, upload-time = "2026-05-30T12:38:42.667Z" } +sdist = { url = "https://files.pythonhosted.org/packages/19/cf/f0e385b9cfbf153d68efe8d19e5ae672b59acbbfc1f9b58faaefc5ec8c9e/pyobjc_framework_intentsui-12.1.tar.gz", hash = "sha256:16bdf4b7b91c0d1ec9d5513a1182861f1b5b7af95d4f4218ff7cf03032d57f99", size = 19784, upload-time = "2025-11-14T10:16:18.716Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/a9/f9/10f8bafdd58f136cd373fa2b0b5bd869dd6f7576abee9135fbc51c10e549/pyobjc_framework_intentsui-12.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:da18833b15f8f31ecc5d4769250de6883e1e117392840175ff33d002a8196f46", size = 9047, upload-time = "2026-05-30T12:11:05.908Z" }, - { url = "https://files.pythonhosted.org/packages/15/e9/6f1eb774981b665e87c08f21b3a4695d0d97dce1c2a9e7eb2ab1956605e4/pyobjc_framework_intentsui-12.2-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:96b0b96147554a0e848a6804ad725abbb183b3d045481abf54d31d6a334a1a25", size = 9222, upload-time = "2026-05-30T12:11:07.572Z" }, + { url = "https://files.pythonhosted.org/packages/57/af/4dc8b6f714ba1bd9cf0218da98c49ece5dcee4e0593b59196ec5aa85e07c/pyobjc_framework_intentsui-12.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:369a88db1ff3647e4d8cf38d315f1e9b381fc7732d765b08994036f9d330f57d", size = 9004, upload-time = "2025-11-14T09:52:09.625Z" }, + { url = "https://files.pythonhosted.org/packages/18/ab/794ed92dcf955dc2d0a0dcfbc384e087864f2dacd330d59d1185f8403353/pyobjc_framework_intentsui-12.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:8742e9237ef2df8dbb1566cdc77e4d747b2693202f438d49435e0c3c91eaa709", size = 9177, upload-time = "2025-11-14T09:52:11.26Z" }, ] [[package]] name = "pyobjc-framework-iobluetooth" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-cocoa" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/ae/d0/ea3057fb6977ab87c85db9e676d8ec77ce77d096680bacade1964ced17e5/pyobjc_framework_iobluetooth-12.2.tar.gz", hash = "sha256:7fd7265db0f467a471a015f5a32ee79fd8f42440888d16b4206bbb985ed7331d", size = 174868, upload-time = "2026-05-30T12:38:53.498Z" } +sdist = { url = "https://files.pythonhosted.org/packages/e4/aa/ca3944bbdfead4201b4ae6b51510942c5a7d8e5e2dc3139a071c74061fdf/pyobjc_framework_iobluetooth-12.1.tar.gz", hash = "sha256:8a434118812f4c01dfc64339d41fe8229516864a59d2803e9094ee4cbe2b7edd", size = 155241, upload-time = "2025-11-14T10:16:28.896Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/7e/7c/6252a3f61bd674c770d37517433485653aeb5e24ff2f5df2a71b79cf9197/pyobjc_framework_iobluetooth-12.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:8bea83069a68476036c260e3c1f3f2a6cc919aa965ecd89c8821165daaf9886f", size = 40552, upload-time = "2026-05-30T12:11:28.065Z" }, - { url = "https://files.pythonhosted.org/packages/df/88/4e49653cc0bf64a90b1aa10b89540cd8d6929a4e4ed79d5546b3bf6cc0f8/pyobjc_framework_iobluetooth-12.2-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:2d058ea04a6924233701cb0c9312aea71174d38a37430494e725d17eb7933ae8", size = 40763, upload-time = "2026-05-30T12:11:31.474Z" }, + { url = "https://files.pythonhosted.org/packages/15/6f/5e165daaf3b637d37fee50f42beda62ab3d5e6e99b1d84c4af4700d39d01/pyobjc_framework_iobluetooth-12.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:2ee0d4fdddf871fb89c49033495ae49973cc8b0e8de50c2e60c92355ce3bea86", size = 40452, upload-time = "2025-11-14T09:52:29.68Z" }, + { url = "https://files.pythonhosted.org/packages/37/bd/7cc5f01fbf573112059766c94535ae3f9c044d6e0cf49c599e490224db58/pyobjc_framework_iobluetooth-12.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:0cd2ea9384e93913703bf40641196a930af83c2f6f62f59f8606b7162fe1caa3", size = 40659, upload-time = "2025-11-14T09:52:33.299Z" }, ] [[package]] name = "pyobjc-framework-iobluetoothui" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-iobluetooth" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/27/cd/0c14569b91e29bd0f64e2496c21b15e34e789f0ca07f5cf0149dec37ec72/pyobjc_framework_iobluetoothui-12.2.tar.gz", hash = "sha256:7902974cbc2ec50adc38dd961b03eae6a84f082812ed60a440db6f690b30b2d2", size = 17987, upload-time = "2026-05-30T12:38:55.655Z" } +sdist = { url = "https://files.pythonhosted.org/packages/8f/39/31d9a4e8565a4b1ec0a9ad81480dc0879f3df28799eae3bc22d1dd53705d/pyobjc_framework_iobluetoothui-12.1.tar.gz", hash = "sha256:81f8158bdfb2966a574b6988eb346114d6a4c277300c8c0a978c272018184e6f", size = 16495, upload-time = "2025-11-14T10:16:31.212Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/dd/a8/2ab7199c81c9f1541e20caa78cf44df5f05162665fcfd29f16e3a85fe822/pyobjc_framework_iobluetoothui-12.2-py2.py3-none-any.whl", hash = "sha256:60622518d2f70e82398c62edf5e4e72403ef9210312945d82f3151cb5e888ccb", size = 4043, upload-time = "2026-05-30T12:11:46.476Z" }, + { url = "https://files.pythonhosted.org/packages/e3/c9/69aeda0cdb5d25d30dc4596a1c5b464fc81b5c0c4e28efc54b7e11bde51c/pyobjc_framework_iobluetoothui-12.1-py2.py3-none-any.whl", hash = "sha256:a6d8ab98efa3029130577a57ee96b183c35c39b0f1c53a7534f8838260fab993", size = 4045, upload-time = "2025-11-14T09:52:42.201Z" }, ] [[package]] name = "pyobjc-framework-iosurface" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-cocoa" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/ca/3d/744c44cdd66f273e1ca731343e7845a281cb14a25c40d20a307334a36e21/pyobjc_framework_iosurface-12.2.tar.gz", hash = "sha256:d0315c6ad3b5ee72d3a5c946d9e92a4cace1a96bd0526f0b9f6b8009c26b9716", size = 18607, upload-time = "2026-05-30T12:38:57.666Z" } +sdist = { url = "https://files.pythonhosted.org/packages/07/61/0f12ad67a72d434e1c84b229ec760b5be71f53671ee9018593961c8bfeb7/pyobjc_framework_iosurface-12.1.tar.gz", hash = "sha256:4b9d0c66431aa296f3ca7c4f84c00dc5fc961194830ad7682fdbbc358fa0db55", size = 17690, upload-time = "2025-11-14T10:16:33.282Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/a6/f8/35fcd4d2504d0b470dd746138f47f6a8d8077fbde6aa85914c999ff9f7d5/pyobjc_framework_iosurface-12.2-py2.py3-none-any.whl", hash = "sha256:3ccd3abe40e21028419a39dbea36f60cb7e34335ab1b81aebb7a1a2f644443c5", size = 4903, upload-time = "2026-05-30T12:11:48.133Z" }, + { url = "https://files.pythonhosted.org/packages/88/ad/793d98a7ed9b775dc8cce54144cdab0df1808a1960ee017e46189291a8f3/pyobjc_framework_iosurface-12.1-py2.py3-none-any.whl", hash = "sha256:e784e248397cfebef4655d2c0025766d3eaa4a70474e363d084fc5ce2a4f2a3f", size = 4902, upload-time = "2025-11-14T09:52:43.899Z" }, ] [[package]] name = "pyobjc-framework-ituneslibrary" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-cocoa" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/dd/37/308813d2e80ce9c8c4e5710e0f1e1dc479be03bb06e2f28dc9058862a756/pyobjc_framework_ituneslibrary-12.2.tar.gz", hash = "sha256:780f7e5f354dc2b0a27df4abb6538f730e8a29371a8703bc05edd6ce50466f8e", size = 26172, upload-time = "2026-05-30T12:39:00.202Z" } +sdist = { url = "https://files.pythonhosted.org/packages/f5/46/d9bcec88675bf4ee887b9707bd245e2a793e7cb916cf310f286741d54b1f/pyobjc_framework_ituneslibrary-12.1.tar.gz", hash = "sha256:7f3aa76c4d05f6fa6015056b88986cacbda107c3f29520dd35ef0936c7367a6e", size = 23730, upload-time = "2025-11-14T10:16:36.127Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/3b/c3/6c8fa4798c8f3d5194dc7f1d4ca061840705b7a908b6ba05b3c9449a0b22/pyobjc_framework_ituneslibrary-12.2-py2.py3-none-any.whl", hash = "sha256:9876e99dac601dc523b2f0e528fb21b027693b2b6f7d697fdf460cb819339980", size = 5212, upload-time = "2026-05-30T12:11:49.77Z" }, + { url = "https://files.pythonhosted.org/packages/de/92/b598694a1713ee46f45c4bfb1a0425082253cbd2b1caf9f8fd50f292b017/pyobjc_framework_ituneslibrary-12.1-py2.py3-none-any.whl", hash = "sha256:fb678d7c3ff14c81672e09c015e25880dac278aa819971f4d5f75d46465932ef", size = 5205, upload-time = "2025-11-14T09:52:45.733Z" }, ] [[package]] name = "pyobjc-framework-kernelmanagement" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-cocoa" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/00/b7/f367cc6c20fc0e9b80706284a1978fa0ee90ba61c2421d7bab867a3ce4d2/pyobjc_framework_kernelmanagement-12.2.tar.gz", hash = "sha256:01abc525c1edbacf88425a36a055e52d1b4a024299097d9a2b25c34f2df4bafc", size = 11935, upload-time = "2026-05-30T12:39:02.13Z" } +sdist = { url = "https://files.pythonhosted.org/packages/0a/7e/ecbac119866e8ac2cce700d7a48a4297946412ac7cbc243a7084a6582fb1/pyobjc_framework_kernelmanagement-12.1.tar.gz", hash = "sha256:488062893ac2074e0c8178667bf864a21f7909c11111de2f6a10d9bc579df59d", size = 11773, upload-time = "2025-11-14T10:16:38.216Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/2b/5e/f98eb2645e1899579eb0b30695866611db6c25cef135dfdd323a164a5d8c/pyobjc_framework_kernelmanagement-12.2-py2.py3-none-any.whl", hash = "sha256:14e789ed81eaaf3ca50557015416fdc232400b682b3756efaefe4afd061552e0", size = 3672, upload-time = "2026-05-30T12:11:51.232Z" }, + { url = "https://files.pythonhosted.org/packages/94/32/04325a20f39d88d6d712437e536961a9e6a4ec19f204f241de6ed54d1d84/pyobjc_framework_kernelmanagement-12.1-py2.py3-none-any.whl", hash = "sha256:926381bfbfbc985c3e6dfcb7004af21bb16ff66ecbc08912b925989a705944ff", size = 3704, upload-time = "2025-11-14T09:52:47.268Z" }, ] [[package]] name = "pyobjc-framework-latentsemanticmapping" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-cocoa" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/87/bb/2824a4eae4fad404603e5ab859654f4f5c5efb9687b27f97c58915726a44/pyobjc_framework_latentsemanticmapping-12.2.tar.gz", hash = "sha256:20dfeeb005880053dcccc03dc6a58d796dd72d7f282caa625906bebc3631ecd4", size = 15932, upload-time = "2026-05-30T12:39:04.01Z" } +sdist = { url = "https://files.pythonhosted.org/packages/88/3c/b621dac54ae8e77ac25ee75dd93e310e2d6e0faaf15b8da13513258d6657/pyobjc_framework_latentsemanticmapping-12.1.tar.gz", hash = "sha256:f0b1fa823313eefecbf1539b4ed4b32461534b7a35826c2cd9f6024411dc9284", size = 15526, upload-time = "2025-11-14T10:16:40.149Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/0d/16/85b8b7dbc58a0cd0baba9854604be687620433fe354347c0e93e05025551/pyobjc_framework_latentsemanticmapping-12.2-py2.py3-none-any.whl", hash = "sha256:1c87b1dd06626eca6188c2939f0dc1f58104ac9f8979c1dd8fc5f8c7d4d901e7", size = 5472, upload-time = "2026-05-30T12:11:52.82Z" }, + { url = "https://files.pythonhosted.org/packages/29/8e/74a7eb29b545f294485cd3cf70557b4a35616555fe63021edbb3e0ea4c20/pyobjc_framework_latentsemanticmapping-12.1-py2.py3-none-any.whl", hash = "sha256:7d760213b42bc8b1bc1472e1873c0f78ee80f987225978837b1fecdceddbdbf4", size = 5471, upload-time = "2025-11-14T09:52:48.939Z" }, ] [[package]] name = "pyobjc-framework-launchservices" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-coreservices" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/25/fd/3ecceb569730898ffe9146f3e544415b4e4ea7d3343e424a3cd17500bf5d/pyobjc_framework_launchservices-12.2.tar.gz", hash = "sha256:02c3f25311673fc26eebb256cd0e873c9883575804c98b97a5d2096c8cebcecd", size = 20826, upload-time = "2026-05-30T12:39:06.23Z" } +sdist = { url = "https://files.pythonhosted.org/packages/37/d0/24673625922b0ad21546be5cf49e5ec1afaa4553ae92f222adacdc915907/pyobjc_framework_launchservices-12.1.tar.gz", hash = "sha256:4d2d34c9bd6fb7f77566155b539a2c70283d1f0326e1695da234a93ef48352dc", size = 20470, upload-time = "2025-11-14T10:16:42.499Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/9e/8d/04c6bb237127a6c109437af6bae244b3695deca6dae67a20d408db736a1b/pyobjc_framework_launchservices-12.2-py2.py3-none-any.whl", hash = "sha256:4a0a478dfee2c53b7f3e2168f3c0e4183621050d324e7225251706500f8f5f0e", size = 3902, upload-time = "2026-05-30T12:11:54.2Z" }, + { url = "https://files.pythonhosted.org/packages/08/af/9a0aebaab4c15632dc8fcb3669c68fa541a3278d99541d9c5f966fbc0909/pyobjc_framework_launchservices-12.1-py2.py3-none-any.whl", hash = "sha256:e63e78fceeed4d4dc807f9dabd5cf90407e4f552fab6a0d75a8d0af63094ad3c", size = 3905, upload-time = "2025-11-14T09:52:50.71Z" }, ] [[package]] name = "pyobjc-framework-libdispatch" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-cocoa" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/1b/fe/e23be301e46c30450955cdb096f16f6a86e7609787a4b8225ec24d6fdc9d/pyobjc_framework_libdispatch-12.2.tar.gz", hash = "sha256:4a41879ef7716b73d70f2e40ff39353d686cbc59d48c93217ed362d2b2baf1ba", size = 40345, upload-time = "2026-05-30T12:39:09.474Z" } +sdist = { url = "https://files.pythonhosted.org/packages/26/e8/75b6b9b3c88b37723c237e5a7600384ea2d84874548671139db02e76652b/pyobjc_framework_libdispatch-12.1.tar.gz", hash = "sha256:4035535b4fae1b5e976f3e0e38b6e3442ffea1b8aa178d0ca89faa9b8ecdea41", size = 38277, upload-time = "2025-11-14T10:16:46.235Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/83/ac/f5e01c960287e3484f71a737e7ffd75ca1c192200de70fa342a22181895f/pyobjc_framework_libdispatch-12.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:265fe4edfd60de111c870932ab8397f845c314332a935aa7a27100fd8562cebc", size = 15651, upload-time = "2026-05-30T12:12:03.156Z" }, - { url = "https://files.pythonhosted.org/packages/a2/d9/8bcb4e234aee09396d06515ed80fb1f79cee3aeb67a311aa8e81a085584b/pyobjc_framework_libdispatch-12.2-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:117ed20ca54e334f657e60b9b9a3de3741d91875fd50ee51ac6a09224912cc68", size = 15918, upload-time = "2026-05-30T12:12:05.257Z" }, + { url = "https://files.pythonhosted.org/packages/38/3a/d85a74606c89b6b293782adfb18711026ff79159db20fc543740f2ac0bc7/pyobjc_framework_libdispatch-12.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:58ffce5e6bcd7456b4311009480b195b9f22107b7682fb0835d4908af5a68ad0", size = 15668, upload-time = "2025-11-14T09:53:01.354Z" }, + { url = "https://files.pythonhosted.org/packages/cc/40/49b1c1702114ee972678597393320d7b33f477e9d24f2a62f93d77f23dfb/pyobjc_framework_libdispatch-12.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:e9f49517e253716e40a0009412151f527005eec0b9a2311ac63ecac1bdf02332", size = 15938, upload-time = "2025-11-14T09:53:03.461Z" }, ] [[package]] name = "pyobjc-framework-libxpc" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-cocoa" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/e6/a2/443c0cad2a13ec038318d391f7ebfec2189ea6d97910c0ded4c863631603/pyobjc_framework_libxpc-12.2.tar.gz", hash = "sha256:6dcae3da5ab706762d68625a391c75a3969609e5676d4091947f5c1185d4f800", size = 37263, upload-time = "2026-05-30T12:39:12.446Z" } +sdist = { url = "https://files.pythonhosted.org/packages/16/e4/364db7dc26f235e3d7eaab2f92057f460b39800bffdec3128f113388ac9f/pyobjc_framework_libxpc-12.1.tar.gz", hash = "sha256:e46363a735f3ecc9a2f91637750623f90ee74f9938a4e7c833e01233174af44d", size = 35186, upload-time = "2025-11-14T10:16:49.503Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/82/f3/9e971bd977c63575359c1e4d95a0c7ac8acba1d0094b190bd738bf64dedd/pyobjc_framework_libxpc-12.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:7caa888b1046a7921121cb44087746803a458002a1182105b3e64734b0ca9f40", size = 19753, upload-time = "2026-05-30T12:12:21.682Z" }, - { url = "https://files.pythonhosted.org/packages/70/e7/143c999a6dde74bff96697b36270ee6d8b105ce01d11b1a066d573a5d722/pyobjc_framework_libxpc-12.2-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:56bf8fbc45e722af533bed03889d02c1dd7f81338946575bbad3efb049e8177a", size = 20308, upload-time = "2026-05-30T12:12:23.88Z" }, + { url = "https://files.pythonhosted.org/packages/0a/64/c4e2f9a4f92f4d2b84c0e213b4a9410968b5f181f15a764eeb43f92c4eb2/pyobjc_framework_libxpc-12.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:635520187a6456ad259e40dd04829caeef08561d0a1a0cfd09787ebd281d47b3", size = 19729, upload-time = "2025-11-14T09:53:19.038Z" }, + { url = "https://files.pythonhosted.org/packages/51/c2/654dd2a22b6f505ff706a66117c522029df9449a9a19ca4827af0d16b5b3/pyobjc_framework_libxpc-12.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:1c36e3e109a95275f90b319161265a7f6a5e0e674938ce49babdf3a64d9fc892", size = 20309, upload-time = "2025-11-14T09:53:22.657Z" }, ] [[package]] name = "pyobjc-framework-linkpresentation" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-cocoa" }, { name = "pyobjc-framework-quartz" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/b9/20/a55fa5ca6fbeb0a0b00515f4aa37cdb946e36fbaba8c8bef6c47774c10b4/pyobjc_framework_linkpresentation-12.2.tar.gz", hash = "sha256:bb910f692f3166d6c5fce44f501a4d64a6067bac9bc26ec9488995fae56bfe6d", size = 13988, upload-time = "2026-05-30T12:39:14.136Z" } +sdist = { url = "https://files.pythonhosted.org/packages/e3/58/c0c5919d883485ccdb6dccd8ecfe50271d2f6e6ab7c9b624789235ccec5a/pyobjc_framework_linkpresentation-12.1.tar.gz", hash = "sha256:84df6779591bb93217aa8bd82c10e16643441678547d2d73ba895475a02ade94", size = 13330, upload-time = "2025-11-14T10:16:52.169Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/8e/42/264d202bd16bb6d8b2820c4a0d3eb1267add1c94aef68aeb749927dfff52/pyobjc_framework_linkpresentation-12.2-py2.py3-none-any.whl", hash = "sha256:68f854b4b72fef3477f1fb6604b258207a5950164e8e278330cd4848281eafee", size = 3864, upload-time = "2026-05-30T12:12:33.935Z" }, + { url = "https://files.pythonhosted.org/packages/ad/51/226eb45f196f3bf93374713571aae6c8a4760389e1d9435c4a4cc3f38ea4/pyobjc_framework_linkpresentation-12.1-py2.py3-none-any.whl", hash = "sha256:853a84c7b525b77b114a7a8d798aef83f528ed3a6803bda12184fe5af4e79a47", size = 3865, upload-time = "2025-11-14T09:53:28.386Z" }, ] [[package]] name = "pyobjc-framework-localauthentication" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-cocoa" }, { name = "pyobjc-framework-security" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/3b/bb/68ff2b154ed783d39a1752cbbb7dc9d0ce55c17097dc00fe56d9080c6349/pyobjc_framework_localauthentication-12.2.tar.gz", hash = "sha256:e1d734db5ddf35093307e213115bd122ef8712463be048eabfa4062022373e21", size = 33074, upload-time = "2026-05-30T12:39:16.945Z" } +sdist = { url = "https://files.pythonhosted.org/packages/8d/0e/7e5d9a58bb3d5b79a75d925557ef68084171526191b1c0929a887a553d4f/pyobjc_framework_localauthentication-12.1.tar.gz", hash = "sha256:2284f587d8e1206166e4495b33f420c1de486c36c28c4921d09eec858a699d05", size = 29947, upload-time = "2025-11-14T10:16:54.923Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/09/28/23c4a20e97d06854248625f53b30543340c17e478e9d6850cbee9ea50736/pyobjc_framework_localauthentication-12.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:38eab810ace8b5cd5aac593b8f0db99a9851a47e7310e0a010eb33d37043da30", size = 10895, upload-time = "2026-05-30T12:12:41.218Z" }, - { url = "https://files.pythonhosted.org/packages/0c/05/4b988f1e0f70b404b3e6ee0b0f63e9a368efb2a17c8b900e57992c126b2c/pyobjc_framework_localauthentication-12.2-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:3b7ad8257cd372950463a4d6fe2f0b5ab14891ca756a8547c3fdb1b3236ec9ca", size = 11042, upload-time = "2026-05-30T12:12:42.808Z" }, + { url = "https://files.pythonhosted.org/packages/e4/f5/a12c76525e4839c7fc902c6b0f0c441414a4dd9bc9a2d89ae697f6cd8850/pyobjc_framework_localauthentication-12.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:e26e746717f4774cce0568debec711f1d8effc430559ad634ff6b06fefd0a0bf", size = 10792, upload-time = "2025-11-14T09:53:35.876Z" }, + { url = "https://files.pythonhosted.org/packages/5c/ed/2714934b027afc6a99d0d817e42bf482d08c711422795fe777e3cd9ad8be/pyobjc_framework_localauthentication-12.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:02357cddc979aa169782bf09f380aab1c3af475c9eb6ffb07c77084ed10f6a6a", size = 10931, upload-time = "2025-11-14T09:53:37.672Z" }, ] [[package]] name = "pyobjc-framework-localauthenticationembeddedui" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-cocoa" }, { name = "pyobjc-framework-localauthentication" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/a3/93/a9d21a00896d016924d1912f2dd8918f8aa95ac0893c2b110cadc779a16a/pyobjc_framework_localauthenticationembeddedui-12.2.tar.gz", hash = "sha256:cff4e489375b3898f34d8ab378f8d84623ab19e89a35de958825c125aafceca6", size = 14134, upload-time = "2026-05-30T12:39:18.692Z" } +sdist = { url = "https://files.pythonhosted.org/packages/31/20/83ab4180e29b9a4a44d735c7f88909296c6adbe6250e8e00a156aff753e1/pyobjc_framework_localauthenticationembeddedui-12.1.tar.gz", hash = "sha256:a15ec44bf2769c872e86c6b550b6dd4f58d4eda40ad9ff00272a67d279d1d4e9", size = 13611, upload-time = "2025-11-14T10:16:57.145Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/5d/94/2e453acd660d9e1e059269c72a95b9f1f2de4a3b7a5dc0f6d6cdfd0eed5e/pyobjc_framework_localauthenticationembeddedui-12.2-py2.py3-none-any.whl", hash = "sha256:0b306917aa011deb364e85c118624d2d80c3eaf67016a345a6c4bc4960416b11", size = 3985, upload-time = "2026-05-30T12:12:51.194Z" }, + { url = "https://files.pythonhosted.org/packages/30/7d/0d46639c7a26b6af928ab4c822cd28b733791e02ac28cc84c3014bcf7dc7/pyobjc_framework_localauthenticationembeddedui-12.1-py2.py3-none-any.whl", hash = "sha256:a7ce7b56346597b9f4768be61938cbc8fc5b1292137225b6c7f631b9cde97cd7", size = 3991, upload-time = "2025-11-14T09:53:42.958Z" }, ] [[package]] name = "pyobjc-framework-mailkit" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-cocoa" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/0d/44/b8fc4dec34b6f29a98f64f38eb6f37e9729aeee4d2e90887a9ece06010eb/pyobjc_framework_mailkit-12.2.tar.gz", hash = "sha256:e29ea94210faefc46a4aefe0c1647bfb77b42cfc2a4962fb8316cb967b34c47f", size = 23870, upload-time = "2026-05-30T12:39:21.115Z" } +sdist = { url = "https://files.pythonhosted.org/packages/2a/98/3d9028620c1cd32ff4fb031155aba3b5511e980cdd114dd51383be9cb51b/pyobjc_framework_mailkit-12.1.tar.gz", hash = "sha256:d5574b7259baec17096410efcaacf5d45c7bb5f893d4c25cbb7072369799b652", size = 20996, upload-time = "2025-11-14T10:16:59.449Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/b9/95/2b4b95d7e5e43750631596da4ee8de4800883475864ca9f169881fbefb3b/pyobjc_framework_mailkit-12.2-py2.py3-none-any.whl", hash = "sha256:25b9aa8c513c40d931a7c5cc44571fd090e3d565f2e1153a634f6980b08da733", size = 4994, upload-time = "2026-05-30T12:12:52.648Z" }, + { url = "https://files.pythonhosted.org/packages/70/8d/3c968b736a3a8bd9d8e870b39b1c772a013eea1b81b89fc4efad9021a6cb/pyobjc_framework_mailkit-12.1-py2.py3-none-any.whl", hash = "sha256:536ac0c4ea3560364cd159a6512c3c18a744a12e4e0883c07df0f8a2ff21e3fe", size = 4871, upload-time = "2025-11-14T09:53:44.697Z" }, ] [[package]] name = "pyobjc-framework-mapkit" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, @@ -5132,28 +5153,28 @@ dependencies = [ { name = "pyobjc-framework-corelocation" }, { name = "pyobjc-framework-quartz" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/74/6b/0f3d14cd1b6f3d30420e268fe6b97f6ab55f1717a4c436ac6e57576c480f/pyobjc_framework_mapkit-12.2.tar.gz", hash = "sha256:65fdf104bd8a1d3e8965c689446b7e42a44ea4bc2da5c871ff389ef7a14ee030", size = 79554, upload-time = "2026-05-30T12:39:26.639Z" } +sdist = { url = "https://files.pythonhosted.org/packages/36/bb/2a668203c20e509a648c35e803d79d0c7f7816dacba74eb5ad8acb186790/pyobjc_framework_mapkit-12.1.tar.gz", hash = "sha256:dbc32dc48e821aaa9b4294402c240adbc1c6834e658a07677b7c19b7990533c5", size = 63520, upload-time = "2025-11-14T10:17:04.221Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/1f/23/649ecd0f1b7092390d5012bfccf0d653840a002c215fe5c7b1d0e1ffb069/pyobjc_framework_mapkit-12.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:4dc30cdae3b30869488ffa936d1bba327b6454809dc1d584083a8033637ab7f3", size = 22867, upload-time = "2026-05-30T12:13:02.802Z" }, - { url = "https://files.pythonhosted.org/packages/a6/ee/d9a3b6a982a3e7fd04d06d1da9627c76b08c7107e46fff217f35a60f0350/pyobjc_framework_mapkit-12.2-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:4245ce0af24948471eca1da30dac432712fb11ce0f65100420bfd74d176359bc", size = 23038, upload-time = "2026-05-30T12:13:05.233Z" }, + { url = "https://files.pythonhosted.org/packages/5e/f1/db2aa9fa44669b9c060a3ae02d5661052a05868ccba1674543565818fdaf/pyobjc_framework_mapkit-12.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:ea210ba88bef2468adb5c8303071d86118d630bf37a29d28cf236c13c3bb85ad", size = 22539, upload-time = "2025-11-14T09:53:55.543Z" }, + { url = "https://files.pythonhosted.org/packages/c1/e4/7dd9f7333eea7f4666274f568cac03e4687b442c9b20622f244497700177/pyobjc_framework_mapkit-12.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:dfee615b73bb687101f08e7fd839eea2aa8b241563ad4cabbcb075d12f598266", size = 22712, upload-time = "2025-11-14T09:53:58.159Z" }, ] [[package]] name = "pyobjc-framework-mediaaccessibility" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-cocoa" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/02/63/34d6f7af511b116dca7761385b7462eda9f39641a9ead9eb1404d621e571/pyobjc_framework_mediaaccessibility-12.2.tar.gz", hash = "sha256:9036a6412bce491b8ca477d4673b6e441cbf2cb2463d617f82bed818c5bde9d7", size = 17239, upload-time = "2026-05-30T12:39:28.7Z" } +sdist = { url = "https://files.pythonhosted.org/packages/e0/10/dc1007e56944ed2e981e69e7b2fed2b2202c79b0d5b742b29b1081d1cbdd/pyobjc_framework_mediaaccessibility-12.1.tar.gz", hash = "sha256:cc4e3b1d45e84133d240318d53424eff55968f5c6873c2c53267598853445a3f", size = 16325, upload-time = "2025-11-14T10:17:07.454Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/3d/b9/fb53b336b9d6233ca96e53aec4ea142d49b225f846bbd9e13353477f118b/pyobjc_framework_mediaaccessibility-12.2-py2.py3-none-any.whl", hash = "sha256:2e1d023c738ef09ed57635ae277b3644a09d7313e6bb979ee1c6d68bae57e4a8", size = 4822, upload-time = "2026-05-30T12:13:16.428Z" }, + { url = "https://files.pythonhosted.org/packages/a2/0c/7fb5462561f59d739192c6d02ba0fd36ad7841efac5a8398a85a030ef7fc/pyobjc_framework_mediaaccessibility-12.1-py2.py3-none-any.whl", hash = "sha256:2ff8845c97dd52b0e5cf53990291e6d77c8a73a7aac0e9235d62d9a4256916d1", size = 4800, upload-time = "2025-11-14T09:54:05.04Z" }, ] [[package]] name = "pyobjc-framework-mediaextension" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, @@ -5161,276 +5182,276 @@ dependencies = [ { name = "pyobjc-framework-cocoa" }, { name = "pyobjc-framework-coremedia" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/60/db/c3c4a933685423d16f69daf8a0dbe026fd45a05e0988ed4842dc2a286097/pyobjc_framework_mediaextension-12.2.tar.gz", hash = "sha256:9affa99bd94774ed91f3fc9f314468b4dc3bc6fc110ee8a81884d3947a9ced12", size = 44550, upload-time = "2026-05-30T12:39:32.301Z" } +sdist = { url = "https://files.pythonhosted.org/packages/d6/aa/1e8015711df1cdb5e4a0aa0ed4721409d39971ae6e1e71915e3ab72423a3/pyobjc_framework_mediaextension-12.1.tar.gz", hash = "sha256:44409d63cc7d74e5724a68e3f9252cb62fd0fd3ccf0ca94c6a33e5c990149953", size = 39425, upload-time = "2025-11-14T10:17:11.486Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/0e/8b/1576473cd8154bc5e2b36cf2f82bac60ad1223bc09145248639446bcfd18/pyobjc_framework_mediaextension-12.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:37e8a452f17db3bce2b50dec8a20b6851eed88906809d2361385c3b096751ff9", size = 39014, upload-time = "2026-05-30T12:13:30.015Z" }, - { url = "https://files.pythonhosted.org/packages/7a/31/473101b145d98dc738c021d66496149d38d2b57d746cf69a3665e5403dfc/pyobjc_framework_mediaextension-12.2-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:5326b3ca9f8ba0f2b51525829bc833f9c441980e3cf6628137e51a50d9e45cbf", size = 39221, upload-time = "2026-05-30T12:13:33.332Z" }, + { url = "https://files.pythonhosted.org/packages/01/df/7ecdbac430d2d2844fb2145e26f3e87a8a7692fa669d0629d90f32575991/pyobjc_framework_mediaextension-12.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:0f3bdca0eb11923efc1e3b95beb1e6e01c675fd7809ed7ef0b475334e3562931", size = 38991, upload-time = "2025-11-14T09:54:20.316Z" }, + { url = "https://files.pythonhosted.org/packages/fc/98/88ac2edeb69bde3708ef3f7b6434f810ba89321d8375914ad642c9a575b0/pyobjc_framework_mediaextension-12.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:0101b8495051bac9791a0488530386eefe9c722477a5239c5bd208967d0eaa67", size = 39198, upload-time = "2025-11-14T09:54:23.806Z" }, ] [[package]] name = "pyobjc-framework-medialibrary" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-cocoa" }, { name = "pyobjc-framework-quartz" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/50/44/ec97fab19e92f5d41c4e0f333bcd54f1f76a255406eadd93a95d753da711/pyobjc_framework_medialibrary-12.2.tar.gz", hash = "sha256:9b65eb789cf10b20f2c5bc4d5f4e61e5feb02a43bc213ac3c03b647e30b96634", size = 19019, upload-time = "2026-05-30T12:39:34.305Z" } +sdist = { url = "https://files.pythonhosted.org/packages/34/e9/848ebd02456f8fdb41b42298ec585bfed5899dbd30306ea5b0a7e4c4b341/pyobjc_framework_medialibrary-12.1.tar.gz", hash = "sha256:690dcca09b62511df18f58e8566cb33d9652aae09fe63a83f594bd018b5edfcd", size = 15995, upload-time = "2025-11-14T10:17:15.45Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/1d/ee/8583d8c8a738e13f3e70bfb84ad70aab17f2995af55ece36780c1acbfdd1/pyobjc_framework_medialibrary-12.2-py2.py3-none-any.whl", hash = "sha256:3bc97cb03e633a3f6f0a4e9d351210000100ebd1a4b19624c49c4e9bc7b5e574", size = 4357, upload-time = "2026-05-30T12:13:48.479Z" }, + { url = "https://files.pythonhosted.org/packages/c2/cd/eeaf8585a343fda5b8cf3b8f144c872d1057c845202098b9441a39b76cb0/pyobjc_framework_medialibrary-12.1-py2.py3-none-any.whl", hash = "sha256:1f03ad6802a5c6e19ee3208b065689d3ec79defe1052cb80e00f54e1eff5f2a0", size = 4361, upload-time = "2025-11-14T09:54:32.259Z" }, ] [[package]] name = "pyobjc-framework-mediaplayer" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-avfoundation" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/c0/c0/aec081f84830e483e23a1763339c9c6ef9bd868d44d9aa39a83080b0ac29/pyobjc_framework_mediaplayer-12.2.tar.gz", hash = "sha256:ee4f818a85e89a4c691e368b2709709d11658b81713fe367342af24dba2c5e62", size = 42669, upload-time = "2026-05-30T12:39:37.577Z" } +sdist = { url = "https://files.pythonhosted.org/packages/e9/f0/851f6f47e11acbd62d5f5dcb8274afc969135e30018591f75bf3cbf6417f/pyobjc_framework_mediaplayer-12.1.tar.gz", hash = "sha256:5ef3f669bdf837d87cdb5a486ec34831542360d14bcba099c7c2e0383380794c", size = 35402, upload-time = "2025-11-14T10:17:18.97Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/1f/89/a12bf5f69920b8909cf92b3e7722082600db4262293d5b878b58eaae8f7a/pyobjc_framework_mediaplayer-12.2-py2.py3-none-any.whl", hash = "sha256:436d3b410b84c7fa6577c4774faa4acc4bd3ca79f582b183e281ca63429a1574", size = 7176, upload-time = "2026-05-30T12:13:50.134Z" }, + { url = "https://files.pythonhosted.org/packages/58/c0/038ee3efd286c0fbc89c1e0cb688f4670ed0e5803aa36e739e79ffc91331/pyobjc_framework_mediaplayer-12.1-py2.py3-none-any.whl", hash = "sha256:85d9baec131807bfdf0f4c24d4b943e83cce806ab31c95c7e19c78e3fb7eefc8", size = 7120, upload-time = "2025-11-14T09:54:33.901Z" }, ] [[package]] name = "pyobjc-framework-mediatoolbox" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-cocoa" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/3f/6e/5181efc8c1a077599ab5ac1cb2263ebb43b1603ed994e486f8a983d2e694/pyobjc_framework_mediatoolbox-12.2.tar.gz", hash = "sha256:35fbaa7df491df5b756da1ad2035f0f04f72e556a560cdd9a6ef74ce315c555a", size = 22818, upload-time = "2026-05-30T12:39:39.837Z" } +sdist = { url = "https://files.pythonhosted.org/packages/a3/71/be5879380a161f98212a336b432256f307d1dcbaaaeb8ec988aea2ada2cd/pyobjc_framework_mediatoolbox-12.1.tar.gz", hash = "sha256:385b48746a5f08756ee87afc14037e552954c427ed5745d7ece31a21a7bad5ab", size = 22305, upload-time = "2025-11-14T10:17:22.501Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/ea/5c/3bdcef52f234ce16c9b06aabfac43caeeea68a5068425bdd510e6277c256/pyobjc_framework_mediatoolbox-12.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:13cca0632cbb91f5c207ec6a9001aebb4bdd1077d3753a5bc7fef7f82c3e9a57", size = 12832, upload-time = "2026-05-30T12:13:57.732Z" }, - { url = "https://files.pythonhosted.org/packages/a2/6b/8ca72d9579f84560f5a648973032757e5b0c61bf1eb74e763bdca6913ef7/pyobjc_framework_mediatoolbox-12.2-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:5b876927d92fb35f6ca6a5c8e030cb853a8b5c68add7d59ebec4ae4358a1f5af", size = 13419, upload-time = "2026-05-30T12:13:59.497Z" }, + { url = "https://files.pythonhosted.org/packages/ca/30/79aa0010b30f3c54c68673d00f06f45ef28f5093ff1e927d68b5376ea097/pyobjc_framework_mediatoolbox-12.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:1529a754cdb5b32797d297c0bf6279c7c14a3f7088f2dfbded09edcbfda19838", size = 12830, upload-time = "2025-11-14T09:54:43.191Z" }, + { url = "https://files.pythonhosted.org/packages/da/26/ae890f8ecce3fdda3e3a518426665467d36945c7c2729da1b073b1c44ff6/pyobjc_framework_mediatoolbox-12.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:13afec7d9f094ca5642e32b98680d1ee59aaa11a3d694cb1a6e454f72003f51c", size = 13420, upload-time = "2025-11-14T09:54:45.133Z" }, ] [[package]] name = "pyobjc-framework-metal" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-cocoa" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/71/a9/ff281c31ce7d0cb819af1989b77258b2d8cffc0b9fad47fcdd39043f4d81/pyobjc_framework_metal-12.2.tar.gz", hash = "sha256:4fb2cfd42cc8e808f08f1f2fe57de713734dd2f495c666296b2c8a5fba9be6dc", size = 238106, upload-time = "2026-05-30T12:39:54.526Z" } +sdist = { url = "https://files.pythonhosted.org/packages/e7/06/a84f7eb8561d5631954b9458cfca04b690b80b5b85ce70642bc89335f52a/pyobjc_framework_metal-12.1.tar.gz", hash = "sha256:bb554877d5ee2bf3f340ad88e8fe1b85baab7b5ec4bd6ae0f4f7604147e3eae7", size = 181847, upload-time = "2025-11-14T10:17:34.157Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/dd/90/f3832396e967ae149b480ebf31da0ab7b033c145b15274b2bd5357d8faf5/pyobjc_framework_metal-12.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:538826eb6020e2d49e481f7ad390319dfa1016aeeac623f8b76bfe8aaec8a66f", size = 75935, upload-time = "2026-05-30T12:14:28.505Z" }, - { url = "https://files.pythonhosted.org/packages/ea/95/f36313fab765e90c8400c9423cc0f6af6fec96a919ad894b09681d0b4a88/pyobjc_framework_metal-12.2-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:b9a9ba61ab834ada0e23fe7d560cf01e6948a88a4aef3342c032683b795bc908", size = 76491, upload-time = "2026-05-30T12:14:33.968Z" }, + { url = "https://files.pythonhosted.org/packages/1c/aa/caa900c1fdb9a3b7e48946c5206171a7adcf3b5189bcdb535cf899220909/pyobjc_framework_metal-12.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:2f04a1a687cc346d23f3baf1ec56e3f42206709b590058d9778b52d45ca1c8ab", size = 75871, upload-time = "2025-11-14T09:55:13.008Z" }, + { url = "https://files.pythonhosted.org/packages/9c/a9/a42a173ea2d94071bc0f3112006a5d6ba7eaf0df9c48424f99b3e867e02d/pyobjc_framework_metal-12.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:3f3aa0848f4da46773952408b4814a440b210dc3f67f5ec5cfc0156ca2c8c0b6", size = 76420, upload-time = "2025-11-14T09:55:18.985Z" }, ] [[package]] name = "pyobjc-framework-metalfx" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-metal" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/87/06/e29f5153fce867015298a9b0b0365777004ff5f4e5276728135afc496269/pyobjc_framework_metalfx-12.2.tar.gz", hash = "sha256:46774b9c938f2af40510a787be291dbc0c7e3778494704489e728fc349183244", size = 33397, upload-time = "2026-05-30T12:39:57.533Z" } +sdist = { url = "https://files.pythonhosted.org/packages/f1/09/ce5c74565677fde66de3b9d35389066b19e5d1bfef9d9a4ad80f0c858c0c/pyobjc_framework_metalfx-12.1.tar.gz", hash = "sha256:1551b686fb80083a97879ce0331bdb1d4c9b94557570b7ecc35ebf40ff65c90b", size = 29470, upload-time = "2025-11-14T10:17:37.16Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/c8/10/40bd25526328be5bb7aa14b481146fee3dbb1271662b5b69112f47f2833e/pyobjc_framework_metalfx-12.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:8f079710065e4f4628c34a2528b0dd868c9d16e3af58230d5f18f6bd22d2ee74", size = 15072, upload-time = "2026-05-30T12:15:04.464Z" }, - { url = "https://files.pythonhosted.org/packages/46/d7/5189782d95c4790b704f70dff50951c183e0567aa53fd4892ccbc91b6f8b/pyobjc_framework_metalfx-12.2-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:40c7e259991c04f5520c4c40eea02810c50812f2bac2c5ff845828a35d99ccbe", size = 15286, upload-time = "2026-05-30T12:15:06.581Z" }, + { url = "https://files.pythonhosted.org/packages/02/b6/baa6071a36962e11c8834d8d13833509ce7ecb63e5c79fe2718d153a8312/pyobjc_framework_metalfx-12.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:d443b0ee06de1b21a3ec5adab315840e71d52a74f8585090200228ab2fa1e59d", size = 15073, upload-time = "2025-11-14T09:55:39.436Z" }, + { url = "https://files.pythonhosted.org/packages/42/d1/b4ea7e6c0c66710db81f315c48dca0252ed81bbde4a41de21b8d54ff2241/pyobjc_framework_metalfx-12.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:dcd334b42c5c50ec88e049f1b0bf43544b52e3ac09fd57b712fec8f63507190e", size = 15286, upload-time = "2025-11-14T09:55:41.642Z" }, ] [[package]] name = "pyobjc-framework-metalkit" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-cocoa" }, { name = "pyobjc-framework-metal" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/14/48/3bbf8a296054633a8a297549c919b3ff6f53c469bdcb0046d31fd7c92ee4/pyobjc_framework_metalkit-12.2.tar.gz", hash = "sha256:0f6379b74d64ce9cb864476caa277ab5010da3b0779b7fdc94af7da25f013a1a", size = 28168, upload-time = "2026-05-30T12:39:59.991Z" } +sdist = { url = "https://files.pythonhosted.org/packages/14/15/5091147aae12d4011a788b93971c3376aaaf9bf32aa935a2c9a06a71e18b/pyobjc_framework_metalkit-12.1.tar.gz", hash = "sha256:14cc5c256f0e3471b412a5b3582cb2a0d36d3d57401a8aa09e433252d1c34824", size = 25473, upload-time = "2025-11-14T10:17:39.721Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/1d/3d/982672d8b3b97e59214b85e694482f8d4b373d540f3d4eb1ad27c7763b0b/pyobjc_framework_metalkit-12.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:d1f1e352621d5e89a2066f992a2b03091d180fd4ee3b6c7b58b432e22d76641b", size = 8795, upload-time = "2026-05-30T12:15:21.571Z" }, - { url = "https://files.pythonhosted.org/packages/87/24/163bbd1c430a7c6adfec59ad92c3f1ec7f3de0ab6739e2f5839edf90f8c5/pyobjc_framework_metalkit-12.2-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:a855935379ededd36ab55507af01b796b845a0acad7dddcff9d9f305fd903b82", size = 8939, upload-time = "2026-05-30T12:15:23.113Z" }, + { url = "https://files.pythonhosted.org/packages/2b/cd/f04e991f4db4512e64ea7611796141c316506e733d75c468512df0e8fda4/pyobjc_framework_metalkit-12.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:4dec94431ee888682115fe88ae72fca8bffc5df0957e3c006777c1d8267f65c3", size = 8769, upload-time = "2025-11-14T09:55:53.318Z" }, + { url = "https://files.pythonhosted.org/packages/b7/b8/6f2fc56b6f8aee222d584edbdef4cf300e90782813e315418eba6d395533/pyobjc_framework_metalkit-12.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:d16958c0d4e2a75e1ea973de8951c775da1e39e378a7a7762fbce1837bf3179c", size = 8922, upload-time = "2025-11-14T09:55:55.016Z" }, ] [[package]] name = "pyobjc-framework-metalperformanceshaders" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-metal" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/ad/77/9675e6e2ea06d693a75586c4194630c4346e6661bcf9c9299353dde1edf3/pyobjc_framework_metalperformanceshaders-12.2.tar.gz", hash = "sha256:f428f762bcf552f1a8f5533508ae4c73057a7f4f4a93bc997a921edec63b51e6", size = 190423, upload-time = "2026-05-30T12:40:11.806Z" } +sdist = { url = "https://files.pythonhosted.org/packages/c5/68/58da38e54aa0d8c19f0d3084d8c84e92d54cc8c9254041f07119d86aa073/pyobjc_framework_metalperformanceshaders-12.1.tar.gz", hash = "sha256:b198e755b95a1de1525e63c3b14327ae93ef1d88359e6be1ce554a3493755b50", size = 137301, upload-time = "2025-11-14T10:17:49.554Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/50/f6/2eaf4c358eb9684b13a08f73239c654029805da1be0ae5052ac0e15fafc5/pyobjc_framework_metalperformanceshaders-12.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:ac154ee0c5bd0c715d2b837689a070b811994a772b209784907730793b725012", size = 34176, upload-time = "2026-05-30T12:15:42.108Z" }, - { url = "https://files.pythonhosted.org/packages/e0/f4/f134c898df89217ae3d07d364c75ac67048dd9106a164d7dcda52f83e5c6/pyobjc_framework_metalperformanceshaders-12.2-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:18cda4e2ed06da0caebb11fa54596e273e8d50cdbf243aa1d34fa347da71db77", size = 34374, upload-time = "2026-05-30T12:15:45.258Z" }, + { url = "https://files.pythonhosted.org/packages/e9/6c/8f3d81905ce6b0613fe364a6dd77bf4ed85a6350f867b40a5e99b69e8d07/pyobjc_framework_metalperformanceshaders-12.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:240321f2fad1555b5ede3aed938c9f37da40a57fc3e7e9c96a45658dc12c3771", size = 33269, upload-time = "2025-11-14T09:56:12.527Z" }, + { url = "https://files.pythonhosted.org/packages/58/44/4813f8606a91a88f67a0b0c02ed9e2449cbfd5b701f7ca61cf9ce3fe0769/pyobjc_framework_metalperformanceshaders-12.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:0aa287ee357fe5bd5660b3d0688f947a768cda8565dbbca3b876307b9876639e", size = 33457, upload-time = "2025-11-14T09:56:15.72Z" }, ] [[package]] name = "pyobjc-framework-metalperformanceshadersgraph" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-metalperformanceshaders" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/e3/95/c274ffa29063e6f331a2d7d6942610ea2dc1e1984c647e68aff0f93e35b3/pyobjc_framework_metalperformanceshadersgraph-12.2.tar.gz", hash = "sha256:16249c5cd8d8403b5d81b871b618fdc0a8af0d7c81b461e733c0b5c1f9a9ef80", size = 60209, upload-time = "2026-05-30T12:40:16.281Z" } +sdist = { url = "https://files.pythonhosted.org/packages/a7/56/7ad0cd085532f7bdea9a8d4e9a2dfde376d26dd21e5eabdf1a366040eff8/pyobjc_framework_metalperformanceshadersgraph-12.1.tar.gz", hash = "sha256:b8fd017b47698037d7b172d41bed7a4835f4c4f2a288235819d200005f89ee35", size = 42992, upload-time = "2025-11-14T10:17:53.502Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/0b/ca/173cf282b48c454dac9ef40f96b0e5338077803f3fbf0f07c09333d3a9aa/pyobjc_framework_metalperformanceshadersgraph-12.2-py2.py3-none-any.whl", hash = "sha256:e465d7717df4b000e3a529054cdf547e50e175f321b53c9520bcd6c69c08c837", size = 7110, upload-time = "2026-05-30T12:15:59.125Z" }, + { url = "https://files.pythonhosted.org/packages/e2/c9/5e7fd0d4bc9bdf7b442f36e020677c721ba9b4c1dc1fa3180085f22a4ef9/pyobjc_framework_metalperformanceshadersgraph-12.1-py2.py3-none-any.whl", hash = "sha256:85a1c7a6114ada05c7924b3235a1a98c45359410d148097488f15aee5ebb6ab9", size = 6481, upload-time = "2025-11-14T09:56:23.66Z" }, ] [[package]] name = "pyobjc-framework-metrickit" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-cocoa" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/00/7e/b880dd8c641abbc0807d75396132df80d7d9cb0d64006b078c7f2e169fb8/pyobjc_framework_metrickit-12.2.tar.gz", hash = "sha256:c76cae82489813ca121de0ad6013555aa826f8742adf975028b3e4268ac51e6c", size = 30585, upload-time = "2026-05-30T12:40:19.065Z" } +sdist = { url = "https://files.pythonhosted.org/packages/ba/13/5576ddfbc0b174810a49171e2dbe610bdafd3b701011c6ecd9b3a461de8a/pyobjc_framework_metrickit-12.1.tar.gz", hash = "sha256:77841daf6b36ba0c19df88545fd910c0516acf279e6b7b4fa0a712a046eaa9f1", size = 27627, upload-time = "2025-11-14T10:17:56.353Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/2e/7a/224f8a506539197efb51df3aa84b269262ee14a6a4ecf9ac08d7267dbb54/pyobjc_framework_metrickit-12.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:db64bd8d99011d67edb16bdb0f923191d95649ee7bc4a276d4f2516e975ec780", size = 8128, upload-time = "2026-05-30T12:16:05.825Z" }, - { url = "https://files.pythonhosted.org/packages/71/c8/a112d3aa27eb2749d1308122b40fb1b45947199034e37ee5d86759eaeff7/pyobjc_framework_metrickit-12.2-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:eb146093ab8ec597e74307ece22c572b3654a4247d6e0d0fd3f4635f0166286e", size = 8267, upload-time = "2026-05-30T12:16:07.3Z" }, + { url = "https://files.pythonhosted.org/packages/f1/e0/8b379325acb39e0966f818106b3c3c8e3966bf87a7ab5c2d0e89753b0d1f/pyobjc_framework_metrickit-12.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:884afb6ec863883318975fda38db9d741b8da5f64a2b8c34bf8edc5ff56019d4", size = 8131, upload-time = "2025-11-14T09:56:30.524Z" }, + { url = "https://files.pythonhosted.org/packages/86/67/dcd2b18a787d3fec89e372aadb83c01879dda24fe1ed2a333a5e1d388591/pyobjc_framework_metrickit-12.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:37674b0e049035d8b32d0221d0afbfedd3f643e4a2ee74b9a0e4e6d1b94fcd69", size = 8273, upload-time = "2025-11-14T09:56:32.128Z" }, ] [[package]] name = "pyobjc-framework-mlcompute" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-cocoa" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/98/32/72a3733b6f3b1c60a18acfa517d28f9bcfff9822a1e21298c50c30c1a944/pyobjc_framework_mlcompute-12.2.tar.gz", hash = "sha256:7a2108c89ccae06e0fa03b1ef08c37bd9fae0ea0727d8b5890254bf44347eeac", size = 55014, upload-time = "2026-05-30T12:40:23.347Z" } +sdist = { url = "https://files.pythonhosted.org/packages/00/69/15f8ce96c14383aa783c8e4bc1e6d936a489343bb197b8e71abb3ddc1cb8/pyobjc_framework_mlcompute-12.1.tar.gz", hash = "sha256:3281db120273dcc56e97becffd5cedf9c62042788289f7be6ea067a863164f1e", size = 40698, upload-time = "2025-11-14T10:17:59.792Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/0c/7f/44c69bb026a7ffc00686a51514b43d7fe1a09682997cabe7a39a016aad0b/pyobjc_framework_mlcompute-12.2-py2.py3-none-any.whl", hash = "sha256:18066ab867e02f5eb2cc66145b4274e6a7105e69165550356ec4a75937db1aae", size = 9622, upload-time = "2026-05-30T12:16:15.333Z" }, + { url = "https://files.pythonhosted.org/packages/ac/f7/4614b9ccd0151795e328b9ed881fbcbb13e577a8ec4ae3507edb1a462731/pyobjc_framework_mlcompute-12.1-py2.py3-none-any.whl", hash = "sha256:4f0fc19551d710a03dfc4c7129299897544ff8ea76db6c7539ecc2f9b2571bde", size = 6744, upload-time = "2025-11-14T09:56:36.973Z" }, ] [[package]] name = "pyobjc-framework-modelio" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-cocoa" }, { name = "pyobjc-framework-quartz" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/c0/42/ff2d205133a753bd95c937b4591559bd10417d88da7debcdb7ef22e00dcc/pyobjc_framework_modelio-12.2.tar.gz", hash = "sha256:3f492868aa12c7107e456238fc718cac0316e8d95f7680b7465e41918d72db2f", size = 83763, upload-time = "2026-05-30T12:40:29.309Z" } +sdist = { url = "https://files.pythonhosted.org/packages/b4/11/32c358111b623b4a0af9e90470b198fffc068b45acac74e1ba711aee7199/pyobjc_framework_modelio-12.1.tar.gz", hash = "sha256:d041d7bca7c2a4526344d3e593347225b7a2e51a499b3aa548895ba516d1bdbb", size = 66482, upload-time = "2025-11-14T10:18:04.92Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/57/92/6dc491a2ffe4c852c266d2a3430114fa0a4cee057930556adb5f27e4948c/pyobjc_framework_modelio-12.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:a2bcdc8079e4886dbee3c2351da5dfc53fe46d1d8e73a9a751085adce97a74ff", size = 20497, upload-time = "2026-05-30T12:16:24.585Z" }, - { url = "https://files.pythonhosted.org/packages/f7/f6/c4253cdf4ce3d2b55465805499deeecaff9230425366bdb9266c0e811736/pyobjc_framework_modelio-12.2-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:c7999915fad52b6578688d32ab4c761460237cb28b06dd663f81993fa6c4580e", size = 20738, upload-time = "2026-05-30T12:16:26.954Z" }, + { url = "https://files.pythonhosted.org/packages/db/fa/f111717fd64015fc3906b7c36dcfca4dda1d31916251c9640a8c70ff611a/pyobjc_framework_modelio-12.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:dad6e914b6efe8ea3d2cd10029c4eb838f1ad6a12344787e8db70c4149df8cfc", size = 20208, upload-time = "2025-11-14T09:56:46.627Z" }, + { url = "https://files.pythonhosted.org/packages/58/d3/6f3131a16694684f3dfa6b2845054941dfb69a63f18980eea02a25c06f6d/pyobjc_framework_modelio-12.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:f00b739f9333d611e7124acf95491bdf025dd32ba7c48b7521f6845b92e2dcce", size = 20448, upload-time = "2025-11-14T09:56:49.184Z" }, ] [[package]] name = "pyobjc-framework-multipeerconnectivity" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-cocoa" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/a7/a5/3112f721c54e1a09d12d8dc48b165ff51a1147783d8d63a53e1da5b603ca/pyobjc_framework_multipeerconnectivity-12.2.tar.gz", hash = "sha256:7a5879cb83e9a7ea8c8d9e7e11ed3de4c9d67046e6c330b8a5f6332339f631a6", size = 26444, upload-time = "2026-05-30T12:40:31.848Z" } +sdist = { url = "https://files.pythonhosted.org/packages/87/35/0d0bb6881004cb238cfd7bf74f4b2e42601a1accdf27b2189ec61cf3a2dc/pyobjc_framework_multipeerconnectivity-12.1.tar.gz", hash = "sha256:7123f734b7174cacbe92a51a62b4645cc9033f6b462ff945b504b62e1b9e6c1c", size = 22816, upload-time = "2025-11-14T10:18:07.363Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/8f/50/4080a78aaa2fe925dd2473fde41f650e3433cbc658c062d09b3658e181a0/pyobjc_framework_multipeerconnectivity-12.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:ff0c6305c3b573d97f217a69b8b82b9075d788a82768377a07a456114bec248d", size = 12018, upload-time = "2026-05-30T12:16:43.467Z" }, - { url = "https://files.pythonhosted.org/packages/2c/75/50488445848adbac42d752d99d126913dadf5e7026aaf28d83c836b6f788/pyobjc_framework_multipeerconnectivity-12.2-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:5f5de878761b5e1cec4566df0aef13143845a83e4d12c80faeaefd308fd919c4", size = 12198, upload-time = "2026-05-30T12:16:45.195Z" }, + { url = "https://files.pythonhosted.org/packages/93/65/589cf3abaec888878d9b86162e5e622d4d467fd88a5f55320f555484dd54/pyobjc_framework_multipeerconnectivity-12.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:25169a2fded90d13431db03787ac238b4ed551c44f7656996f8dfb6b6986b997", size = 12019, upload-time = "2025-11-14T09:57:02.86Z" }, + { url = "https://files.pythonhosted.org/packages/0e/77/c184a36ba61d803d482029021410568b0a2155b5bf0dd2def4256ab58a1e/pyobjc_framework_multipeerconnectivity-12.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:3a6c2d233ecda3127bd6b6ded289ef0d1fa6ddc3acbab7f8af996c96090f7bfc", size = 12194, upload-time = "2025-11-14T09:57:04.63Z" }, ] [[package]] name = "pyobjc-framework-naturallanguage" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-cocoa" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/6a/1b/8fe870dd9ffed8943e72328fdd71df69363ea55037107882a3c11182edbe/pyobjc_framework_naturallanguage-12.2.tar.gz", hash = "sha256:f6980ba957bb24501bbe135ffcdd0ff149f33d30e965f033ad153df756b33cc7", size = 27251, upload-time = "2026-05-30T12:40:34.327Z" } +sdist = { url = "https://files.pythonhosted.org/packages/8a/d1/c81c0cdbb198d498edc9bc5fbb17e79b796450c17bb7541adbf502f9ad65/pyobjc_framework_naturallanguage-12.1.tar.gz", hash = "sha256:cb27a1e1e5b2913d308c49fcd2fd04ab5ea87cb60cac4a576a91ebf6a50e52f6", size = 23524, upload-time = "2025-11-14T10:18:09.883Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/f5/00/5923b25edd9d64ba7494cb8e28c1c073ec5cbb43a41eaa70bffa4b7a2862/pyobjc_framework_naturallanguage-12.2-py2.py3-none-any.whl", hash = "sha256:8c02a9ea25b888eefb0ac503211e17a9868a1781f5d5bf9c1655445abc14ffe2", size = 5436, upload-time = "2026-05-30T12:16:53.941Z" }, + { url = "https://files.pythonhosted.org/packages/ec/d8/715a11111f76c80769cb267a19ecf2a4ac76152a6410debb5a4790422256/pyobjc_framework_naturallanguage-12.1-py2.py3-none-any.whl", hash = "sha256:a02ef383ec88948ca28f03ab8995523726b3bc75c49f593b5c89c218bcbce7ce", size = 5320, upload-time = "2025-11-14T09:57:10.294Z" }, ] [[package]] name = "pyobjc-framework-netfs" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-cocoa" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/de/c8/e22988cf11df9b7c7da2ba04b7e9b9435fa7dc4ba3be7d6bb34d60f686eb/pyobjc_framework_netfs-12.2.tar.gz", hash = "sha256:fdb04ecc91864a4b79498a07f4d34f33b5dcae34958d555f5cbd69e20165991d", size = 15139, upload-time = "2026-05-30T12:40:36.186Z" } +sdist = { url = "https://files.pythonhosted.org/packages/46/68/4bf0e5b8cc0780cf7acf0aec54def58c8bcf8d733db0bd38f5a264d1af06/pyobjc_framework_netfs-12.1.tar.gz", hash = "sha256:e8d0c25f41d7d9ced1aa2483238d0a80536df21f4b588640a72e1bdb87e75c1e", size = 14799, upload-time = "2025-11-14T10:18:11.85Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/f8/c1/1584c42fc716ee13d085461913b59f5682fddd76b8094feb760477a8edab/pyobjc_framework_netfs-12.2-py2.py3-none-any.whl", hash = "sha256:864d09a7b671f4407ff577739949c98ae8ba9b013433cf938fb0c86319151248", size = 4161, upload-time = "2026-05-30T12:16:55.515Z" }, + { url = "https://files.pythonhosted.org/packages/7e/6b/8c2f223879edd3e3f030d0a9c9ba812775519c6d0c257e3e7255785ca6e7/pyobjc_framework_netfs-12.1-py2.py3-none-any.whl", hash = "sha256:0021f8b141e693d3821524c170e9c645090eb320e80c2935ddb978a6e8b8da81", size = 4163, upload-time = "2025-11-14T09:57:11.845Z" }, ] [[package]] name = "pyobjc-framework-network" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-cocoa" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/fd/a8/12fcf0341ff377600a102f48266ef85e67af9dc7d894ca40fb18dd8702bb/pyobjc_framework_network-12.2.tar.gz", hash = "sha256:99d7a1900d8250d008eb285b20792d14076eedd665749cb0f48e1e102056207a", size = 62275, upload-time = "2026-05-30T12:40:40.695Z" } +sdist = { url = "https://files.pythonhosted.org/packages/38/13/a71270a1b0a9ec979e68b8ec84b0f960e908b17b51cb3cac246a74d52b6b/pyobjc_framework_network-12.1.tar.gz", hash = "sha256:dbf736ff84d1caa41224e86ff84d34b4e9eb6918ae4e373a44d3cb597648a16a", size = 56990, upload-time = "2025-11-14T10:18:16.714Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/c6/b3/c99e31a29975fe58d81396105518d74cdd1b0de5f8d939e5a5892b7d95f7/pyobjc_framework_network-12.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:6677fac4bfe2d8ae320ffc069767c0e2ca7d50304ad3cf7a77d0a4d08d69465e", size = 19643, upload-time = "2026-05-30T12:17:04.223Z" }, - { url = "https://files.pythonhosted.org/packages/85/94/233e77df7b4b53aa0316346540ee1345ed6c2d5b1893fd10fe268e1d9a1c/pyobjc_framework_network-12.2-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:c198226431964487f1213ba17de69eddcaf5ddd1bea406b31c6845cc956da536", size = 19714, upload-time = "2026-05-30T12:17:06.29Z" }, + { url = "https://files.pythonhosted.org/packages/d1/f5/612539c2c0c7ce1160bd348325747f3a94ea367901965b217af877a556a1/pyobjc_framework_network-12.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:e341beb32c7f95ed3e38f00cfed0a9fe7f89b8d80679bf2bd97c1a8d2280180a", size = 19632, upload-time = "2025-11-14T09:57:21.762Z" }, + { url = "https://files.pythonhosted.org/packages/c6/ff/6a1909206f6d840ebcf40c9ea5de9a9ee07e7bb1ffa4fe573da7f90fac12/pyobjc_framework_network-12.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:8344e3b57afccc762983e4629ec5eff72a3d7292afa8169a3e2aada3348848a8", size = 19696, upload-time = "2025-11-14T09:57:23.948Z" }, ] [[package]] name = "pyobjc-framework-networkextension" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-cocoa" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/11/f0/bf65ac7714c81159f295d9386d718c9a876fc212f8af54b6da22c2d2873a/pyobjc_framework_networkextension-12.2.tar.gz", hash = "sha256:45bc3e7966cb9fce997832960d8aaf324a187f84019e65fc4432c27046715f70", size = 81296, upload-time = "2026-05-30T12:40:46.374Z" } +sdist = { url = "https://files.pythonhosted.org/packages/bf/3e/ac51dbb2efa16903e6af01f3c1f5a854c558661a7a5375c3e8767ac668e8/pyobjc_framework_networkextension-12.1.tar.gz", hash = "sha256:36abc339a7f214ab6a05cb2384a9df912f247163710741e118662bd049acfa2e", size = 62796, upload-time = "2025-11-14T10:18:21.769Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/3b/86/91d135890a83c021e2b031c467001802314a5b2c6aa1580669b1bf524060/pyobjc_framework_networkextension-12.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:631ca462cedf277531800e3cbdf6d4f98aac2dd2ce8512fc855076fa373d6725", size = 14467, upload-time = "2026-05-30T12:17:22.768Z" }, - { url = "https://files.pythonhosted.org/packages/85/d5/47debfb91e4f0c1bdbb1d4f433662cdc97e0467bf84379764be7dc26dfe3/pyobjc_framework_networkextension-12.2-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:1f9c7e7aa156d604a2c0764f65ef95131ff0c7724dd9ff35347d96b27836814c", size = 14611, upload-time = "2026-05-30T12:17:25.109Z" }, + { url = "https://files.pythonhosted.org/packages/cb/a8/5d847dd3ffea913597342982614eb17bad4c29c07fac3447b56c9c5136ab/pyobjc_framework_networkextension-12.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:63453b38e5a795f9ff950397e5a564071c2b4fd3360d79169ab017755bbb932a", size = 14399, upload-time = "2025-11-14T09:57:38.178Z" }, + { url = "https://files.pythonhosted.org/packages/b4/a8/8d56c6ca7826633f856924256761338094eeab1ae40783c29c14b9746bc9/pyobjc_framework_networkextension-12.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:e21d8ec762ded95afaff41b68425219df55ca8c3f777b810238441a4f7c221e3", size = 14539, upload-time = "2025-11-14T09:57:40.222Z" }, ] [[package]] name = "pyobjc-framework-notificationcenter" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-cocoa" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/e2/d4/62b27947aa2ff2228b49083245e622eb4840f68c58d6d3e89041f597b5dc/pyobjc_framework_notificationcenter-12.2.tar.gz", hash = "sha256:d7a20fd67851d91db142765aa823a5c60c03c37957cea310a4eaad37640c085e", size = 22134, upload-time = "2026-05-30T12:40:48.715Z" } +sdist = { url = "https://files.pythonhosted.org/packages/c6/12/ae0fe82fb1e02365c9fe9531c9de46322f7af09e3659882212c6bf24d75e/pyobjc_framework_notificationcenter-12.1.tar.gz", hash = "sha256:2d09f5ab9dc39770bae4fa0c7cfe961e6c440c8fc465191d403633dccc941094", size = 21282, upload-time = "2025-11-14T10:18:24.51Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/46/ac/2b2465db73f0340538df30728e5cc4a1c3014066651b091406cf2fe96e0e/pyobjc_framework_notificationcenter-12.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:d869a7689086ccb6f5c82a29684f38cbd2293e63a50fb8b06cec6151b497a73e", size = 9896, upload-time = "2026-05-30T12:17:39.78Z" }, - { url = "https://files.pythonhosted.org/packages/11/0d/bff8fbabbad5f0328852f0d9b7d87551b206c3c76ff9c5ecd863d7613643/pyobjc_framework_notificationcenter-12.2-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:db911fd4de68f52abda8e812799e87721092f78ac575ec50bff82018e1efb06a", size = 10088, upload-time = "2026-05-30T12:17:41.723Z" }, + { url = "https://files.pythonhosted.org/packages/44/9a/f2b627dd4631a0756ee3e99b57de1e78447081d11f10313ed198e7521a31/pyobjc_framework_notificationcenter-12.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:06470683f568803f55f1646accfbf5eaa3fda56d15f27fca31bdbff4eaa8796c", size = 9917, upload-time = "2025-11-14T09:57:53.001Z" }, + { url = "https://files.pythonhosted.org/packages/f4/f5/5fff664571dc48eea9246d31530fc564c654af827bfca1ddab47b72dc344/pyobjc_framework_notificationcenter-12.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:bdf87e5f027bec727b24bb1764a9933af9728862f6a0e9a7f4a1835061f283dd", size = 10110, upload-time = "2025-11-14T09:57:55.015Z" }, ] [[package]] name = "pyobjc-framework-opendirectory" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-cocoa" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/12/43/1c4b9f4e3739c3ab763f42b6e51ea74afebafefa5662b2740a6fb812697a/pyobjc_framework_opendirectory-12.2.tar.gz", hash = "sha256:e9edbe26c4d9aa533f343264d34af96fbef958d0c3a833acd2d64cf0fdb138e7", size = 69875, upload-time = "2026-05-30T12:40:53.704Z" } +sdist = { url = "https://files.pythonhosted.org/packages/5b/11/bc2f71d3077b3bd078dccad5c0c5c57ec807fefe3d90c97b97dd0ed3d04b/pyobjc_framework_opendirectory-12.1.tar.gz", hash = "sha256:2c63ce5dd179828ef2d8f9e3961da3bfa971a57db07a6c34eedc296548a928bb", size = 61049, upload-time = "2025-11-14T10:18:29.336Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/09/0d/6926ea3ba0f58e52e7a2260b416abd44c4680dc6c5c8e2212ccdd8d649cc/pyobjc_framework_opendirectory-12.2-py2.py3-none-any.whl", hash = "sha256:71d17cc1be29dd2ac50ae76fd654d233bed3b117854bf0ace021d8242a5a5566", size = 11910, upload-time = "2026-05-30T12:17:49.849Z" }, + { url = "https://files.pythonhosted.org/packages/d6/e7/3c2dece9c5b28af28a44d72a27b35ea5ffac31fed7cbd8d696ea75dc4a81/pyobjc_framework_opendirectory-12.1-py2.py3-none-any.whl", hash = "sha256:b5b5a5cf3cc2fb25147b16b79f046b90e3982bf3ded1b210a993d8cfdba737c4", size = 11845, upload-time = "2025-11-14T09:58:00.175Z" }, ] [[package]] name = "pyobjc-framework-osakit" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-cocoa" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/9d/bf/f6ea6b2e15151c79a22feda80d9e2c120d457cf16750c7751408f3dffc7c/pyobjc_framework_osakit-12.2.tar.gz", hash = "sha256:219efdbe36fa6bea1c780b28ad8a1b23ec4ca0ee9ad3cf040da192f883514b81", size = 18910, upload-time = "2026-05-30T12:40:55.732Z" } +sdist = { url = "https://files.pythonhosted.org/packages/cb/b9/bf52c555c75a83aa45782122432fa06066bb76469047f13d06fb31e585c4/pyobjc_framework_osakit-12.1.tar.gz", hash = "sha256:36ea6acf03483dc1e4344a0cce7250a9656f44277d12bc265fa86d4cbde01f23", size = 17102, upload-time = "2025-11-14T10:18:31.354Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/f4/ad/e79528da31d07f4d227c0f674b94a8a5b0aeac062d6a2df8363dbf0d99c9/pyobjc_framework_osakit-12.2-py2.py3-none-any.whl", hash = "sha256:604f428b00a0b1da1f40fc8a78db96e08b23abc7d666545a0909cc6e7b5ca2fd", size = 4143, upload-time = "2026-05-30T12:17:51.431Z" }, + { url = "https://files.pythonhosted.org/packages/99/10/30a15d7b23e6fcfa63d41ca4c7356c39ff81300249de89c3ff28216a9790/pyobjc_framework_osakit-12.1-py2.py3-none-any.whl", hash = "sha256:c49165336856fd75113d2e264a98c6deb235f1bd033eae48f661d4d832d85e6b", size = 4162, upload-time = "2025-11-14T09:58:01.953Z" }, ] [[package]] name = "pyobjc-framework-oslog" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, @@ -5438,583 +5459,583 @@ dependencies = [ { name = "pyobjc-framework-coremedia" }, { name = "pyobjc-framework-quartz" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/64/ba/dc92bab4a4be642226c3f6b71e0a100f70c27027728df00eeaaa588d04f8/pyobjc_framework_oslog-12.2.tar.gz", hash = "sha256:c2213dbb3edff318c731b300509c69bd922ad102311042dddcd9de8287e50a83", size = 22307, upload-time = "2026-05-30T12:40:57.943Z" } +sdist = { url = "https://files.pythonhosted.org/packages/12/42/805c9b4ac6ad25deb4215989d8fc41533d01e07ffd23f31b65620bade546/pyobjc_framework_oslog-12.1.tar.gz", hash = "sha256:d0ec6f4e3d1689d5e4341bc1130c6f24cb4ad619939f6c14d11a7e80c0ac4553", size = 21193, upload-time = "2025-11-14T10:18:33.645Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/be/13/df0e2bae8e19998101ba238a2cd27c147906c63cd42d1814293bc08f729b/pyobjc_framework_oslog-12.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:ce52bdc6803bf980369d3f265339063fb71391fcf980acadf9f73c4b7af7413d", size = 7902, upload-time = "2026-05-30T12:17:57.82Z" }, - { url = "https://files.pythonhosted.org/packages/c5/cb/b73921c1ce8a78620c14f00f2907de7430a5dd78cd858b3b72cf43758ee1/pyobjc_framework_oslog-12.2-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:102c32f34f772befc22d37bbf3a6a70a88b3389ea6d25111217e84c5bfde40cf", size = 8081, upload-time = "2026-05-30T12:17:59.592Z" }, + { url = "https://files.pythonhosted.org/packages/89/ad/719d65e7202623da7a3f22225e7f2b736f38cd6d3e0d87253b7f74f5b9c0/pyobjc_framework_oslog-12.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:d26ce39be2394695cf4c4c699e47f9b85479cf1ccb0472614bb88027803a8986", size = 7834, upload-time = "2025-11-14T09:58:09.586Z" }, + { url = "https://files.pythonhosted.org/packages/86/f0/a042b06f47d11bdad58d5c0cec9fe3dc4dc12ed9e476031cd4c0f08c6f18/pyobjc_framework_oslog-12.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:a6925e6764c6f293b69fbd4f5fd32a9810fca07d63e782c41cb4ebf05dc42977", size = 8016, upload-time = "2025-11-14T09:58:11.431Z" }, ] [[package]] name = "pyobjc-framework-passkit" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-cocoa" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/03/ed/68c8657d080f53706ea7e6cd77a4babb2b8f95a0c73471db5a56c5742988/pyobjc_framework_passkit-12.2.tar.gz", hash = "sha256:14a9b37b290942e86633ac59f923195d0038ff0f746443d914dfd5858cba9eff", size = 68267, upload-time = "2026-05-30T12:41:02.865Z" } +sdist = { url = "https://files.pythonhosted.org/packages/6c/d4/2afb59fb0f99eb2f03888850887e536f1ef64b303fd756283679471a5189/pyobjc_framework_passkit-12.1.tar.gz", hash = "sha256:d8c27c352e86a3549bf696504e6b25af5f2134b173d9dd60d66c6d3da53bb078", size = 53835, upload-time = "2025-11-14T10:18:37.906Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/3a/b0/dc2ca2ccf1377eb980220ea1b392803c0d7f42b2164960ed5a04361ec592/pyobjc_framework_passkit-12.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:3ca56bc17cd5ac7fea74caec55f3329a2b21c9462f70f1799a1896cb2fc9c06d", size = 14465, upload-time = "2026-05-30T12:18:13.945Z" }, - { url = "https://files.pythonhosted.org/packages/a2/24/1355ea6c97237c844e689e1f6b92481c3382693590af67a637a7c5205df7/pyobjc_framework_passkit-12.2-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:f58e668a4e827e2bfb7ddc41aae68025c980b5ec25d218ea8a49740159268f8e", size = 14627, upload-time = "2026-05-30T12:18:15.871Z" }, + { url = "https://files.pythonhosted.org/packages/7c/e2/6135402be2151042b234ea241e89f4b8984f6494fd11d9f56b4a56a9d7d4/pyobjc_framework_passkit-12.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:64287e6dc54ab4c0aa8ba80a7a51762e36591602c77c6a803aee690e7464b6b2", size = 14110, upload-time = "2025-11-14T09:58:23.107Z" }, + { url = "https://files.pythonhosted.org/packages/23/f3/ff6f81206eca1e1fb49c5a516d5eb15f143b38c5adee5b0c24076be02be9/pyobjc_framework_passkit-12.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:4a360e98b29eee8642f3e7d973c636284c24fb2ec2c3ee56022eeae6270943be", size = 14277, upload-time = "2025-11-14T09:58:25.338Z" }, ] [[package]] name = "pyobjc-framework-pencilkit" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-cocoa" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/ea/f0/39d09038bea6f2130ed6ad9de9034a2ebf3babd9eb5ad75a70f60160cfd6/pyobjc_framework_pencilkit-12.2.tar.gz", hash = "sha256:a224250d5bd8490e619792570bf2b03849b875757c076412ef83bddf58a3d2c5", size = 20122, upload-time = "2026-05-30T12:41:04.877Z" } +sdist = { url = "https://files.pythonhosted.org/packages/7e/43/859068016bcbe7d80597d5c579de0b84b0da62c5c55cdf9cc940e9f9c0f8/pyobjc_framework_pencilkit-12.1.tar.gz", hash = "sha256:d404982d1f7a474369f3e7fea3fbd6290326143fa4138d64b6753005a6263dc4", size = 17664, upload-time = "2025-11-14T10:18:40.045Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/ee/d6/45dc7133e4d561b725718a2d8cd016605a6fe7bcf3f12a002c34a309ee4c/pyobjc_framework_pencilkit-12.2-py2.py3-none-any.whl", hash = "sha256:aec57e9ebe2a875d4fc17c46ef16ffcee74ba7551dcd6d83207efb05c3377187", size = 4245, upload-time = "2026-05-30T12:18:25.228Z" }, + { url = "https://files.pythonhosted.org/packages/e8/26/daf47dcfced8f7326218dced5c68ed2f3b522ec113329218ce1305809535/pyobjc_framework_pencilkit-12.1-py2.py3-none-any.whl", hash = "sha256:33b88e5ed15724a12fd8bf27a68614b654ff739d227e81161298bc0d03acca4f", size = 4206, upload-time = "2025-11-14T09:58:30.814Z" }, ] [[package]] name = "pyobjc-framework-phase" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-avfoundation" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/40/4e/3102eb1fa234c851e23213701d3cda26eb3516c61598dcc7e3f26eb17724/pyobjc_framework_phase-12.2.tar.gz", hash = "sha256:fc1ec192bf7aac2627425c5f1fdabc3df614d100d18a6273b25ec4593f257eca", size = 40747, upload-time = "2026-05-30T12:41:08.372Z" } +sdist = { url = "https://files.pythonhosted.org/packages/96/51/3b25eaf7ca85f38ceef892fdf066b7faa0fec716f35ea928c6ffec6ae311/pyobjc_framework_phase-12.1.tar.gz", hash = "sha256:3a69005c572f6fd777276a835115eb8359a33673d4a87e754209f99583534475", size = 32730, upload-time = "2025-11-14T10:18:43.102Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/a8/80/9d526e002b9be65dd80abc2cc5c62afe8a85f353282f33d212c6b44b52db/pyobjc_framework_phase-12.2-py2.py3-none-any.whl", hash = "sha256:e8b85d7b2743b61f8920ad044f7e8370de80e5a4ca4f85ff42b6047b04e5f821", size = 7187, upload-time = "2026-05-30T12:18:26.949Z" }, + { url = "https://files.pythonhosted.org/packages/ae/9f/1ae45db731e8d6dd3e0b408c3accd0cf3236849e671f95c7c8cf95687240/pyobjc_framework_phase-12.1-py2.py3-none-any.whl", hash = "sha256:99a1c1efc6644f5312cce3693117d4e4482538f65ad08fe59e41e2579b67ab17", size = 6902, upload-time = "2025-11-14T09:58:32.436Z" }, ] [[package]] name = "pyobjc-framework-photos" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-cocoa" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/7e/a9/3845e4976742f15baf7decd63202b16326196596ee95271eb1eacbb388ed/pyobjc_framework_photos-12.2.tar.gz", hash = "sha256:126d2d2aa78ea0e704db807ee2c7f7b418d8a859a0cb8df6ee31e66fd371c2ab", size = 58662, upload-time = "2026-05-30T12:41:12.67Z" } +sdist = { url = "https://files.pythonhosted.org/packages/b8/53/f8a3dc7f711034d2283e289cd966fb7486028ea132a24260290ff32d3525/pyobjc_framework_photos-12.1.tar.gz", hash = "sha256:adb68aaa29e186832d3c36a0b60b0592a834e24c5263e9d78c956b2b77dce563", size = 47034, upload-time = "2025-11-14T10:18:47.27Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/b7/39/2195f0457e021692c80db6b31334d26fa08db64ced2751040384de8b5fca/pyobjc_framework_photos-12.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:2f3caf43105e0d142abc6b10bb851dc107158682d9dbb612d053cee80385f0f7", size = 12537, upload-time = "2026-05-30T12:18:34.198Z" }, - { url = "https://files.pythonhosted.org/packages/67/ca/3c305cec64c242f2f66533650ec955c93af89772a910c64c4eb4c6748ec2/pyobjc_framework_photos-12.2-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:59a9ac81947dc6140093ec2f4131842c8820f6ad9a51226c56e15b43ebacf011", size = 12715, upload-time = "2026-05-30T12:18:36.022Z" }, + { url = "https://files.pythonhosted.org/packages/71/5a/3c4e2af8d17e62ecf26e066fbb9209aacccfaf691f5faa42e3fd64b2b9f2/pyobjc_framework_photos-12.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:bd7906d8662af29f91c71892ae0b0cab4682a3a7ef5be1a2277d881d7b8d37d3", size = 12367, upload-time = "2025-11-14T09:58:42.328Z" }, + { url = "https://files.pythonhosted.org/packages/fb/24/566de3200d4aa05ca75b0150e5d031d2384a388f9126a4fef62a8f53818f/pyobjc_framework_photos-12.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:c822d81c778dd2a789f15d0f329cee633391c5ad766482ffbaf40d3dc57584a3", size = 12552, upload-time = "2025-11-14T09:58:44.134Z" }, ] [[package]] name = "pyobjc-framework-photosui" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-cocoa" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/ff/62/9b4322779ac45e8971d613c23f19284d7c6ac2492b2384c8eaa4582e6dfd/pyobjc_framework_photosui-12.2.tar.gz", hash = "sha256:c85ebf27f523dca57fadf767a4d72739c760d7c7236f5e5c8fbe4f80e696c9fd", size = 33856, upload-time = "2026-05-30T12:41:15.824Z" } +sdist = { url = "https://files.pythonhosted.org/packages/40/a5/14c538828ed1a420e047388aedc4a2d7d9292030d81bf6b1ced2ec27b6e9/pyobjc_framework_photosui-12.1.tar.gz", hash = "sha256:9141234bb9d17687f1e8b66303158eccdd45132341fbe5e892174910035f029a", size = 29886, upload-time = "2025-11-14T10:18:50.238Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/99/c4/c2f9cc556bde2e1e85cc20103ef34705da6e695b542330d5fff7eff17cdd/pyobjc_framework_photosui-12.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:2630d9f61df8f786b1a42a30872e856be2ae7a2fd21c995c5d7d88705cc784ed", size = 11793, upload-time = "2026-05-30T12:18:50.524Z" }, - { url = "https://files.pythonhosted.org/packages/b5/68/f9696cd18c479e67b9b911c5a8d7243034fe36c6bf6482add22ae1076dc0/pyobjc_framework_photosui-12.2-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:9c3e0cdbca02ee749b3d56ff332a4a69b8d378550131df4e4003733c6331728d", size = 11994, upload-time = "2026-05-30T12:18:52.323Z" }, + { url = "https://files.pythonhosted.org/packages/d6/cd/204298e136ff22d3502f0b66cda1d36df89346fa2b20f4a3a681c2c96fee/pyobjc_framework_photosui-12.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:5fa3ca2bc4c8609dee46e3c8fb5f3fbfb615f39fa3d710a213febec38e227758", size = 11725, upload-time = "2025-11-14T09:58:56.694Z" }, + { url = "https://files.pythonhosted.org/packages/f6/5e/492007c629844666e8334e535471c5492e93715965fdffe4f75227f47fac/pyobjc_framework_photosui-12.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:713ec72b13d8399229d285ccd1e94e5ea2627cf88858977a2a91cc94d1affcd6", size = 11921, upload-time = "2025-11-14T09:58:58.477Z" }, ] [[package]] name = "pyobjc-framework-preferencepanes" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-cocoa" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/0b/86/73de5b65736cea66bb0159d9a37c007abceee8ecd3a059211241aa2d77cb/pyobjc_framework_preferencepanes-12.2.tar.gz", hash = "sha256:4928aa6fb30b24af3aa7379125ceca91687e97b08715909689d549a0a73266d3", size = 25151, upload-time = "2026-05-30T12:41:18.455Z" } +sdist = { url = "https://files.pythonhosted.org/packages/90/bc/e87df041d4f7f6b7721bf7996fa02aa0255939fb0fac0ecb294229765f92/pyobjc_framework_preferencepanes-12.1.tar.gz", hash = "sha256:b2a02f9049f136bdeca7642b3307637b190850e5853b74b5c372bc7d88ef9744", size = 24543, upload-time = "2025-11-14T10:18:53.259Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/d9/5d/b75418c408c5e969352307b5fd4d739e55b3618cf94e729ba9768e453f2a/pyobjc_framework_preferencepanes-12.2-py2.py3-none-any.whl", hash = "sha256:ccd142fb1d26f20e660651008fce1440f0abc1897bd5ffb5546cd77e89bb31a6", size = 4803, upload-time = "2026-05-30T12:19:00.619Z" }, + { url = "https://files.pythonhosted.org/packages/36/7b/8ceec1ab0446224d685e243e2770c5a5c92285bcab0b9324dbe7a893ae5a/pyobjc_framework_preferencepanes-12.1-py2.py3-none-any.whl", hash = "sha256:1b3af9db9e0cfed8db28c260b2cf9a22c15fda5f0ff4c26157b17f99a0e29bbf", size = 4797, upload-time = "2025-11-14T09:59:03.998Z" }, ] [[package]] name = "pyobjc-framework-pushkit" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-cocoa" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/e1/40/23d8b7065434179984df6f4bb18c6ead5400ed2f85b7080282c600106022/pyobjc_framework_pushkit-12.2.tar.gz", hash = "sha256:8f6b6879920bf9650f2288adb0dc8f809a807825c29136b6492561712234b0b3", size = 20471, upload-time = "2026-05-30T12:41:22.736Z" } +sdist = { url = "https://files.pythonhosted.org/packages/a9/45/de756b62709add6d0615f86e48291ee2bee40223e7dde7bbe68a952593f0/pyobjc_framework_pushkit-12.1.tar.gz", hash = "sha256:829a2fc8f4780e75fc2a41217290ee0ff92d4ade43c42def4d7e5af436d8ae82", size = 19465, upload-time = "2025-11-14T10:18:57.727Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/fd/73/d315aac0efb5466a0235ea69aefac9883add2f5fb90ee363372abeaab299/pyobjc_framework_pushkit-12.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:358e5e381d37fc1199d0e18eae0ec9bc88145545c985a75ffae37918c0634a3c", size = 8299, upload-time = "2026-05-30T12:19:09.129Z" }, - { url = "https://files.pythonhosted.org/packages/89/6f/8ee291088ec4b6469b9b51674d0f160929395164483136cccf2569bb85c2/pyobjc_framework_pushkit-12.2-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:11a5efd1e08cce341b0882cf4b47ba120f288c04594d714c0149c2a357518b05", size = 8438, upload-time = "2026-05-30T12:19:10.855Z" }, + { url = "https://files.pythonhosted.org/packages/1b/79/00368a140fe4a14e92393da25ef5a3037a09bb0024d984d7813e7e3fa11c/pyobjc_framework_pushkit-12.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:f3751276cb595a9f886ed6094e06004fd11932443e345760eade09119f8e0181", size = 8193, upload-time = "2025-11-14T09:59:13.23Z" }, + { url = "https://files.pythonhosted.org/packages/57/29/dccede214ef1835662066c74138978629d92b6a9f723e28670cfb04f3ce7/pyobjc_framework_pushkit-12.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:64955af6441635449c2af6c6f468c9ba5e413e1494b87617bc1e9fbd8be7e5bf", size = 8339, upload-time = "2025-11-14T09:59:14.754Z" }, ] [[package]] name = "pyobjc-framework-quartz" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-cocoa" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/91/a3/5ae4c90c13999b46315f549694f25c374c48a9f7ab18f98ace6e74f4a5c1/pyobjc_framework_quartz-12.2.tar.gz", hash = "sha256:b343395d4790323b0376fe20c83ac468510ba19f65429323ca211708c939d107", size = 3215525, upload-time = "2026-05-30T12:44:27.759Z" } +sdist = { url = "https://files.pythonhosted.org/packages/94/18/cc59f3d4355c9456fc945eae7fe8797003c4da99212dd531ad1b0de8a0c6/pyobjc_framework_quartz-12.1.tar.gz", hash = "sha256:27f782f3513ac88ec9b6c82d9767eef95a5cf4175ce88a1e5a65875fee799608", size = 3159099, upload-time = "2025-11-14T10:21:24.31Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/96/56/670a847a3a8ee2799f405b876a2f20914f22b4865f1d8157169095c21d94/pyobjc_framework_quartz-12.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:214c19aadfd100d9202994a22fbced804f7d60f8473de6f292111cc1668f9373", size = 219383, upload-time = "2026-05-30T12:20:12.444Z" }, - { url = "https://files.pythonhosted.org/packages/35/ef/598bd4d1fb796305648c03667938f08bb59ed4e0bcdc1591fd2c6238abf2/pyobjc_framework_quartz-12.2-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:4e0634ee9782e480587a074d1d08867fa7ef0d845c2f6cbaef6a48b7d2c3899f", size = 224436, upload-time = "2026-05-30T12:20:26.608Z" }, + { url = "https://files.pythonhosted.org/packages/ba/2d/e8f495328101898c16c32ac10e7b14b08ff2c443a756a76fd1271915f097/pyobjc_framework_quartz-12.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:629b7971b1b43a11617f1460cd218bd308dfea247cd4ee3842eb40ca6f588860", size = 219206, upload-time = "2025-11-14T10:00:15.623Z" }, + { url = "https://files.pythonhosted.org/packages/67/43/b1f0ad3b842ab150a7e6b7d97f6257eab6af241b4c7d14cb8e7fde9214b8/pyobjc_framework_quartz-12.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:53b84e880c358ba1ddcd7e8d5ea0407d760eca58b96f0d344829162cda5f37b3", size = 224317, upload-time = "2025-11-14T10:00:30.703Z" }, ] [[package]] name = "pyobjc-framework-quicklookthumbnailing" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-cocoa" }, { name = "pyobjc-framework-quartz" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/75/c7/e19792f6473714f4144ff2c579f2a231eeb81e405388140471f9f6ffaa4c/pyobjc_framework_quicklookthumbnailing-12.2.tar.gz", hash = "sha256:b0104142f0eb950e849ea25f40c01715069e1bdb3de69949c1b4732c8f5c693f", size = 15771, upload-time = "2026-05-30T12:44:30.263Z" } +sdist = { url = "https://files.pythonhosted.org/packages/97/1a/b90539500e9a27c2049c388d85a824fc0704009b11e33b05009f52a6dc67/pyobjc_framework_quicklookthumbnailing-12.1.tar.gz", hash = "sha256:4f7e09e873e9bda236dce6e2f238cab571baeb75eca2e0bc0961d5fcd85f3c8f", size = 14790, upload-time = "2025-11-14T10:21:26.442Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/48/5d/012d04a9fe4117f727e0436b7b6c9a30f780e04ee51f1d6e28bb6d1a8700/pyobjc_framework_quicklookthumbnailing-12.2-py2.py3-none-any.whl", hash = "sha256:a60bdc283a44a70ad7a12840010b76d42ffd580c4bffb630da3874b229d30a74", size = 4306, upload-time = "2026-05-30T12:21:24.611Z" }, + { url = "https://files.pythonhosted.org/packages/1e/22/7bd07b5b44bf8540514a9f24bc46da68812c1fd6c63bb2d3496e5ea44bf0/pyobjc_framework_quicklookthumbnailing-12.1-py2.py3-none-any.whl", hash = "sha256:5efe50b0318188b3a4147681788b47fce64709f6fe0e1b5d020e408ef40ab08e", size = 4234, upload-time = "2025-11-14T10:01:02.209Z" }, ] [[package]] name = "pyobjc-framework-replaykit" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-cocoa" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/ad/28/9562e12a0f13ba9c03ec59694af026500265cba2bc71468bf5985230ff3e/pyobjc_framework_replaykit-12.2.tar.gz", hash = "sha256:f971842973fad039642a67e3432b864e8bed815228d67d07b52174fceadca86f", size = 27206, upload-time = "2026-05-30T12:44:32.807Z" } +sdist = { url = "https://files.pythonhosted.org/packages/35/f8/b92af879734d91c1726227e7a03b9e68ab8d9d2bb1716d1a5c29254087f2/pyobjc_framework_replaykit-12.1.tar.gz", hash = "sha256:95801fd35c329d7302b2541f2754e6574bf36547ab869fbbf41e408dfa07268a", size = 23312, upload-time = "2025-11-14T10:21:29.18Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/f8/e3/bf9e3cc9fb4f3629b42e510f40539e323af43597601bf1ae5275a8468572/pyobjc_framework_replaykit-12.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:ae67c235356b4442dd0765ba3b911acf6f597894ad27b6b6c322b55ea501be6e", size = 10165, upload-time = "2026-05-30T12:21:31.556Z" }, - { url = "https://files.pythonhosted.org/packages/03/ad/a34116524dd3d7cae22cef8125a897c4533b9dff9236cf4e00f06ca01012/pyobjc_framework_replaykit-12.2-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:2040fe7d3da7ac485c32f620bc0a2ffb8c5c1052ca67e2d36db78533bbd84e9c", size = 10348, upload-time = "2026-05-30T12:21:33.309Z" }, + { url = "https://files.pythonhosted.org/packages/22/f1/95d3cf08a5b747e15dfb45f4ad23aeae566e75e6c54f3c58caf59b99f4d9/pyobjc_framework_replaykit-12.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:18af5ab59574102978790ce9ccc89fe24be9fa57579f24ed8cfc2b44ea28d839", size = 10141, upload-time = "2025-11-14T10:01:10.366Z" }, + { url = "https://files.pythonhosted.org/packages/4e/78/fac397700f62fdb73161e04affd608678883e9476553fd99e9d65db51f79/pyobjc_framework_replaykit-12.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:31c826a71b76cd7d12c3f30956c202116b0c985a19eb420e91fc1f51bedd2f72", size = 10319, upload-time = "2025-11-14T10:01:12.058Z" }, ] [[package]] name = "pyobjc-framework-safariservices" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-cocoa" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/9f/e5/8caad7cc12d7452f9f78f931bec253f04577c6a876a9884834572223462c/pyobjc_framework_safariservices-12.2.tar.gz", hash = "sha256:35f76589201c9857f36fcae027c79ae2719d4463e1bb35996f78de9f570a0a58", size = 27300, upload-time = "2026-05-30T12:44:35.242Z" } +sdist = { url = "https://files.pythonhosted.org/packages/3e/4b/8f896bafbdbfa180a5ba1e21a6f5dc63150c09cba69d85f68708e02866ae/pyobjc_framework_safariservices-12.1.tar.gz", hash = "sha256:6a56f71c1e692bca1f48fe7c40e4c5a41e148b4e3c6cfb185fd80a4d4a951897", size = 25165, upload-time = "2025-11-14T10:21:32.041Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/83/56/c3bf80c5abf766078fc6815a91c287a72772eb675eb538fa8e3aad426dd5/pyobjc_framework_safariservices-12.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:d7883793626c82eb645c99b719cffa856f8fa6d2bc19ce9fabedf5611888b7e9", size = 7339, upload-time = "2026-05-30T12:21:46.007Z" }, - { url = "https://files.pythonhosted.org/packages/5c/19/bbd38d764573a907e9287aec7fd065904b136042a6f4d8d9b488cdb67640/pyobjc_framework_safariservices-12.2-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:f97571814b69ca81baa3570a4338e9c7679a7505c5f05b28938890ed71d95ff6", size = 7344, upload-time = "2026-05-30T12:21:47.611Z" }, + { url = "https://files.pythonhosted.org/packages/b6/e7/fc984cf2471597e71378b4f82be4a1923855a4c4a56486cc8d97fdaf1694/pyobjc_framework_safariservices-12.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:592cf5080a9e7f104d6a8d338ebf2523a961f38068f238f11783e86dc105f9c7", size = 7304, upload-time = "2025-11-14T10:01:22.786Z" }, + { url = "https://files.pythonhosted.org/packages/6e/99/3d3062808a64422f39586519d38a52e73304ed60f45500b2c75b97fdd667/pyobjc_framework_safariservices-12.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:097a2166f79c60633e963913722a087a13b1c5849f3173655b24a8be47039ac4", size = 7308, upload-time = "2025-11-14T10:01:24.299Z" }, ] [[package]] name = "pyobjc-framework-safetykit" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-cocoa" }, { name = "pyobjc-framework-quartz" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/28/c2/7a6c1c356ba3d9164357c353142e6d9354f999b45f204c57c5f2162a47dd/pyobjc_framework_safetykit-12.2.tar.gz", hash = "sha256:3161c4cd35261615ea38e64bd1db9de19c66d18d4d350bbe7d4eb4f69207e256", size = 20867, upload-time = "2026-05-30T12:44:37.319Z" } +sdist = { url = "https://files.pythonhosted.org/packages/f4/bf/ad6bf60ceb61614c9c9f5758190971e9b90c45b1c7a244e45db64138b6c2/pyobjc_framework_safetykit-12.1.tar.gz", hash = "sha256:0cd4850659fb9b5632fd8ad21f2de6863e8303ff0d51c5cc9c0034aac5db08d8", size = 20086, upload-time = "2025-11-14T10:21:34.212Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/a0/c9/f33171cb2129b39fc8ce4a2dfd5ccb9d5fd7fcff795b90efa85462490609/pyobjc_framework_safetykit-12.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:93020a92a64dba726e8e1fb03079b4697d49e67f0338b33a63eab76a1a797033", size = 8594, upload-time = "2026-05-30T12:22:00.181Z" }, - { url = "https://files.pythonhosted.org/packages/54/1d/2abc135c5b8674511bf72a194e2ee7d9fd23cc37ad6a9a8884451aa2a6b1/pyobjc_framework_safetykit-12.2-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:6dee8522c45cca1017ebc52198a89d81cf12b4e1fc751e8fab87059326b9c9d2", size = 8748, upload-time = "2026-05-30T12:22:01.766Z" }, + { url = "https://files.pythonhosted.org/packages/02/c5/0e8961e48a2e5942f3f4fad46be5a7b47e17792d89f4c2405b065c1241b5/pyobjc_framework_safetykit-12.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:20170b4869c4ee5485f750ad02bbfcb25c53bbfe86892e5328096dc3c6478b83", size = 8564, upload-time = "2025-11-14T10:01:34.934Z" }, + { url = "https://files.pythonhosted.org/packages/48/3f/fdadc2b992cb3e08269fc75dec3128f8153dd833715b9fbfb975c193c4d2/pyobjc_framework_safetykit-12.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:4a935c55ae8e731a44c3cb74324da7517634bfc0eca678b6d4b2f9fe04ff53d8", size = 8720, upload-time = "2025-11-14T10:01:36.564Z" }, ] [[package]] name = "pyobjc-framework-scenekit" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-cocoa" }, { name = "pyobjc-framework-quartz" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/f8/c8/963293a476d7c80f60d93e3da2b1f6016913e827fdde63d3b9b7ec96164b/pyobjc_framework_scenekit-12.2.tar.gz", hash = "sha256:de58706317e567d0a5f257f9a4a66fafa037c5c8ef79051c19066b42477e301f", size = 131982, upload-time = "2026-05-30T12:44:45.83Z" } +sdist = { url = "https://files.pythonhosted.org/packages/94/8c/1f4005cf0cb68f84dd98b93bbc0974ee7851bb33d976791c85e042dc2278/pyobjc_framework_scenekit-12.1.tar.gz", hash = "sha256:1bd5b866f31fd829f26feac52e807ed942254fd248115c7c742cfad41d949426", size = 101212, upload-time = "2025-11-14T10:21:41.265Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/a5/e1/c117e5db66ceb6c13f0bb44c40210749e2d9c61eb5d77d50e731dceb8865/pyobjc_framework_scenekit-12.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:0b1795cf860b19fb04116236b6de3a46ffac9f8b03c46863128d36207cc53a40", size = 34827, upload-time = "2026-05-30T12:22:21.167Z" }, - { url = "https://files.pythonhosted.org/packages/c4/44/645de9525dbd6258954b8001336df1f3ae85559acae9a119049089975270/pyobjc_framework_scenekit-12.2-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:0d0bcea0b7a4a13046a666a5b316c1b3ebfdd90a63226fcd5b7943fd9ee9d615", size = 35142, upload-time = "2026-05-30T12:22:24.247Z" }, + { url = "https://files.pythonhosted.org/packages/4a/82/c728a025fd09cd259870d43b68ce8e7cffb639112033693ffa02d3d1eac0/pyobjc_framework_scenekit-12.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:a032377a7374320131768b6c8bf84589e45819d9e0fe187bd3f8d985207016b9", size = 33623, upload-time = "2025-11-14T10:01:54.878Z" }, + { url = "https://files.pythonhosted.org/packages/5e/ef/9cea4cc4ac7f43fa6fb60d0690d25b2da1d8e1cf42266316014d1bb43a11/pyobjc_framework_scenekit-12.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:633909adff9b505b49c34307f507f4bd926b88a1482d8143655d5703481cbbf5", size = 33934, upload-time = "2025-11-14T10:01:57.994Z" }, ] [[package]] name = "pyobjc-framework-screencapturekit" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-cocoa" }, { name = "pyobjc-framework-coremedia" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/d2/e5/469c73f6ba9bf9ae6d4a93aa23838f288dabee88555402754dee000ec884/pyobjc_framework_screencapturekit-12.2.tar.gz", hash = "sha256:7f45f2e170b97dfde3e6c7d3b867ec3ec03caf3aac9259fde4ba0272d912b00e", size = 37813, upload-time = "2026-05-30T12:44:49.014Z" } +sdist = { url = "https://files.pythonhosted.org/packages/2d/7f/73458db1361d2cb408f43821a1e3819318a0f81885f833d78d93bdc698e0/pyobjc_framework_screencapturekit-12.1.tar.gz", hash = "sha256:50992c6128b35ab45d9e336f0993ddd112f58b8c8c8f0892a9cb42d61bd1f4c9", size = 32573, upload-time = "2025-11-14T10:21:44.497Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/73/5e/e64b2a94e8f950dc2418a274049c01ad3f8f3f54fbabe6912c72a72dff5b/pyobjc_framework_screencapturekit-12.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:ca8378bf217d3ac48db0bb62218b8bcf6b69bd35e1ba66608bec8c31e0f0fbf5", size = 11590, upload-time = "2026-05-30T12:22:44.063Z" }, - { url = "https://files.pythonhosted.org/packages/21/25/892fe4f54b8ccecbcce6f05c98e377021ec4ada9b226b18523ac97c04025/pyobjc_framework_screencapturekit-12.2-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:c1be8a80eaa2a929cde641526f81e7452ff156234372d27c5084df472a74843a", size = 11766, upload-time = "2026-05-30T12:22:45.744Z" }, + { url = "https://files.pythonhosted.org/packages/45/f9/ff713b8c4659f9ef1c4dbb8ca4b59c4b22d9df48471230979d620709e3b4/pyobjc_framework_screencapturekit-12.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:168125388fb35c6909bec93b259508156e89b9e30fec5748d4a04fd0157f0e0d", size = 11523, upload-time = "2025-11-14T10:02:13.494Z" }, + { url = "https://files.pythonhosted.org/packages/f0/26/8bf1bacdb2892cf26d043c7f6e8788a613bbb2ccb313a5ea0634612cfc24/pyobjc_framework_screencapturekit-12.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:4fc2fe72c1da5ac1b8898a7b2082ed69803e6d9c11f414bb5a5ec94422a5f74f", size = 11701, upload-time = "2025-11-14T10:02:15.634Z" }, ] [[package]] name = "pyobjc-framework-screensaver" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-cocoa" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/45/47/475b9d9462fb72f264c600178905e0f149d0dc3ac549940477cc582aa24c/pyobjc_framework_screensaver-12.2.tar.gz", hash = "sha256:2aefc58e53b42c33d0d06b4c846147c7b15b065254c588bef0ce8871ccf6d9d7", size = 22793, upload-time = "2026-05-30T12:44:51.232Z" } +sdist = { url = "https://files.pythonhosted.org/packages/7d/99/7cfbce880cea61253a44eed594dce66c2b2fbf29e37eaedcd40cffa949e9/pyobjc_framework_screensaver-12.1.tar.gz", hash = "sha256:c4ca111317c5a3883b7eace0a9e7dd72bc6ffaa2ca954bdec918c3ab7c65c96f", size = 22229, upload-time = "2025-11-14T10:21:47.299Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/aa/cc/168c45769e522b7982702c2b2af9891036e7653d8bc50a3871f529c9fb8a/pyobjc_framework_screensaver-12.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:e4a2e2205effaa1dcbf5365e25011b057ae70deadeb29b0782c0af6dc2592f7c", size = 8481, upload-time = "2026-05-30T12:22:59.402Z" }, - { url = "https://files.pythonhosted.org/packages/3b/bd/f0ee37d17d48f64c1232cf89fcac33ba56454be63062ca50150ff0002799/pyobjc_framework_screensaver-12.2-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:921dc983e81b0aab7f102bcd115b4c5cbc347d251b00167ca58ccec7c6ba10cf", size = 8493, upload-time = "2026-05-30T12:23:01.134Z" }, + { url = "https://files.pythonhosted.org/packages/7e/8a/2e0cb958e872896b67ae6d5877070867f4a845ea1010984ff887ad418396/pyobjc_framework_screensaver-12.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:2a865b6dbb39fb92cdb67b13f68d594ab84d08a984cc3e9a39fab3386f431649", size = 8442, upload-time = "2025-11-14T10:02:26.135Z" }, + { url = "https://files.pythonhosted.org/packages/35/45/3eb9984119be3dcd90f4628ecc3964c1a394b702a71034af6d932f98de3a/pyobjc_framework_screensaver-12.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:c249dffcb95d55fc6be626bf17f70b477e320c33d94e234597bc0074e302cfcd", size = 8450, upload-time = "2025-11-14T10:02:27.782Z" }, ] [[package]] name = "pyobjc-framework-screentime" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-cocoa" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/7b/e1/acd5b9635c905305cdd367d1e5e06f71db13c44ac3384f0241845b180272/pyobjc_framework_screentime-12.2.tar.gz", hash = "sha256:0f708bf1707f2db5c4d13397471bd13cb8c1516ea204d7c4cca8f448295caa4e", size = 14069, upload-time = "2026-05-30T12:44:52.98Z" } +sdist = { url = "https://files.pythonhosted.org/packages/10/11/ba18f905321895715dac3cae2071c2789745ae13605b283b8114b41e0459/pyobjc_framework_screentime-12.1.tar.gz", hash = "sha256:583de46b365543bbbcf27cd70eedd375d397441d64a2cf43c65286fd9c91af55", size = 13413, upload-time = "2025-11-14T10:21:49.17Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/74/a6/2bdf31496600ffcbbb958910e03726e238f6a0ac6a7f3862cdbc28cab9c1/pyobjc_framework_screentime-12.2-py2.py3-none-any.whl", hash = "sha256:ef463bf9cf66ab2679a6fdc3da0a51bca3050bee4ff7614ac714edaa13e36003", size = 3979, upload-time = "2026-05-30T12:23:09.049Z" }, + { url = "https://files.pythonhosted.org/packages/27/06/904174de6170e11b53673cc5844e5f13394eeeed486e0bcdf5288c1b0853/pyobjc_framework_screentime-12.1-py2.py3-none-any.whl", hash = "sha256:d34a068ec8ba2704987fcd05c37c9a9392de61d92933e6e71c8e4eaa4dfce029", size = 3963, upload-time = "2025-11-14T10:02:32.577Z" }, ] [[package]] name = "pyobjc-framework-scriptingbridge" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-cocoa" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/2b/81/59528ce5c27667c0effcb6af24d039767df0faafe3ad006f154a82d270ef/pyobjc_framework_scriptingbridge-12.2.tar.gz", hash = "sha256:b1420622d923cfe6218904a6a997eae4984653d32554b16374690c347f8ab55d", size = 21239, upload-time = "2026-05-30T12:44:55.141Z" } +sdist = { url = "https://files.pythonhosted.org/packages/0c/cb/adc0a09e8c4755c2281bd12803a87f36e0832a8fc853a2d663433dbb72ce/pyobjc_framework_scriptingbridge-12.1.tar.gz", hash = "sha256:0e90f866a7e6a8aeaf723d04c826657dd528c8c1b91e7a605f8bb947c74ad082", size = 20339, upload-time = "2025-11-14T10:21:51.769Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/9b/5b/ed96c67b88ce1408f1778d1235a7c3c354980e4c925ce53bfbea0b424c78/pyobjc_framework_scriptingbridge-12.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:ea7944907fe696a8192f2a9861e148b9a0161ac3415ab6ce6e76230181a10264", size = 8376, upload-time = "2026-05-30T12:23:15.823Z" }, - { url = "https://files.pythonhosted.org/packages/c0/57/9658c1a8576038e571308c3f21a6f38050808a7e379b1149c9b55abed746/pyobjc_framework_scriptingbridge-12.2-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:8dfab9213a60840f15d0ebb2572237fea569ff69d2a593f524e8c7074b6cf657", size = 8525, upload-time = "2026-05-30T12:23:17.429Z" }, + { url = "https://files.pythonhosted.org/packages/1a/da/b11568f21924a994aa59272e2752e742f8380ab2cf88d111326ba7baede0/pyobjc_framework_scriptingbridge-12.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:bddbd3a13bfaeaa38ab66e44f10446d5bc7d1110dbc02e59b80bcd9c3a60548a", size = 8371, upload-time = "2025-11-14T10:02:40.603Z" }, + { url = "https://files.pythonhosted.org/packages/77/eb/9bc3e6e9611d757fc80b4423cc28128750a72eae8241be8ae43e1d76c4cd/pyobjc_framework_scriptingbridge-12.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:148191010b4e10c3938cdb2dcecad43fa0884cefb5a78499a21bdaf5a78318b3", size = 8526, upload-time = "2025-11-14T10:02:42.298Z" }, ] [[package]] name = "pyobjc-framework-searchkit" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-coreservices" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/87/f1/2240da12e22d6e7273f60bc7fa7ec160ab67d8a3c7801010d480f661a16d/pyobjc_framework_searchkit-12.2.tar.gz", hash = "sha256:aec05c1fa302e11a8e1e737a67ed8ce2bf1e04e9e249796b3b923e90e7b07b9f", size = 31137, upload-time = "2026-05-30T12:44:57.732Z" } +sdist = { url = "https://files.pythonhosted.org/packages/6e/60/a38523198430e14fdef21ebe62a93c43aedd08f1f3a07ea3d96d9997db5d/pyobjc_framework_searchkit-12.1.tar.gz", hash = "sha256:ddd94131dabbbc2d7c3f17db3da87c1a712c431310eef16f07187771e7e85226", size = 30942, upload-time = "2025-11-14T10:21:55.483Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/47/ef/4e69b33a88e31e6d4e2ef9d266771b81bd20fce0eeffc1fa7c79ce9b3ec7/pyobjc_framework_searchkit-12.2-py2.py3-none-any.whl", hash = "sha256:eb004bbc4522e7e7a8ee3751539056e18c204fd591ac8a2ffa6a8146117ab3fe", size = 3732, upload-time = "2026-05-30T12:23:25.282Z" }, + { url = "https://files.pythonhosted.org/packages/72/46/4f9cd3011f47b43b21b2924ab3770303c3f0a4d16f05550d38c5fcb42e78/pyobjc_framework_searchkit-12.1-py2.py3-none-any.whl", hash = "sha256:844ce62b7296b19da8db7dedd539d07f7b3fb3bb8b029c261f7bcf0e01a97758", size = 3733, upload-time = "2025-11-14T10:02:47.026Z" }, ] [[package]] name = "pyobjc-framework-security" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-cocoa" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/e3/3c/7778dd8e196373feabc54841b87e495148da3fe20d305f39397546afaaee/pyobjc_framework_security-12.2.tar.gz", hash = "sha256:ef4d2d852a09360929e284c6f355964d84ac88b170207de1ac299fa1e1c33e40", size = 181056, upload-time = "2026-05-30T12:45:09.053Z" } +sdist = { url = "https://files.pythonhosted.org/packages/80/aa/796e09a3e3d5cee32ebeebb7dcf421b48ea86e28c387924608a05e3f668b/pyobjc_framework_security-12.1.tar.gz", hash = "sha256:7fecb982bd2f7c4354513faf90ba4c53c190b7e88167984c2d0da99741de6da9", size = 168044, upload-time = "2025-11-14T10:22:06.334Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/33/ea/20d93a62d2f3d54dccac9e3d9de617d27c229ccce42b8bd0d7f4bb4461aa/pyobjc_framework_security-12.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:703b8544d2623a854f438b13ef4561402e6228eacfb0f0b2cbf28d2704815f44", size = 41278, upload-time = "2026-05-30T12:23:39.428Z" }, - { url = "https://files.pythonhosted.org/packages/17/a7/9725d152c8f23c6f2d3bb7fc2c2c9bbcbc7908a91de935c80fc5ed54c6c5/pyobjc_framework_security-12.2-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:10f03ed38e915f823640cbc19d5a921ee29ae266f0d76a2910c53fcd7cd61447", size = 42156, upload-time = "2026-05-30T12:23:42.945Z" }, + { url = "https://files.pythonhosted.org/packages/32/48/b294ed75247c5cfa00d51925a10237337d24f54961d49a179b20a4307642/pyobjc_framework_security-12.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:afc36661cc6eb98cd794bed1d6668791e96557d6f72d9ac70aa49022d26af1d4", size = 41284, upload-time = "2025-11-14T10:03:01.722Z" }, + { url = "https://files.pythonhosted.org/packages/ef/57/0d3ef78779cf5c3bba878b2f824137e50978ad4a21dabe65d8b5ae0fc0d1/pyobjc_framework_security-12.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:9510c98ab56921d1d416437372605cc1c1f6c1ad8d3061ee56b17bf423dd5427", size = 42162, upload-time = "2025-11-14T10:03:05.337Z" }, ] [[package]] name = "pyobjc-framework-securityfoundation" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-cocoa" }, { name = "pyobjc-framework-security" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/f6/20/7fc0158fb92a894699ecf510c3be138c249817276c8346e70fd2a8868371/pyobjc_framework_securityfoundation-12.2.tar.gz", hash = "sha256:03d51d2945f4ceeb7f5fe60e28f9f18f9e96797152467d523d374f6f242eb89f", size = 13080, upload-time = "2026-05-30T12:45:11.227Z" } +sdist = { url = "https://files.pythonhosted.org/packages/57/d5/c2b77e83c1585ba43e5f00c917273ba4bf7ed548c1b691f6766eb0418d52/pyobjc_framework_securityfoundation-12.1.tar.gz", hash = "sha256:1f39f4b3db6e3bd3a420aaf4923228b88e48c90692cf3612b0f6f1573302a75d", size = 12669, upload-time = "2025-11-14T10:22:09.256Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/bb/86/f3fe3bea55f684182e65a4762204802c5fdd7f0b67db77f5dff2a2b3b2f6/pyobjc_framework_securityfoundation-12.2-py2.py3-none-any.whl", hash = "sha256:7e1c8307799cc819cf5891ed046b78eae4907e267592456688fe15f5892ec16f", size = 3801, upload-time = "2026-05-30T12:23:58.268Z" }, + { url = "https://files.pythonhosted.org/packages/93/1e/349fb71a413b37b1b41e712c7ca180df82144478f8a9a59497d66d0f2ea2/pyobjc_framework_securityfoundation-12.1-py2.py3-none-any.whl", hash = "sha256:579cf23e63434226f78ffe0afb8426e971009588e4ad812c478d47dfd558201c", size = 3792, upload-time = "2025-11-14T10:03:14.459Z" }, ] [[package]] name = "pyobjc-framework-securityinterface" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-cocoa" }, { name = "pyobjc-framework-security" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/f4/21/d164e409e47ae4460d9320d21de17c825017731a870dee1a2905fd187127/pyobjc_framework_securityinterface-12.2.tar.gz", hash = "sha256:096ea141b84f5128d367f4a7800073c801200bde86a451c735708137a4f23183", size = 27756, upload-time = "2026-05-30T12:45:13.639Z" } +sdist = { url = "https://files.pythonhosted.org/packages/f9/64/bf5b5d82655112a2314422ee649f1e1e73d4381afa87e1651ce7e8444694/pyobjc_framework_securityinterface-12.1.tar.gz", hash = "sha256:deef11ad03be8d9ff77db6e7ac40f6b641ee2d72eaafcf91040537942472e88b", size = 25552, upload-time = "2025-11-14T10:22:12.098Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/e0/6a/39f94ce520d5661866ba15c69264eec1af67ed8e757d5ba9c25ddf0c5577/pyobjc_framework_securityinterface-12.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:8741dff8c98a9cf585e5dd582c3fc2df124a0b5b885e9c128a53afb960b6e4fb", size = 10795, upload-time = "2026-05-30T12:24:06.026Z" }, - { url = "https://files.pythonhosted.org/packages/5e/9d/a18302f5aac77c33b8f3e6e6b529d3cca2d934c893c880b756c8bd6434d5/pyobjc_framework_securityinterface-12.2-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:d1e56bce8179bb4b5e71986162491423173c6178663e5ca9f1f5c4ac0a493adb", size = 11136, upload-time = "2026-05-30T12:24:07.847Z" }, + { url = "https://files.pythonhosted.org/packages/78/c0/b286689fca6dd23f1ad5185eb429a12fba60d157d7d53f6188c19475b331/pyobjc_framework_securityinterface-12.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:af5db06d53c92f05446600d241afab5aec6fec7ab10941b4eeb27a452c543b64", size = 10799, upload-time = "2025-11-14T10:03:22.296Z" }, + { url = "https://files.pythonhosted.org/packages/72/52/d378f25bb15f0d34e610f6cba50cedb0b99fdbae9bae9c0f0e715340f338/pyobjc_framework_securityinterface-12.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:08516c01954233fecb9bd203778b1bf559d427ccea26444ae1fa93691e751ddd", size = 11139, upload-time = "2025-11-14T10:03:24.17Z" }, ] [[package]] name = "pyobjc-framework-securityui" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-cocoa" }, { name = "pyobjc-framework-security" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/c6/f0/bd802a0bca727076fc117b57046a953bbf57cb41656fda917ebf066f287f/pyobjc_framework_securityui-12.2.tar.gz", hash = "sha256:9ce580490d7be95d7ef4b6cfdb9af80b62be486932a89aa402accc86596df934", size = 12587, upload-time = "2026-05-30T12:45:15.325Z" } +sdist = { url = "https://files.pythonhosted.org/packages/83/3f/d870305f5dec58cd02966ca06ac29b69fb045d8b46dfb64e2da31f295345/pyobjc_framework_securityui-12.1.tar.gz", hash = "sha256:f1435fed85edc57533c334a4efc8032170424b759da184cb7a7a950ceea0e0b6", size = 12184, upload-time = "2025-11-14T10:22:14.323Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/92/a5/db3bc24bd588cb704bb7db16f0f73177b0488c7577d676ced3932f1f41ee/pyobjc_framework_securityui-12.2-py2.py3-none-any.whl", hash = "sha256:d6cc86e9c039e8a1ac0227947277fb2b46ca2b9f9bb1fb7f7b081a3717ac045e", size = 3603, upload-time = "2026-05-30T12:24:16.206Z" }, + { url = "https://files.pythonhosted.org/packages/36/7f/eff9ffdd34511cc95a60e5bd62f1cfbcbcec1a5012ef1168161506628c87/pyobjc_framework_securityui-12.1-py2.py3-none-any.whl", hash = "sha256:3e988b83c9a2bb0393207eaa030fc023a8708a975ac5b8ea0508cdafc2b60705", size = 3594, upload-time = "2025-11-14T10:03:29.628Z" }, ] [[package]] name = "pyobjc-framework-sensitivecontentanalysis" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-cocoa" }, { name = "pyobjc-framework-quartz" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/03/f9/e18f459b2957f208718e7ff6a9f2715ad66509bb3bb1d4988d4c5820941b/pyobjc_framework_sensitivecontentanalysis-12.2.tar.gz", hash = "sha256:796d6cd3696daa7ac9116b35e7b2d520e86b687a8433443b755db8fd0cdd8315", size = 14411, upload-time = "2026-05-30T12:45:17.068Z" } +sdist = { url = "https://files.pythonhosted.org/packages/e7/ce/17bf31753e14cb4d64fffaaba2377453c4977c2c5d3cf2ff0a3db30026c7/pyobjc_framework_sensitivecontentanalysis-12.1.tar.gz", hash = "sha256:2c615ac10e93eb547b32b214cd45092056bee0e79696426fd09978dc3e670f25", size = 13745, upload-time = "2025-11-14T10:22:16.447Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/e1/37/3c92718706b58f76eeacbafc5d6ba1b09a5ff684cd8f47ee7b53dc139d70/pyobjc_framework_sensitivecontentanalysis-12.2-py2.py3-none-any.whl", hash = "sha256:5beb7d718e6dea0b17c14560ebaa3474f7aa349e412f974573cfae84cd7121b7", size = 4246, upload-time = "2026-05-30T12:24:17.732Z" }, + { url = "https://files.pythonhosted.org/packages/95/23/c99568a0d4e38bd8337d52e4ae25a0b0bd540577f2e06f3430c951d73209/pyobjc_framework_sensitivecontentanalysis-12.1-py2.py3-none-any.whl", hash = "sha256:faf19d32d4599ac2b18fb1ccdc3e33b2b242bdf34c02e69978bd62d3643ad068", size = 4230, upload-time = "2025-11-14T10:03:31.26Z" }, ] [[package]] name = "pyobjc-framework-servicemanagement" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-cocoa" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/b5/d6/c31e62d53305b30110cae00013b0947b5cec17ee77afe3e1376d5fe1ea1c/pyobjc_framework_servicemanagement-12.2.tar.gz", hash = "sha256:9c7b698f4354a36ad0448dccba57e724ac682a1276eef3971b8d85d7ac7a6488", size = 15263, upload-time = "2026-05-30T12:45:18.771Z" } +sdist = { url = "https://files.pythonhosted.org/packages/31/d0/b26c83ae96ab55013df5fedf89337d4d62311b56ce3f520fc7597d223d82/pyobjc_framework_servicemanagement-12.1.tar.gz", hash = "sha256:08120981749a698033a1d7a6ab99dbbe412c5c0d40f2b4154014b52113511c1d", size = 14585, upload-time = "2025-11-14T10:22:18.735Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/09/67/d02639a189926546ddd2afd5015c0a5574e8310c2a59633bff0ad2b90b2a/pyobjc_framework_servicemanagement-12.2-py2.py3-none-any.whl", hash = "sha256:fa8b9d3bcfd0d2e6feb0884f3a95fda9cd681baf0b0ca457ec3f611de9439f7f", size = 5427, upload-time = "2026-05-30T12:24:19.271Z" }, + { url = "https://files.pythonhosted.org/packages/ee/5d/1009c32189f9cb26da0124b4a60640ed26dd8ad453810594f0cbfab0ff70/pyobjc_framework_servicemanagement-12.1-py2.py3-none-any.whl", hash = "sha256:9a2941f16eeb71e55e1cd94f50197f91520778c7f48ad896761f5e78725cc08f", size = 5357, upload-time = "2025-11-14T10:03:32.928Z" }, ] [[package]] name = "pyobjc-framework-sharedwithyou" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-sharedwithyoucore" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/f6/bb/afb864c9b6835bae72d55208e52d79734a88d597edc89c437a717da34ef5/pyobjc_framework_sharedwithyou-12.2.tar.gz", hash = "sha256:215aefe1baee8d31dce55b38bd653cdecf0a74dddcf89277d64fcb8d6beafb9d", size = 27301, upload-time = "2026-05-30T12:45:21.174Z" } +sdist = { url = "https://files.pythonhosted.org/packages/0f/8b/8ab209a143c11575a857e2111acc5427fb4986b84708b21324cbcbf5591b/pyobjc_framework_sharedwithyou-12.1.tar.gz", hash = "sha256:167d84794a48f408ee51f885210c616fda1ec4bff3dd8617a4b5547f61b05caf", size = 24791, upload-time = "2025-11-14T10:22:21.248Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/22/2d/5df7613183733cb6d8bcb811d3b423cf97a24a12803cda0caaaa5018e5c1/pyobjc_framework_sharedwithyou-12.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:1e6d829807fb4edd2eaf5752319649b99a4574d359cd0742c71c7ec0037fec82", size = 8826, upload-time = "2026-05-30T12:24:25.996Z" }, - { url = "https://files.pythonhosted.org/packages/16/cc/5b5bb308f516f9ad75089595f3bf06eb08e1641cf4b66747473cb45bdf12/pyobjc_framework_sharedwithyou-12.2-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:ee9b7aba9c09b8f7c75982cfc714f16d2c8db9dff54eaba689b4ee51f84c2124", size = 8962, upload-time = "2026-05-30T12:24:27.619Z" }, + { url = "https://files.pythonhosted.org/packages/2e/51/e833c41cb6578f51623da361f6ded50b5b91331f9339b125ea50b4e62f8b/pyobjc_framework_sharedwithyou-12.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:491b35cdb3a0bc11e730c96d4109944c77ab153573a28220ff12d41d34dd9c0f", size = 8781, upload-time = "2025-11-14T10:03:40.14Z" }, + { url = "https://files.pythonhosted.org/packages/59/c4/b843dc3b7bd1385634df7f0bb8b557d8d09df3a384c7b2df0bc85af5bd4e/pyobjc_framework_sharedwithyou-12.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:50f0b32e2bf6f7ceb3af4422b015f674dc20a8cb1afa72d78f7e4186eb3710b9", size = 8917, upload-time = "2025-11-14T10:03:41.824Z" }, ] [[package]] name = "pyobjc-framework-sharedwithyoucore" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-cocoa" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/b0/02/4b1809c63319c277d88542576f86b7d7abcffd57ccd876d47d4623d6d5fb/pyobjc_framework_sharedwithyoucore-12.2.tar.gz", hash = "sha256:212bd551676cf0ae791eb8d7b5f6a4b10090e2d407721124d691e3020f709e51", size = 24303, upload-time = "2026-05-30T12:45:23.444Z" } +sdist = { url = "https://files.pythonhosted.org/packages/55/ef/84059c5774fd5435551ab7ab40b51271cfb9997b0d21f491c6b429fe57a8/pyobjc_framework_sharedwithyoucore-12.1.tar.gz", hash = "sha256:0813149eeb755d718b146ec9365eb4ca3262b6af9ff9ba7db2f7b6f4fd104518", size = 22350, upload-time = "2025-11-14T10:22:23.611Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/34/3e/913bc40fce99ee370c940261eb59d65bd4f9961354c5059bd4d5612e32b2/pyobjc_framework_sharedwithyoucore-12.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:3cc10c8a03892a3da8bff22235e31baa24a931f5bcd1994fc0124a197f14f70e", size = 8594, upload-time = "2026-05-30T12:24:40.949Z" }, - { url = "https://files.pythonhosted.org/packages/2e/94/67b218f72f4a6be6926691fc85266437edd7fcc837cec755a43bc0daa206/pyobjc_framework_sharedwithyoucore-12.2-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:0286e5dfb8bc9530de31b0e686d052019d91e17fff3ea35c0338ac62e23659b6", size = 8721, upload-time = "2026-05-30T12:24:42.525Z" }, + { url = "https://files.pythonhosted.org/packages/5e/23/2446cb158efe0f55d983ae7b4729b3b24c52a1370b5d22bc134f046cdb34/pyobjc_framework_sharedwithyoucore-12.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:13eebca21722556449e47b0eda3339165b5afbb455ae00b34aabe03988affd7a", size = 8547, upload-time = "2025-11-14T10:03:52.459Z" }, + { url = "https://files.pythonhosted.org/packages/8e/42/6c5de4e508a0c0f4715e3466c0035e23b5875d2a43525a6ed81e4770ad3c/pyobjc_framework_sharedwithyoucore-12.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:d9aa525cdff75005a8f0ca2f7afdd1535b9e34ccafb6a92a932f3ded4b6d64d4", size = 8677, upload-time = "2025-11-14T10:03:54.15Z" }, ] [[package]] name = "pyobjc-framework-shazamkit" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-cocoa" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/a1/c5/5cc4e2c0cb5e3fb3a3e3a4eb75aa85da70c5491125efef25e581516ec108/pyobjc_framework_shazamkit-12.2.tar.gz", hash = "sha256:9bfd2790b331b36ebdd9f80dab1fcc80b816ee19a1fb5ae981e5b4a8fb2e7084", size = 26080, upload-time = "2026-05-30T12:45:25.726Z" } +sdist = { url = "https://files.pythonhosted.org/packages/ed/2c/8d82c5066cc376de68ad8c1454b7c722c7a62215e5c2f9dac5b33a6c3d42/pyobjc_framework_shazamkit-12.1.tar.gz", hash = "sha256:71db2addd016874639a224ed32b2000b858802b0370c595a283cce27f76883fe", size = 22518, upload-time = "2025-11-14T10:22:25.996Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/f0/e4/837c888b09e330599601446b0da9ec3101ee1ad4250113c5f4a040ea76d1/pyobjc_framework_shazamkit-12.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:05b0f1efc47471a2962f947dcf764355086a37061307880ca4853df3d7d202df", size = 8648, upload-time = "2026-05-30T12:24:55.896Z" }, - { url = "https://files.pythonhosted.org/packages/a2/48/ca405138c3deae6a18b8750ab8b1e688add932e149ce234bb132b999e034/pyobjc_framework_shazamkit-12.2-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:ef389bb99ac4c74741fa1b08f4b08721cbeed3522f2d8e167a9105545d5d29f6", size = 8796, upload-time = "2026-05-30T12:24:57.441Z" }, + { url = "https://files.pythonhosted.org/packages/a9/fa/476cf0eb6f70e434056276b1a52bb47419e4b91d80e0c8e1190ce84f888f/pyobjc_framework_shazamkit-12.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:957c5e31b2b275c822ea43d7c4435fa1455c6dc5469ad4b86b29455571794027", size = 8587, upload-time = "2025-11-14T10:04:06.351Z" }, + { url = "https://files.pythonhosted.org/packages/9a/69/105fccda6c5ca32d35edc5e055d4cffc9aefe6a40fdd00bb21ec5d21e0ce/pyobjc_framework_shazamkit-12.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:eb2875ddf18d3cd2dc2b1327f58e142b9bd86fafd32078387ed867ec5a6c5571", size = 8734, upload-time = "2025-11-14T10:04:08.33Z" }, ] [[package]] name = "pyobjc-framework-social" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-cocoa" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/9e/8e/30527d2219e08e0d042c1190ffb64425aca051701f50823d5376a22bf573/pyobjc_framework_social-12.2.tar.gz", hash = "sha256:0f5e8c3e6bfd36f8c552b58b42d8d1ff4c8bf18c74776cdc3e830c272a904118", size = 13754, upload-time = "2026-05-30T12:45:27.614Z" } +sdist = { url = "https://files.pythonhosted.org/packages/31/21/afc6f37dfdd2cafcba0227e15240b5b0f1f4ad57621aeefda2985ac9560e/pyobjc_framework_social-12.1.tar.gz", hash = "sha256:1963db6939e92ae40dd9d68852e8f88111cbfd37a83a9fdbc9a0c08993ca7e60", size = 13184, upload-time = "2025-11-14T10:22:28.048Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/24/93/e8f2405693ca24878b1fe1cf58d4aa58b293f4e774af64a56aeba904b33b/pyobjc_framework_social-12.2-py2.py3-none-any.whl", hash = "sha256:d012f52721d694000b37999b2fed213332bf89e8a682f4d29656db4d8c6c7087", size = 4464, upload-time = "2026-05-30T12:25:05.261Z" }, + { url = "https://files.pythonhosted.org/packages/f6/fb/090867e332d49a1e492e4b8972ac6034d1c7d17cf39f546077f35be58c46/pyobjc_framework_social-12.1-py2.py3-none-any.whl", hash = "sha256:2f3b36ba5769503b1bc945f85fd7b255d42d7f6e417d78567507816502ff2b44", size = 4462, upload-time = "2025-11-14T10:04:14.578Z" }, ] [[package]] name = "pyobjc-framework-soundanalysis" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-cocoa" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/97/0a/19357da779f1b8942f69acfaa3f4568c0b117d6c1b5820af2a50d25dde31/pyobjc_framework_soundanalysis-12.2.tar.gz", hash = "sha256:37dee57e3f75121b690550601fc136e0931f3be56a87357cdfae7696886850fc", size = 15773, upload-time = "2026-05-30T12:45:29.585Z" } +sdist = { url = "https://files.pythonhosted.org/packages/6b/d6/5039b61edc310083425f87ce2363304d3a87617e941c1d07968c63b5638d/pyobjc_framework_soundanalysis-12.1.tar.gz", hash = "sha256:e2deead8b9a1c4513dbdcf703b21650dcb234b60a32d08afcec4895582b040b1", size = 14804, upload-time = "2025-11-14T10:22:29.998Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/23/8b/fb4db5583f5be6a5537baa1ecc39ae56f2bc1bdd6fc8dc7912e7c48b36fa/pyobjc_framework_soundanalysis-12.2-py2.py3-none-any.whl", hash = "sha256:d669deee79636bc6858e40039d5c9b4cca47af7b4cf042c787c52f39b5b5ab40", size = 4221, upload-time = "2026-05-30T12:25:06.842Z" }, + { url = "https://files.pythonhosted.org/packages/53/d3/8df5183d52d20d459225d3f5d24f55e01b8cd9fe587ed972e3f20dd18709/pyobjc_framework_soundanalysis-12.1-py2.py3-none-any.whl", hash = "sha256:8b2029ab48c1a9772f247f0aea995e8c3ff4706909002a9c1551722769343a52", size = 4188, upload-time = "2025-11-14T10:04:16.12Z" }, ] [[package]] name = "pyobjc-framework-speech" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-cocoa" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/5a/d7/b4c297150b863946fc4064dd927445d0539140524629e4d0b12f704577c0/pyobjc_framework_speech-12.2.tar.gz", hash = "sha256:14058f3ab48e29a68de5925297754a8bc6157b60c17cb24b3e8560290769e9aa", size = 27785, upload-time = "2026-05-30T12:45:32.009Z" } +sdist = { url = "https://files.pythonhosted.org/packages/8d/3d/194cf19fe7a56c2be5dfc28f42b3b597a62ebb1e1f52a7dd9c55b917ac6c/pyobjc_framework_speech-12.1.tar.gz", hash = "sha256:2a2a546ba6c52d5dd35ddcfee3fd9226a428043d1719597e8701851a6566afdd", size = 25218, upload-time = "2025-11-14T10:22:32.505Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/ce/bb/4262b2565e6fd0137b07b661a828acc48d65c6280124755feeac8fd1964b/pyobjc_framework_speech-12.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:4647b2775c3bdd3016fb5cce155dd03ca7a8f04902211868a68099511e8ea9f7", size = 9285, upload-time = "2026-05-30T12:25:13.879Z" }, - { url = "https://files.pythonhosted.org/packages/96/48/4071527182ef72ee5e31158cfbdf11d6f97265708e94a0a1ed138f2620e0/pyobjc_framework_speech-12.2-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:df58c5d6ec1ac5425565a1544659c8c45c78b0f7984ac50ff4590b5b6b872a5d", size = 9441, upload-time = "2026-05-30T12:25:15.502Z" }, + { url = "https://files.pythonhosted.org/packages/21/98/9ae05ebe183f35ac4bb769070f90533405d886fb9216e868e30a0e58d1ad/pyobjc_framework_speech-12.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:49df0ac39ae6fb44a83b2f4d7f500e0fa074ff58fbc53106d8f626d325079c23", size = 9274, upload-time = "2025-11-14T10:04:23.399Z" }, + { url = "https://files.pythonhosted.org/packages/ec/9d/41581c58ea8f8962189bcf6a15944f9a0bf36b46c5fce611a9632b3344a2/pyobjc_framework_speech-12.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:ed5455f6d9e473c08ebf904ae280ad5fd0d00a073448bf4f0a01fee5887c5537", size = 9430, upload-time = "2025-11-14T10:04:25.026Z" }, ] [[package]] name = "pyobjc-framework-spritekit" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-cocoa" }, { name = "pyobjc-framework-quartz" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/de/1d/84896e2233d2f90444e3be44282ad6e8600b485ce96c37566ed5bd255204/pyobjc_framework_spritekit-12.2.tar.gz", hash = "sha256:75e8fd8040f77c7585247004b9c59971de84cbcb707070f391c8508888750565", size = 83896, upload-time = "2026-05-30T12:45:37.754Z" } +sdist = { url = "https://files.pythonhosted.org/packages/b6/78/d683ebe0afb49f46d2d21d38c870646e7cb3c2e83251f264e79d357b1b74/pyobjc_framework_spritekit-12.1.tar.gz", hash = "sha256:a851f4ef5aa65cc9e08008644a528e83cb31021a1c0f17ebfce4de343764d403", size = 64470, upload-time = "2025-11-14T10:22:37.569Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/9e/39/abc521893bd60cf5b88ece0091e83fd30717c58a2dbce712d9d9da2e5b3b/pyobjc_framework_spritekit-12.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:d8ce3c810728a0a54f0af3063ed7ae45a8d0ae6c5a5ba405d02d08cf2c2bc6e5", size = 18645, upload-time = "2026-05-30T12:25:30.826Z" }, - { url = "https://files.pythonhosted.org/packages/ec/44/aaa0c92b8bf0b9b32c13fc62fdf506e3a868f3451670291441fe008bf9e9/pyobjc_framework_spritekit-12.2-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:a8a68b20f5377ee1530f752bb693388a3dcc085b1c2cdaf6930427d1cf5791a4", size = 18914, upload-time = "2026-05-30T12:25:32.947Z" }, + { url = "https://files.pythonhosted.org/packages/1f/c6/0e62700fbc90ab57170931fb5056d964202d49efd4d07a610fdaa28ffcfa/pyobjc_framework_spritekit-12.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:dd6847cb7a287c42492ffd7c30bc08165f4fbb51b2602290e001c0d27e0aa0f0", size = 17818, upload-time = "2025-11-14T10:04:37.804Z" }, + { url = "https://files.pythonhosted.org/packages/a6/22/26b19fc487913d9324cbba824841c9ac921aa9bdd6e340ed46b9968547bc/pyobjc_framework_spritekit-12.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:dd6e309aa284fa9b434aa7bf8ab9ab23fe52e7a372e2db3869586a74471f3419", size = 18088, upload-time = "2025-11-14T10:04:39.973Z" }, ] [[package]] name = "pyobjc-framework-storekit" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-cocoa" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/29/ce/3c5e9ee38040e4770af6aafa0fd11080b34a20dc2c718d2524db5b048bce/pyobjc_framework_storekit-12.2.tar.gz", hash = "sha256:f50699484da541b9d028503441bcb745eeff0becadc75556783aaf76b8764975", size = 40947, upload-time = "2026-05-30T12:45:41.165Z" } +sdist = { url = "https://files.pythonhosted.org/packages/00/87/8a66a145feb026819775d44975c71c1c64df4e5e9ea20338f01456a61208/pyobjc_framework_storekit-12.1.tar.gz", hash = "sha256:818452e67e937a10b5c8451758274faa44ad5d4329df0fa85735115fb0608da9", size = 34574, upload-time = "2025-11-14T10:22:40.73Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/1b/b7/16adfa4c5aedad949ea10a751c60e343745afe889706bb8d71491ff57732/pyobjc_framework_storekit-12.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:94d2daae9e5166cfa9d694acb2e51bf1d3856cf7ce6c74a84e13d80dbe6915ec", size = 12894, upload-time = "2026-05-30T12:25:48.888Z" }, - { url = "https://files.pythonhosted.org/packages/39/c9/bcf7f4c1087b7f83d190335d2149e8ecd5591064419ea820dac09b47bf4b/pyobjc_framework_storekit-12.2-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:922da8a72885d79c3c30dd3d36e9a966dcdd642c08f258b4b099a3f0e3ded643", size = 13091, upload-time = "2026-05-30T12:25:50.719Z" }, + { url = "https://files.pythonhosted.org/packages/5a/84/d354fd6f50952148614597dd4ebd52ed1d6a3e38cbd5d88e930bd549983d/pyobjc_framework_storekit-12.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:556c3dc187646ab8bda714a7e5630201b931956b81b0162ba420c64f55e5faaf", size = 12835, upload-time = "2025-11-14T10:04:52.866Z" }, + { url = "https://files.pythonhosted.org/packages/4f/24/f8a8d2f1c1107a0a0f85bd830b9e0ff7016d4530924b17787cb8c7bf4f4c/pyobjc_framework_storekit-12.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:15d4643bc4de4aa62f72efcb7a4930bd7e15280867be225bd2c582b3367d75ae", size = 13028, upload-time = "2025-11-14T10:04:55.605Z" }, ] [[package]] name = "pyobjc-framework-symbols" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-cocoa" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/50/06/042965972619d440c69037105764accd700053c658dbcbc2914ba4682ab5/pyobjc_framework_symbols-12.2.tar.gz", hash = "sha256:06c00d97047ee79fad95f95380d308c6dc1200d688cf4adf954382d65f138b10", size = 14785, upload-time = "2026-05-30T12:45:43.191Z" } +sdist = { url = "https://files.pythonhosted.org/packages/9a/ce/a48819eb8524fa2dc11fb3dd40bb9c4dcad0596fe538f5004923396c2c6c/pyobjc_framework_symbols-12.1.tar.gz", hash = "sha256:7d8e999b8a59c97d38d1d343b6253b1b7d04bf50b665700957d89c8ac43b9110", size = 12782, upload-time = "2025-11-14T10:22:42.609Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/6d/de/168b3925a76417978e5bc5921c8ac0a278e5a672302a20ca10f18d317695/pyobjc_framework_symbols-12.2-py2.py3-none-any.whl", hash = "sha256:abc83c18ef8733897667d0b4d79400e3c38828347985bcad4aaf40b0cd61c94a", size = 3526, upload-time = "2026-05-30T12:25:59.498Z" }, + { url = "https://files.pythonhosted.org/packages/f0/ea/6e9af9c750d68109ac54fbffb5463e33a7b54ffe8b9901a5b6b603b7884b/pyobjc_framework_symbols-12.1-py2.py3-none-any.whl", hash = "sha256:c72eecbc25f6bfcd39c733067276270057c5aca684be20fdc56def645f2b6446", size = 3331, upload-time = "2025-11-14T10:05:01.333Z" }, ] [[package]] name = "pyobjc-framework-syncservices" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-cocoa" }, { name = "pyobjc-framework-coredata" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/f3/e4/ac36cf4a79c52c865d92b148b024ee0fcda7e9efa45017cc64654558654b/pyobjc_framework_syncservices-12.2.tar.gz", hash = "sha256:354f7aab848d4f2ce055886a083d07be752ebedf5fe1dcb3cbedd489fd4bfa05", size = 34830, upload-time = "2026-05-30T12:45:46.067Z" } +sdist = { url = "https://files.pythonhosted.org/packages/21/91/6d03a988831ddb0fb001b13573560e9a5bcccde575b99350f98fe56a2dd4/pyobjc_framework_syncservices-12.1.tar.gz", hash = "sha256:6a213e93d9ce15128810987e4c5de8c73cfab1564ac8d273e6b437a49965e976", size = 31032, upload-time = "2025-11-14T10:22:45.902Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/60/1c/1ef02418ff43f53ac9ef49035b34fcdf664fcd5632d3d796cafddd01fd57/pyobjc_framework_syncservices-12.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:a9ff8eb0475033f24434b1dfd7f77a8c458f9ef7ed692e59b9e5a26c22692e0d", size = 13429, upload-time = "2026-05-30T12:26:07.387Z" }, - { url = "https://files.pythonhosted.org/packages/21/ea/df2f2e636b8616ccb4c8d2b15ddd29275245ba60a7666dc9287b4fe977a5/pyobjc_framework_syncservices-12.2-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:10c1dff31d1499b618b3741956219577f2254b04df2fbf10a65a49ed3ff3dff2", size = 13599, upload-time = "2026-05-30T12:26:09.354Z" }, + { url = "https://files.pythonhosted.org/packages/5b/e3/9a6bd76529feffe08a3f6b2962c9a96d75febc02453881ec81389ff9ac13/pyobjc_framework_syncservices-12.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:606afac9255b5bf828f1dcf7b0d7bdc7726021b686ad4f5743978eb4086902d9", size = 13425, upload-time = "2025-11-14T10:05:09.692Z" }, + { url = "https://files.pythonhosted.org/packages/3b/5d/338850a31968b94417ba95a7b94db9fcd40b16011eaf82f757de7c1eba6c/pyobjc_framework_syncservices-12.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:9d1ebe60e92efd08455be209a265879cf297feda831aadf36431f38229b1dd52", size = 13599, upload-time = "2025-11-14T10:05:11.732Z" }, ] [[package]] name = "pyobjc-framework-systemconfiguration" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-cocoa" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/a3/de/30ce4e5e41d2bc965b5598ba4f3595ac3eaa088e26cc99d519f68d62c7b9/pyobjc_framework_systemconfiguration-12.2.tar.gz", hash = "sha256:017bb958c436b6aa90e04a99fe3fdce3787e8c1db80d165ff0071273bdbf242f", size = 63332, upload-time = "2026-05-30T12:45:50.691Z" } +sdist = { url = "https://files.pythonhosted.org/packages/90/7d/50848df8e1c6b5e13967dee9fb91d3391fe1f2399d2d0797d2fc5edb32ba/pyobjc_framework_systemconfiguration-12.1.tar.gz", hash = "sha256:90fe04aa059876a21626931c71eaff742a27c79798a46347fd053d7008ec496e", size = 59158, upload-time = "2025-11-14T10:22:53.056Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/ce/e3/fb4e684f873347039ea5136c0a5f7a0ae18ce7b4caaee8508e013fd47f03/pyobjc_framework_systemconfiguration-12.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:d0b290b3cfd77fde1f4234590afa0be7785c02ff2cd5b591ef8d07e2cd0caecd", size = 21533, upload-time = "2026-05-30T12:26:26.467Z" }, - { url = "https://files.pythonhosted.org/packages/26/0e/948a070637f7f0ffcf2dd3b5a323c77694a1ed0ae04e54dd4fddea9cfac2/pyobjc_framework_systemconfiguration-12.2-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:d4b81bb37f365891a14bb4a09d735784a0bbe2c594b89a1cb87e17f1db7abac8", size = 21946, upload-time = "2026-05-30T12:26:28.795Z" }, + { url = "https://files.pythonhosted.org/packages/64/26/22f031c99fd7012dffa41455951004a758aaf9a25216b3a4ee83496bc44f/pyobjc_framework_systemconfiguration-12.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:359b35c00f52f57834169c1057522279201ac5a64ac5b4d90dbafa40ad6c54b4", size = 21575, upload-time = "2025-11-14T10:05:28.396Z" }, + { url = "https://files.pythonhosted.org/packages/f2/58/648803bdf3d2ebd3221ef43deb008c77aefe0bec231af2aa67e5b29a78e2/pyobjc_framework_systemconfiguration-12.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:f4ff57defb4dcd933db392eb8ea9e5a46005cb7a6f2b46c27ab2dd5e13a459ab", size = 21990, upload-time = "2025-11-14T10:05:30.875Z" }, ] [[package]] name = "pyobjc-framework-systemextensions" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-cocoa" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/9c/4a/49dd15416665943fe08999c3d5d8675c6dc153c720b9cc17e83215350a46/pyobjc_framework_systemextensions-12.2.tar.gz", hash = "sha256:2ec1edcd9d12451ef74969eae546b4661514381d7d60221240560ca9a743f506", size = 21675, upload-time = "2026-05-30T12:45:52.904Z" } +sdist = { url = "https://files.pythonhosted.org/packages/12/01/8a706cd3f7dfcb9a5017831f2e6f9e5538298e90052db3bb8163230cbc4f/pyobjc_framework_systemextensions-12.1.tar.gz", hash = "sha256:243e043e2daee4b5c46cd90af5fff46b34596aac25011bab8ba8a37099685eeb", size = 20701, upload-time = "2025-11-14T10:22:58.257Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/dd/76/f9490cb2be6a6c06ba2132a50d33d368dd90a917284a712614eec818c08b/pyobjc_framework_systemextensions-12.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:dc3c41d413a867483511edbd3332d3a13fa0011119fadf0e4c642ea1b97b7bec", size = 9217, upload-time = "2026-05-30T12:26:45.252Z" }, - { url = "https://files.pythonhosted.org/packages/db/4c/a9e07ceece91b207e2554166675f299f05b0fe9af93868b91eaeedfeb2d0/pyobjc_framework_systemextensions-12.2-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:8c131f836a61df9064020382b6b1b80965799ae44cdb197ef4696167e0796bf2", size = 9375, upload-time = "2026-05-30T12:26:46.809Z" }, + { url = "https://files.pythonhosted.org/packages/dd/ef/fd34784added1dff088bd18cc2694049b0893b01e835587eab1735fd68f3/pyobjc_framework_systemextensions-12.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:038032801d46cc7b1ea69400f43d5c17b25d7a16efa7a7d9727b25789387a8cf", size = 9185, upload-time = "2025-11-14T10:05:43.136Z" }, + { url = "https://files.pythonhosted.org/packages/72/76/fd6f06e54299998677548bacd21105450bc6435df215a6620422a31b0099/pyobjc_framework_systemextensions-12.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:2aea4e823d915abca463b1c091ff969cef09108c88b71b68569485dec6f3651d", size = 9345, upload-time = "2025-11-14T10:05:44.814Z" }, ] [[package]] name = "pyobjc-framework-threadnetwork" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-cocoa" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/ce/e6/8b1744871062c39cce64d43ab20b11344ef5f1b93993c1b737da2faa3acd/pyobjc_framework_threadnetwork-12.2.tar.gz", hash = "sha256:2d7df5938094e3aa93210a079ebf3e801a20c84a3b759573ddf05ec2c2cbf083", size = 13327, upload-time = "2026-05-30T12:45:54.674Z" } +sdist = { url = "https://files.pythonhosted.org/packages/62/7e/f1816c3461e4121186f2f7750c58af083d1826bbd73f72728da3edcf4915/pyobjc_framework_threadnetwork-12.1.tar.gz", hash = "sha256:e071eedb41bfc1b205111deb54783ec5a035ccd6929e6e0076336107fdd046ee", size = 12788, upload-time = "2025-11-14T10:23:00.329Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/a4/7e/dfa9e914c1f192d6afdb504efc01f5aac777a73d43cfe103896bb5072ee2/pyobjc_framework_threadnetwork-12.2-py2.py3-none-any.whl", hash = "sha256:08c7a03e11c60dca7b3f219db744986b90b8797d61b6842e0c0bad192e723f48", size = 3805, upload-time = "2026-05-30T12:26:54.517Z" }, + { url = "https://files.pythonhosted.org/packages/4f/b8/94b37dd353302c051a76f1a698cf55b5ad50ca061db7f0f332aa9e195766/pyobjc_framework_threadnetwork-12.1-py2.py3-none-any.whl", hash = "sha256:07d937748fc54199f5ec04d5a408e8691a870481c11b641785c2adc279dd8e4b", size = 3771, upload-time = "2025-11-14T10:05:49.899Z" }, ] [[package]] name = "pyobjc-framework-uniformtypeidentifiers" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-cocoa" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/64/54/e270da2b0b4ab1fb0dc7f4e616d1a6e141583f88409c0742f6ebfcf7a064/pyobjc_framework_uniformtypeidentifiers-12.2.tar.gz", hash = "sha256:19cc82f1bbf3bc0999597779711422f6c9d7340634d699ae64d9bc7c0d79f984", size = 20704, upload-time = "2026-05-30T12:45:56.773Z" } +sdist = { url = "https://files.pythonhosted.org/packages/65/b8/dd9d2a94509a6c16d965a7b0155e78edf520056313a80f0cd352413f0d0b/pyobjc_framework_uniformtypeidentifiers-12.1.tar.gz", hash = "sha256:64510a6df78336579e9c39b873cfcd03371c4b4be2cec8af75a8a3d07dff607d", size = 17030, upload-time = "2025-11-14T10:23:02.222Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/da/19/4f314697bc8f519fe6505afe51d83d7fdcae93239b7bab5941f4bebc1f9e/pyobjc_framework_uniformtypeidentifiers-12.2-py2.py3-none-any.whl", hash = "sha256:f140a378cfe6a8ca47ce3b04fd5a4c4bec1fcbedac8acc87e2c18985bb805203", size = 5019, upload-time = "2026-05-30T12:26:56.001Z" }, + { url = "https://files.pythonhosted.org/packages/4e/5f/1f10f5275b06d213c9897850f1fca9c881c741c1f9190cea6db982b71824/pyobjc_framework_uniformtypeidentifiers-12.1-py2.py3-none-any.whl", hash = "sha256:ec5411e39152304d2a7e0e426c3058fa37a00860af64e164794e0bcffee813f2", size = 4901, upload-time = "2025-11-14T10:05:51.532Z" }, ] [[package]] name = "pyobjc-framework-usernotifications" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-cocoa" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/5a/c3/f1d43ac73b5fce42a00bcb68ac53edd7180217df60a25985e2477c9c389b/pyobjc_framework_usernotifications-12.2.tar.gz", hash = "sha256:b7773e84fe40e746f706055267ba2b1dc9e0a34e6575719f1e515354f72583a0", size = 33908, upload-time = "2026-05-30T12:45:59.61Z" } +sdist = { url = "https://files.pythonhosted.org/packages/90/cd/e0253072f221fa89a42fe53f1a2650cc9bf415eb94ae455235bd010ee12e/pyobjc_framework_usernotifications-12.1.tar.gz", hash = "sha256:019ccdf2d400f9a428769df7dba4ea97c02453372bc5f8b75ce7ae54dfe130f9", size = 29749, upload-time = "2025-11-14T10:23:05.364Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/dd/e3/a962cbd3739cbb01b2b5697e336babb15307fb473500524bd7e730446b7e/pyobjc_framework_usernotifications-12.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:dbc51fc214446f622b4670bca7efb8969ad84cdee21672da3c872fa3aff5aff5", size = 10198, upload-time = "2026-05-30T12:27:02.504Z" }, - { url = "https://files.pythonhosted.org/packages/dd/8e/2a44292fc4e96682054f74a1aab1c303fa5caf5820e5cd67b0d23b52750f/pyobjc_framework_usernotifications-12.2-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:e329301b42181a95c2ac5f71491529ac1260afa9b26b16a104db275bbafdcb18", size = 10357, upload-time = "2026-05-30T12:27:04.132Z" }, + { url = "https://files.pythonhosted.org/packages/b1/cc/4c6efe6a65b1742ea238734f81509ceba5346b45f605baa809ca63f30692/pyobjc_framework_usernotifications-12.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:40a5457f4157ca007f80f0644413f44f0dc141f7864b28e1728623baf56a8539", size = 9659, upload-time = "2025-11-14T10:05:58.763Z" }, + { url = "https://files.pythonhosted.org/packages/06/4e/02ff6975567974f360cf0e1e358236026e35f7ba7795511bc4dcbaa13f62/pyobjc_framework_usernotifications-12.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:58c09bd1bd7a8cd29613d0d0e6096eda6c8465dc5a7a733675e1b8d0406f7adc", size = 9811, upload-time = "2025-11-14T10:06:00.775Z" }, ] [[package]] name = "pyobjc-framework-usernotificationsui" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-cocoa" }, { name = "pyobjc-framework-usernotifications" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/4b/5f/d58600259b0b99ff3745eef91570d0ced05fa1b26083f2846082acc15249/pyobjc_framework_usernotificationsui-12.2.tar.gz", hash = "sha256:8c3298cddd27be794ad46a2783304b6fb1f0ad4d65933c34ba3e43e58ecdb406", size = 13462, upload-time = "2026-05-30T12:46:01.549Z" } +sdist = { url = "https://files.pythonhosted.org/packages/0e/03/73e29fd5e5973cb3800c9d56107c1062547ef7524cbcc757c3cbbd5465c6/pyobjc_framework_usernotificationsui-12.1.tar.gz", hash = "sha256:51381c97c7344099377870e49ed0871fea85ba50efe50ab05ccffc06b43ec02e", size = 13125, upload-time = "2025-11-14T10:23:07.259Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/c6/29/f4413e1941e153a770b2d85faee4d3a4f9be67b69f5823f63db8dd091356/pyobjc_framework_usernotificationsui-12.2-py2.py3-none-any.whl", hash = "sha256:a5d92117c2d18e2b6365f5e39daf45a68491a66ac9103b1bc94df43b8868c256", size = 3930, upload-time = "2026-05-30T12:27:12.318Z" }, + { url = "https://files.pythonhosted.org/packages/23/c8/52ac8a879079c1fbf25de8335ff506f7db87ff61e64838b20426f817f5d5/pyobjc_framework_usernotificationsui-12.1-py2.py3-none-any.whl", hash = "sha256:11af59dc5abfcb72c08769ab4d7ca32a628527a8ba341786431a0d2dacf31605", size = 3933, upload-time = "2025-11-14T10:06:05.478Z" }, ] [[package]] name = "pyobjc-framework-videosubscriberaccount" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-cocoa" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/42/3d/cace0ae1dd453f9da495311675d4fabe7adf89e94e7b99e26f45ba0fa713/pyobjc_framework_videosubscriberaccount-12.2.tar.gz", hash = "sha256:821f5485545238fd997dc26aff8ab2c838b43d664a7ec6a030ba67b09c2b799d", size = 21360, upload-time = "2026-05-30T12:46:03.619Z" } +sdist = { url = "https://files.pythonhosted.org/packages/10/f8/27927a9c125c622656ee5aada4596ccb8e5679da0260742360f193df6dcf/pyobjc_framework_videosubscriberaccount-12.1.tar.gz", hash = "sha256:750459fa88220ab83416f769f2d5d210a1f77b8938fa4d119aad0002fc32846b", size = 18793, upload-time = "2025-11-14T10:23:09.33Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/d3/03/f3b0c4ed85b4883d5fcd48ba2efd807507c3a5ce7c3aa7d4366dce81f503/pyobjc_framework_videosubscriberaccount-12.2-py2.py3-none-any.whl", hash = "sha256:b158b03e1432dc229fabc96451f5ac8db5ab228792354f0f26419a973777c700", size = 4866, upload-time = "2026-05-30T12:27:14.012Z" }, + { url = "https://files.pythonhosted.org/packages/41/ca/e2f982916267508c1594f1e50d27bf223a24f55a5e175ab7d7822a00997c/pyobjc_framework_videosubscriberaccount-12.1-py2.py3-none-any.whl", hash = "sha256:381a5e8a3016676e52b88e38b706559fa09391d33474d8a8a52f20a883104a7b", size = 4825, upload-time = "2025-11-14T10:06:07.027Z" }, ] [[package]] name = "pyobjc-framework-videotoolbox" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, @@ -6022,29 +6043,29 @@ dependencies = [ { name = "pyobjc-framework-coremedia" }, { name = "pyobjc-framework-quartz" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/f3/2c/af5a91d12bb265697fb13ccdbac7068e04e8f40c36139b314ea477982aa3/pyobjc_framework_videotoolbox-12.2.tar.gz", hash = "sha256:33d0838f706c771667b0be5737036d303b677bb243ba64df9ea2fa6860ea9f76", size = 64923, upload-time = "2026-05-30T12:46:08.377Z" } +sdist = { url = "https://files.pythonhosted.org/packages/b3/5f/6995ee40dc0d1a3460ee183f696e5254c0ad14a25b5bc5fd9bd7266c077b/pyobjc_framework_videotoolbox-12.1.tar.gz", hash = "sha256:7adc8670f3b94b086aed6e86c3199b388892edab4f02933c2e2d9b1657561bef", size = 57825, upload-time = "2025-11-14T10:23:13.825Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/c9/08/48b4af0452930b1865dee4e847113d5b6d2530a19ad111b6f551d8b5bd8a/pyobjc_framework_videotoolbox-12.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:3393990f9f566dadada78b06c134bcefcabd50731b5322110759e0d26d9ca280", size = 18999, upload-time = "2026-05-30T12:27:22.983Z" }, - { url = "https://files.pythonhosted.org/packages/48/11/d111f5d93f88f0d4d7150d318a6e089b0e08196cc29bdcae3c6af7c9891b/pyobjc_framework_videotoolbox-12.2-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:06dea99b364c3628037332c5fbffcb341f32a4cc7acd0ea4813a83b78fe1f70c", size = 19209, upload-time = "2026-05-30T12:27:25.22Z" }, + { url = "https://files.pythonhosted.org/packages/f0/59/7fc3d67df437f3e263b477dd181eef3ac3430cb7eb1acc951f5f1e84cc4d/pyobjc_framework_videotoolbox-12.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:ca28b39e22016eb5f81f540102a575ee6e6114074d09e17e22eb3b5647976d93", size = 18929, upload-time = "2025-11-14T10:06:16.418Z" }, + { url = "https://files.pythonhosted.org/packages/f4/41/08b526d2f228271994f8216651d2e5c8e76415224daa012e67c53c90fc7a/pyobjc_framework_videotoolbox-12.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:dba7e078df01432331ee75a90c2c147264bfdb9e31998b4e4fc28913b93b832e", size = 19139, upload-time = "2025-11-14T10:06:18.602Z" }, ] [[package]] name = "pyobjc-framework-virtualization" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-cocoa" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/1a/b4/16c8280c717f393e524e32de93bcb18952ca852ebbf5aaed38dac68d2e01/pyobjc_framework_virtualization-12.2.tar.gz", hash = "sha256:021249f0cd72e4756dfba096bda0e9ebd9294ba7738f1bdbb2742e461ac5671e", size = 49152, upload-time = "2026-05-30T12:46:12.317Z" } +sdist = { url = "https://files.pythonhosted.org/packages/3b/6a/9d110b5521d9b898fad10928818c9f55d66a4af9ac097426c65a9878b095/pyobjc_framework_virtualization-12.1.tar.gz", hash = "sha256:e96afd8e801e92c6863da0921e40a3b68f724804f888bce43791330658abdb0f", size = 40682, upload-time = "2025-11-14T10:23:17.456Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/46/90/a2e2a3676286359dcf4d5898652e904925006dba0eca959759472be37651/pyobjc_framework_virtualization-12.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:48667f1318bdc3e3599123dafb1d9df3369a6d8d3a64fb36f9eaf86ef2ea4808", size = 13617, upload-time = "2026-05-30T12:27:41.616Z" }, - { url = "https://files.pythonhosted.org/packages/9d/22/3e04b58c4a1ecc27518a8c5b8ca13cea7b74106928b1bd130a0564cb54a6/pyobjc_framework_virtualization-12.2-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:68e8989bf2cfb294116cdfd583d6ac092f9209ccca2af5b79fb697adbdae4653", size = 13821, upload-time = "2026-05-30T12:27:43.448Z" }, + { url = "https://files.pythonhosted.org/packages/76/ca/228fffccbeafecbe7599fc2cdaa64bf2a8e42fd8fe619c5b670c92b263c3/pyobjc_framework_virtualization-12.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:232956de8a0c3086a58c96621e0a2148497d1750ebb1bb6bea9f7f34ec3c83c6", size = 13147, upload-time = "2025-11-14T10:06:31.294Z" }, + { url = "https://files.pythonhosted.org/packages/b3/2f/4e56147bc9963bb7f96886fda376004a66c5abe579dc029180952fd872fa/pyobjc_framework_virtualization-12.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:a9552e49b967fb520e5be1cfce510e0b68c2ba314a28ac90aad36fe33218d430", size = 13351, upload-time = "2025-11-14T10:06:33.189Z" }, ] [[package]] name = "pyobjc-framework-vision" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, @@ -6052,24 +6073,24 @@ dependencies = [ { name = "pyobjc-framework-coreml" }, { name = "pyobjc-framework-quartz" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/49/51/aed3761cfa2f0335a8fc4cdfa04c54b3fece5242745d5dd2370f38efcff5/pyobjc_framework_vision-12.2.tar.gz", hash = "sha256:0e90244f98ede5ec16ac129ed4bbd7cf0ec07247bac6f06e9cb612db23a68a3b", size = 72582, upload-time = "2026-05-30T12:46:17.468Z" } +sdist = { url = "https://files.pythonhosted.org/packages/c2/5a/08bb3e278f870443d226c141af14205ff41c0274da1e053b72b11dfc9fb2/pyobjc_framework_vision-12.1.tar.gz", hash = "sha256:a30959100e85dcede3a786c544e621ad6eb65ff6abf85721f805822b8c5fe9b0", size = 59538, upload-time = "2025-11-14T10:23:21.979Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/79/34/9c92c1d70a98818edb4e113f771bb264c2e7f08ec6bba501e0196c500dc4/pyobjc_framework_vision-12.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:df4d7d3ccdd723334ab62e6e2051d04e3554724be90102db353874938f101e05", size = 16938, upload-time = "2026-05-30T12:27:59.678Z" }, - { url = "https://files.pythonhosted.org/packages/16/a5/1cf2213da57b1941f788baf0505c3cc4c98fbbdcdf1ac3a19290331ca4d1/pyobjc_framework_vision-12.2-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:76737fa3440c504993995537643b6529d47c1affecba426f00c716cd93a07a9b", size = 17081, upload-time = "2026-05-30T12:28:01.972Z" }, + { url = "https://files.pythonhosted.org/packages/f5/e4/e87361a31b82b22f8c0a59652d6e17625870dd002e8da75cb2343a84f2f9/pyobjc_framework_vision-12.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:7273e2508db4c2e88523b4b7ff38ac54808756e7ba01d78e6c08ea68f32577d2", size = 16640, upload-time = "2025-11-14T10:06:46.653Z" }, + { url = "https://files.pythonhosted.org/packages/b1/dd/def55d8a80b0817f486f2712fc6243482c3264d373dc5ff75037b3aeb7ea/pyobjc_framework_vision-12.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:04296f0848cc8cdead66c76df6063720885cbdf24fdfd1900749a6e2297313db", size = 16782, upload-time = "2025-11-14T10:06:48.816Z" }, ] [[package]] name = "pyobjc-framework-webkit" -version = "12.2" +version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyobjc-core" }, { name = "pyobjc-framework-cocoa" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/06/ba/0e17f151d80854285a84b3c96f48d55b0c61ae683060a52cd50084ef4c64/pyobjc_framework_webkit-12.2.tar.gz", hash = "sha256:498353fe812006f7fe2829a679018fcff3ed2684aa31c08d8a8af929ee9283b6", size = 332359, upload-time = "2026-05-30T12:46:37.677Z" } +sdist = { url = "https://files.pythonhosted.org/packages/14/10/110a50e8e6670765d25190ca7f7bfeecc47ec4a8c018cb928f4f82c56e04/pyobjc_framework_webkit-12.1.tar.gz", hash = "sha256:97a54dd05ab5266bd4f614e41add517ae62cdd5a30328eabb06792474b37d82a", size = 284531, upload-time = "2025-11-14T10:23:40.287Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/f7/32/bea045cf4e2c697ea9b68ed7d60b0e765a8b0e46d30a4eb26bf178be817c/pyobjc_framework_webkit-12.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:9fafcbf5a071cf9ad3fbc28155a99287ff9dc9efcaa41fe3ed3d79b6e5576450", size = 50367, upload-time = "2026-05-30T12:28:28.846Z" }, - { url = "https://files.pythonhosted.org/packages/bc/3e/d29fc44f6d346a5a97883ae76bfa030a5b6ff3b019bafd58ad8ea14588d2/pyobjc_framework_webkit-12.2-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:751f3138441c81fdddc555f0bd31f5f3ad3ec72ae2ed626af24925ce32054353", size = 50840, upload-time = "2026-05-30T12:28:32.75Z" }, + { url = "https://files.pythonhosted.org/packages/7a/3d/80d36280164c69220ce99372f7736a028617c207e42cb587716009eecb88/pyobjc_framework_webkit-12.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:1da0c428c9d9891c93e0de51c9f272bfeb96d34356cdf3136cb4ad56ce32ec2d", size = 50096, upload-time = "2025-11-14T10:07:10.027Z" }, + { url = "https://files.pythonhosted.org/packages/8a/7a/03c29c46866e266b0c705811c55c22625c349b0a80f5cf4776454b13dc4c/pyobjc_framework_webkit-12.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:1a29e334d5a7dd4a4f0b5647481b6ccf8a107b92e67b2b3c6b368c899f571965", size = 50572, upload-time = "2025-11-14T10:07:14.232Z" }, ] [[package]] @@ -6150,12 +6171,6 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/5a/dc/491b7661614ab97483abf2056be1deee4dc2490ecbf7bff9ab5cdbac86e1/pyreadline3-3.5.4-py3-none-any.whl", hash = "sha256:eaf8e6cc3c49bcccf145fc6067ba8643d1df34d604a1ec0eccbf7a18e6d3fae6", size = 83178, upload-time = "2024-09-19T02:40:08.598Z" }, ] -[[package]] -name = "pyrfr" -version = "0.9.0" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/17/c3/88ec42a429a8d439c912b42ca86c2686ca5a9ad60313a8e1f05728515ee7/pyrfr-0.9.0.tar.gz", hash = "sha256:bc6e758317cf79579fe6b7ce5f01dd42f77c991bf707e33646e8c6a9112c186b", size = 295099, upload-time = "2023-02-16T16:43:33.11Z" } - [[package]] name = "pytest" version = "9.0.2" @@ -6273,12 +6288,12 @@ wheels = [ [[package]] name = "pywin32" -version = "312" +version = "311" source = { registry = "https://pypi.org/simple" } wheels = [ - { url = "https://files.pythonhosted.org/packages/2d/41/12fbfd7f36ed2146d8bc9de96c2741296bf0d490b98508496cff322e274c/pywin32-312-cp313-cp313-win32.whl", hash = "sha256:7a27df850933d16a8eabfbaeb73d52b273e2da667f80d70b01a89d1f6828d02c", size = 6370184, upload-time = "2026-06-04T07:49:36.253Z" }, - { url = "https://files.pythonhosted.org/packages/ba/db/36a78e3403099d31d9746d13fdcde5accc43c1155f375a34d15983a479a7/pywin32-312-cp313-cp313-win_amd64.whl", hash = "sha256:c53e878d15a1c44788082bfe712a905433473aa38f86375b7cf8b45e3acbaaf9", size = 6914298, upload-time = "2026-06-04T07:49:38.876Z" }, - { url = "https://files.pythonhosted.org/packages/84/37/c1697194092b76de9ed47ca124323f02c57ffc8a45c06f88a3d5acaf01eb/pywin32-312-cp313-cp313-win_arm64.whl", hash = "sha256:59aba5d5940842075343a5ddc6b11f1cdf0d1567fe745290359dfbcc7c2eb831", size = 6727640, upload-time = "2026-06-04T07:49:41.083Z" }, + { url = "https://files.pythonhosted.org/packages/a5/be/3fd5de0979fcb3994bfee0d65ed8ca9506a8a1260651b86174f6a86f52b3/pywin32-311-cp313-cp313-win32.whl", hash = "sha256:f95ba5a847cba10dd8c4d8fefa9f2a6cf283b8b88ed6178fa8a6c1ab16054d0d", size = 8705700, upload-time = "2025-07-14T20:13:26.471Z" }, + { url = "https://files.pythonhosted.org/packages/e3/28/e0a1909523c6890208295a29e05c2adb2126364e289826c0a8bc7297bd5c/pywin32-311-cp313-cp313-win_amd64.whl", hash = "sha256:718a38f7e5b058e76aee1c56ddd06908116d35147e133427e59a3983f703a20d", size = 9494700, upload-time = "2025-07-14T20:13:28.243Z" }, + { url = "https://files.pythonhosted.org/packages/04/bf/90339ac0f55726dce7d794e6d79a18a91265bdf3aa70b6b9ca52f35e022a/pywin32-311-cp313-cp313-win_arm64.whl", hash = "sha256:7b4075d959648406202d92a2310cb990fea19b535c7f4a78d3f5e10b926eeb8a", size = 8709318, upload-time = "2025-07-14T20:13:30.348Z" }, ] [[package]] @@ -6440,15 +6455,15 @@ wheels = [ [[package]] name = "rich" -version = "15.0.0" +version = "14.3.3" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "markdown-it-py" }, { name = "pygments" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/c0/8f/0722ca900cc807c13a6a0c696dacf35430f72e0ec571c4275d2371fca3e9/rich-15.0.0.tar.gz", hash = "sha256:edd07a4824c6b40189fb7ac9bc4c52536e9780fbbfbddf6f1e2502c31b068c36", size = 230680, upload-time = "2026-04-12T08:24:00.75Z" } +sdist = { url = "https://files.pythonhosted.org/packages/b3/c6/f3b320c27991c46f43ee9d856302c70dc2d0fb2dba4842ff739d5f46b393/rich-14.3.3.tar.gz", hash = "sha256:b8daa0b9e4eef54dd8cf7c86c03713f53241884e814f4e2f5fb342fe520f639b", size = 230582, upload-time = "2026-02-19T17:23:12.474Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/82/3b/64d4899d73f91ba49a8c18a8ff3f0ea8f1c1d75481760df8c68ef5235bf5/rich-15.0.0-py3-none-any.whl", hash = "sha256:33bd4ef74232fb73fe9279a257718407f169c09b78a87ad3d296f548e27de0bb", size = 310654, upload-time = "2026-04-12T08:24:02.83Z" }, + { url = "https://files.pythonhosted.org/packages/14/25/b208c5683343959b670dc001595f2f3737e051da617f66c31f7c4fa93abc/rich-14.3.3-py3-none-any.whl", hash = "sha256:793431c1f8619afa7d3b52b2cdec859562b950ea0d4b6b505397612db8d5362d", size = 310458, upload-time = "2026-02-19T17:23:13.732Z" }, ] [[package]] @@ -6642,7 +6657,7 @@ wheels = [ [[package]] name = "smac" -version = "2.3.1" +version = "2.4.0" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "configspace" }, @@ -6653,24 +6668,25 @@ dependencies = [ { name = "numpy" }, { name = "psutil" }, { name = "pynisher" }, - { name = "pyrfr" }, { name = "pyyaml" }, { name = "regex" }, { name = "scikit-learn" }, { name = "scipy" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/27/88/68a964bfa4d07bd9902c0e81f625aa76d04bcb62802ad2c832c0c1c69cf3/smac-2.3.1.tar.gz", hash = "sha256:c23c574b0a9d084f77490a9975e2160dadccc4f4992f5c20867e9a655ea13bf2", size = 166135, upload-time = "2025-03-20T15:27:01.352Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/01/3f/1154b649c899f134006b8fb1e79e1a7cccafde7e2ee6b6064023773c4dab/smac-2.4.0-py3-none-any.whl", hash = "sha256:670fb21b812f2130fc5b07d31a9da51821685c5edcccacc9720a199291273b2c", size = 278108, upload-time = "2026-04-22T19:25:23.114Z" }, +] [[package]] name = "smart-open" -version = "7.6.1" +version = "7.5.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "wrapt" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/c5/65/3ada667d32675399001bf022ad3d9f3989b57101351ebc71d6fbe2384634/smart_open-7.6.1.tar.gz", hash = "sha256:4347996e7ba21db7cd1e059632e0b30395407e4f6c660d2ddffc8f2a9ae5f990", size = 54754, upload-time = "2026-05-09T06:23:37.06Z" } +sdist = { url = "https://files.pythonhosted.org/packages/e8/be/a66598b305763861a9ab15ff0f2fbc44e47b1ce7a776797337a4eef37c66/smart_open-7.5.1.tar.gz", hash = "sha256:3f08e16827c4733699e6b2cc40328a3568f900cb12ad9a3ad233ba6c872d9fe7", size = 54034, upload-time = "2026-02-23T11:01:28.979Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/14/78/0f68b93564b8c6b6987a0696c582ba2591a381ab2f733a501909e949f241/smart_open-7.6.1-py3-none-any.whl", hash = "sha256:b4de6aebef023aca91cc9fb372052e1343ba3f152de215bd22391a663e3ddd21", size = 64845, upload-time = "2026-05-09T06:23:35.386Z" }, + { url = "https://files.pythonhosted.org/packages/5e/ea/dcdecd68acebb49d3fd560473a43499b1635076f7f1ae8641c060fe7ce74/smart_open-7.5.1-py3-none-any.whl", hash = "sha256:3e07cbbd9c8a908bcb8e25d48becf1a5cbb4886fa975e9f34c672ed171df2318", size = 64108, upload-time = "2026-02-23T11:01:27.429Z" }, ] [[package]] @@ -6711,7 +6727,7 @@ wheels = [ [[package]] name = "spacy" -version = "3.8.14" +version = "3.8.13" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "catalogue" }, @@ -6734,14 +6750,16 @@ dependencies = [ { name = "wasabi" }, { name = "weasel" }, ] +sdist = { url = "https://files.pythonhosted.org/packages/63/d7/1924f32272f50d2f13275f16d6f869fcec47b2b676b64f91fa206bd30ef4/spacy-3.8.13.tar.gz", hash = "sha256:eb7c03c2bb16593c34d4c91974118f0931c6e6969dbfe895b1a026c6714176cf", size = 1328016, upload-time = "2026-03-23T17:44:32.042Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/1b/e5/822bbdfa459fee863ef2e9879a34b0ae5db7cd1e3eb76d32c766f19222e9/spacy-3.8.14-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:2b4f60fa8b9641a5e93e7a96db0cdd106d05d61756bf1d0ddcd1705ad347909a", size = 6202114, upload-time = "2026-03-29T10:41:06.119Z" }, - { url = "https://files.pythonhosted.org/packages/7e/de/0e512154113e1f341567f2b9341835775e4180c180221e60faedaebb2f65/spacy-3.8.14-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:0860c57220c633ccb20468bcd64bfb0d28908990c371a8857951d093a148dc8e", size = 6015458, upload-time = "2026-03-29T10:41:07.79Z" }, - { url = "https://files.pythonhosted.org/packages/0c/4f/29c7e56afc7db07348a9e0efe0243b5eef465d5dc3d56433f164378c3fa6/spacy-3.8.14-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:c24620b7dba879c69cebc51ef3b1107d4d4e44a1e0d4baa439372887d00c3fd9", size = 32510659, upload-time = "2026-03-29T10:41:09.88Z" }, - { url = "https://files.pythonhosted.org/packages/1e/ce/cae678f664d5467016819253f5d6e52f8e68a12d8e799b651d73ec2a9a4b/spacy-3.8.14-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:9699c1248d115d5825987c287a6f6acd66386ef3ebee7994ee67ba093e932c59", size = 32841057, upload-time = "2026-03-29T10:41:12.585Z" }, - { url = "https://files.pythonhosted.org/packages/04/d4/419868afd449bdd367df005932537eea66c71e97c899ba278f3124933f3c/spacy-3.8.14-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:042d799e342fdb6bb5b02a4213a95acc9116c40ed3c849bb0a8296fbe648ec22", size = 31763252, upload-time = "2026-03-29T10:41:15.569Z" }, - { url = "https://files.pythonhosted.org/packages/ec/53/df5c1fee45f200b749ba72eeb536fbb2c545fc56230324954263b2f3be00/spacy-3.8.14-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:69b2264294097336e86832e8663f1ab3a7215621184863c96c082ab17ee11937", size = 32717872, upload-time = "2026-03-29T10:41:18.193Z" }, - { url = "https://files.pythonhosted.org/packages/12/c2/f1882ec2f5cc9c4e73cf2132997a03c397d7ceeb5ee7f7bb878b51a16365/spacy-3.8.14-cp313-cp313-win_amd64.whl", hash = "sha256:4b6d4f20e291a7c70e37de2f246622b44a0ce82efaa710c9801c6bd599e75177", size = 14220335, upload-time = "2026-03-29T10:41:20.89Z" }, + { url = "https://files.pythonhosted.org/packages/a7/2d/dc15440fa58c12bab25cbd368bbf3b754eb11d1d3cc37f3aee47caa63695/spacy-3.8.13-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:6db8903cf3fd8b40db9dab669c1e823a8884100f223dc8ec63c3744ff505d5fd", size = 6202080, upload-time = "2026-03-23T17:43:25.044Z" }, + { url = "https://files.pythonhosted.org/packages/1b/27/6d723fa0c3c9872d7b8c3fb1c76edef65c1db2de441ee87d119128cb82f7/spacy-3.8.13-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:c26258bfed2f3bf5563c5994ee752ea8662bbac70924d28fbea4d1c10df48fd0", size = 6015435, upload-time = "2026-03-23T17:43:28.281Z" }, + { url = "https://files.pythonhosted.org/packages/c0/36/d13f36204290e7753ce849106fb732a1a1ff6c1af0a200f2c2f493a56e60/spacy-3.8.13-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:a5f02eab8e6e8e9e790b1e8da05b70b3b1d4b1fb10dc4f44203da96939fdb977", size = 32510675, upload-time = "2026-03-23T17:43:32.657Z" }, + { url = "https://files.pythonhosted.org/packages/19/37/f2a0c986bc2d59b18547d5ffaabf57fd9d88e129ad7df5ebc9ccdc91e643/spacy-3.8.13-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:17b14f28d83fe85390f420f89760ae36d515f3e0a236f8266c46335549806e3a", size = 32841103, upload-time = "2026-03-23T17:43:38.139Z" }, + { url = "https://files.pythonhosted.org/packages/37/31/b4a86cc013e4ac3c3c290ecade748c4623709a78db8a368ee0e152931c0b/spacy-3.8.13-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:10fffb387e6afeba582e01efd9b5e0c5431ac323af134f4a71a749255182f4c8", size = 31763223, upload-time = "2026-03-23T17:43:42.823Z" }, + { url = "https://files.pythonhosted.org/packages/4f/fa/b3a406bdc2636aaa315b8539b88f262e78ca391afc4083e3e9806953b24a/spacy-3.8.13-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:500f6eb9e4711e75fc07d517962dbfb553ba144ccf1b1e8ffc71b014c9ad91b2", size = 32717863, upload-time = "2026-03-23T17:43:47.939Z" }, + { url = "https://files.pythonhosted.org/packages/d9/97/11ed2a980e7225b0a1a4041cb1cba44f40bd83682a08e450dd6171f054e4/spacy-3.8.13-cp313-cp313-win_amd64.whl", hash = "sha256:1e679a8c5dd86c564a1185d894b1b8e50b52fa81bee518120fc2f86349d1879c", size = 14220413, upload-time = "2026-03-23T17:43:51.922Z" }, + { url = "https://files.pythonhosted.org/packages/ca/e2/06633e779486f62b3ec7ddeeb4accc10fb9a356b59f5bed3771dfb89931b/spacy-3.8.13-cp313-cp313-win_arm64.whl", hash = "sha256:c086bff909d73be892b4eb6883070dd3e328592b8933f0059a6569c8c7904928", size = 13619060, upload-time = "2026-03-23T17:43:55.449Z" }, ] [[package]] @@ -6830,11 +6848,11 @@ wheels = [ [[package]] name = "std-uritemplate" -version = "2.0.10" +version = "2.0.8" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/74/45/575604653c42b26eb693a6564cfbcf38ea8eb1feaa0a1f85df1a0d995a4b/std_uritemplate-2.0.10.tar.gz", hash = "sha256:35048a322217aed9766fdffe5a69f0632f7319577a4a265268761cd4ffa3205e", size = 6146, upload-time = "2026-05-20T14:49:56.888Z" } +sdist = { url = "https://files.pythonhosted.org/packages/93/62/61866776cd32df3f984ff2f79b1428e10700e0a33ca7a7536e3fcba3cf2a/std_uritemplate-2.0.8.tar.gz", hash = "sha256:138ceff2c5bfef18a650372a5e8c82fe7f780c87235513de6c342fb5f7e18347", size = 6018, upload-time = "2025-10-16T15:51:29.774Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/79/5b/86b48580bcebff823102978c36c15eaaca45f2f0c74001dc39e759ff5d10/std_uritemplate-2.0.10-py3-none-any.whl", hash = "sha256:bc93137c5718216aaaf6e5a016ce24cb6e356512cedb66182b1f835bc57a55cb", size = 6671, upload-time = "2026-05-20T14:49:58.319Z" }, + { url = "https://files.pythonhosted.org/packages/64/97/b4f2f442fee92a1406f08b4fbc990bd7d02dc84b3b5e6315a59fa9b2a9f4/std_uritemplate-2.0.8-py3-none-any.whl", hash = "sha256:839807a7f9d07f0bad1a88977c3428bd97b9ff0d229412a0bf36123d8c724257", size = 6512, upload-time = "2025-10-16T15:51:28.713Z" }, ] [[package]] @@ -6908,28 +6926,28 @@ wheels = [ [[package]] name = "tiktoken" -version = "0.13.0" +version = "0.12.0" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "regex" }, { name = "requests" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/e4/e5/5f3cb2159769d0f4324c0e9e87f9de3c4b1cd45848a96b2eb3566ad5ca77/tiktoken-0.13.0.tar.gz", hash = "sha256:c9435714c3a84c2319499de9a300c0e604449dd0799ff246458b3bb6a7f433c1", size = 38986, upload-time = "2026-05-15T04:51:27.153Z" } +sdist = { url = "https://files.pythonhosted.org/packages/7d/ab/4d017d0f76ec3171d469d80fc03dfbb4e48a4bcaddaa831b31d526f05edc/tiktoken-0.12.0.tar.gz", hash = "sha256:b18ba7ee2b093863978fcb14f74b3707cdc8d4d4d3836853ce7ec60772139931", size = 37806, upload-time = "2025-10-06T20:22:45.419Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/9c/83/b096c859c2a47c11731bf2f5885f4028b809dfe2396582883eed9cae372f/tiktoken-0.13.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:5df5d1507bd245f1ccad4a074698240021239e455eb0bb4ced4e3d7181872154", size = 1034228, upload-time = "2026-05-15T04:50:40.988Z" }, - { url = "https://files.pythonhosted.org/packages/53/61/c68e123b6d753e3fc2751e9b18e732c9d8bf1e1926762e736eee935d931c/tiktoken-0.13.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:8fe806a50664e83a6ffd56cbd1e4f5dcc6cd32a3e7538f70dc38b1a271384545", size = 982978, upload-time = "2026-05-15T04:50:42.195Z" }, - { url = "https://files.pythonhosted.org/packages/ef/8b/96cc178cc584e65d363134500f297790b06cd48cdeb1e8fcf7bbe60f4715/tiktoken-0.13.0-cp313-cp313-manylinux_2_28_aarch64.whl", hash = "sha256:125bc05005e747f993a83dc67934249932d6e4209854452cd4c0b1d53fba3ba2", size = 1116355, upload-time = "2026-05-15T04:50:43.564Z" }, - { url = "https://files.pythonhosted.org/packages/86/f5/bab735d2c72ea55404b295d02d092644eb5f7cc6205e34d35eb9abfb9ab2/tiktoken-0.13.0-cp313-cp313-manylinux_2_28_x86_64.whl", hash = "sha256:5e6358911cab4adee6712da27d65573496a4f68cf8a2b5fca6a4ad10fc5748cf", size = 1135772, upload-time = "2026-05-15T04:50:44.782Z" }, - { url = "https://files.pythonhosted.org/packages/4e/b9/6de04ebdf904edfaad87788011b3735087a0c9ea671b9027e1e4e965e8c8/tiktoken-0.13.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:975cbd78d085d75d26b59660e262736dcaed1e35f8f142cd6291025c01d25486", size = 1182415, upload-time = "2026-05-15T04:50:46.422Z" }, - { url = "https://files.pythonhosted.org/packages/0d/9c/470a05f3b1caf038f44880e334d47ab674e0c80d514c66b375d14d5afa10/tiktoken-0.13.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:75ab9bc99fa020a4c283424590ecd7f3afd70c1c281cb3fa3192a6c3af9f9615", size = 1239879, upload-time = "2026-05-15T04:50:48.052Z" }, - { url = "https://files.pythonhosted.org/packages/42/a6/c1936d16055436cb32e6c6128d68629622e00f4768562f55653752d34768/tiktoken-0.13.0-cp313-cp313-win_amd64.whl", hash = "sha256:6b1615f0ff71953d19729ceb18865429c185b0a23c5353f1bbca34a394bf60f7", size = 874829, upload-time = "2026-05-15T04:50:49.202Z" }, - { url = "https://files.pythonhosted.org/packages/d6/07/acb5992c3772b5a36284f742cfb7a5895aa4471d1848ac31464ad50d7fdf/tiktoken-0.13.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:6eb4a5bfbc6426938026b1a334e898ac53541360d62d8c689870160cc80abd67", size = 1033600, upload-time = "2026-05-15T04:50:50.4Z" }, - { url = "https://files.pythonhosted.org/packages/14/e9/742e9aec30f59b9f161f7ff7cd072e02ea836c9e1c0854a8076dfcd40d5c/tiktoken-0.13.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:43cee3e5400573b2046fbf092cc7a5bc30164f9e4c95ce20714da929df48737a", size = 982516, upload-time = "2026-05-15T04:50:52.03Z" }, - { url = "https://files.pythonhosted.org/packages/72/74/ca1541b053e7648254d2e4b42a253e1bb4359f2c91a0a8d49228c794e1a0/tiktoken-0.13.0-cp313-cp313t-manylinux_2_28_aarch64.whl", hash = "sha256:7de52e3f566d19b3b11bd37eea552c6c305ad74081f736882bd44d148ed4c48d", size = 1115518, upload-time = "2026-05-15T04:50:53.543Z" }, - { url = "https://files.pythonhosted.org/packages/46/e3/93825eaf5a4a504795b787e5d5dea07fbeb3dabf97aa7b450be8bde59c89/tiktoken-0.13.0-cp313-cp313t-manylinux_2_28_x86_64.whl", hash = "sha256:51384448aa508e4df84c0f7c1dc3211c7f7b8096325660ee5fc82f3e11b381ce", size = 1136867, upload-time = "2026-05-15T04:50:55.191Z" }, - { url = "https://files.pythonhosted.org/packages/8c/46/002b68de6827091d5ae90b048f326e8aad8d953520950e5ce1508879414f/tiktoken-0.13.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:e28157350f7ebf35008dd8e9e0fdb621f976e4230c881099c85e8cf07eaa50e2", size = 1181826, upload-time = "2026-05-15T04:50:56.296Z" }, - { url = "https://files.pythonhosted.org/packages/db/c6/d393e3185a276505182f7abd93fe714f3c444a2be9180798fa052347504e/tiktoken-0.13.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:165cf1820ea4a354985c2490a5205d4cc74661c934aca79dd0368232fff94e0f", size = 1239489, upload-time = "2026-05-15T04:50:57.918Z" }, - { url = "https://files.pythonhosted.org/packages/b7/4d/bc07d1f1635d4897a202acc0ae11c2886eaa7325c359ba4741b47bf8e225/tiktoken-0.13.0-cp313-cp313t-win_amd64.whl", hash = "sha256:6c43a675ca14f6f2749ba7f12075d37456015a24b859f2517b9beb4ef30807ec", size = 873820, upload-time = "2026-05-15T04:50:59.528Z" }, + { url = "https://files.pythonhosted.org/packages/00/61/441588ee21e6b5cdf59d6870f86beb9789e532ee9718c251b391b70c68d6/tiktoken-0.12.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:775c2c55de2310cc1bc9a3ad8826761cbdc87770e586fd7b6da7d4589e13dab3", size = 1050802, upload-time = "2025-10-06T20:22:00.96Z" }, + { url = "https://files.pythonhosted.org/packages/1f/05/dcf94486d5c5c8d34496abe271ac76c5b785507c8eae71b3708f1ad9b45a/tiktoken-0.12.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:a01b12f69052fbe4b080a2cfb867c4de12c704b56178edf1d1d7b273561db160", size = 993995, upload-time = "2025-10-06T20:22:02.788Z" }, + { url = "https://files.pythonhosted.org/packages/a0/70/5163fe5359b943f8db9946b62f19be2305de8c3d78a16f629d4165e2f40e/tiktoken-0.12.0-cp313-cp313-manylinux_2_28_aarch64.whl", hash = "sha256:01d99484dc93b129cd0964f9d34eee953f2737301f18b3c7257bf368d7615baa", size = 1128948, upload-time = "2025-10-06T20:22:03.814Z" }, + { url = "https://files.pythonhosted.org/packages/0c/da/c028aa0babf77315e1cef357d4d768800c5f8a6de04d0eac0f377cb619fa/tiktoken-0.12.0-cp313-cp313-manylinux_2_28_x86_64.whl", hash = "sha256:4a1a4fcd021f022bfc81904a911d3df0f6543b9e7627b51411da75ff2fe7a1be", size = 1151986, upload-time = "2025-10-06T20:22:05.173Z" }, + { url = "https://files.pythonhosted.org/packages/a0/5a/886b108b766aa53e295f7216b509be95eb7d60b166049ce2c58416b25f2a/tiktoken-0.12.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:981a81e39812d57031efdc9ec59fa32b2a5a5524d20d4776574c4b4bd2e9014a", size = 1194222, upload-time = "2025-10-06T20:22:06.265Z" }, + { url = "https://files.pythonhosted.org/packages/f4/f8/4db272048397636ac7a078d22773dd2795b1becee7bc4922fe6207288d57/tiktoken-0.12.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:9baf52f84a3f42eef3ff4e754a0db79a13a27921b457ca9832cf944c6be4f8f3", size = 1255097, upload-time = "2025-10-06T20:22:07.403Z" }, + { url = "https://files.pythonhosted.org/packages/8e/32/45d02e2e0ea2be3a9ed22afc47d93741247e75018aac967b713b2941f8ea/tiktoken-0.12.0-cp313-cp313-win_amd64.whl", hash = "sha256:b8a0cd0c789a61f31bf44851defbd609e8dd1e2c8589c614cc1060940ef1f697", size = 879117, upload-time = "2025-10-06T20:22:08.418Z" }, + { url = "https://files.pythonhosted.org/packages/ce/76/994fc868f88e016e6d05b0da5ac24582a14c47893f4474c3e9744283f1d5/tiktoken-0.12.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:d5f89ea5680066b68bcb797ae85219c72916c922ef0fcdd3480c7d2315ffff16", size = 1050309, upload-time = "2025-10-06T20:22:10.939Z" }, + { url = "https://files.pythonhosted.org/packages/f6/b8/57ef1456504c43a849821920d582a738a461b76a047f352f18c0b26c6516/tiktoken-0.12.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:b4e7ed1c6a7a8a60a3230965bdedba8cc58f68926b835e519341413370e0399a", size = 993712, upload-time = "2025-10-06T20:22:12.115Z" }, + { url = "https://files.pythonhosted.org/packages/72/90/13da56f664286ffbae9dbcfadcc625439142675845baa62715e49b87b68b/tiktoken-0.12.0-cp313-cp313t-manylinux_2_28_aarch64.whl", hash = "sha256:fc530a28591a2d74bce821d10b418b26a094bf33839e69042a6e86ddb7a7fb27", size = 1128725, upload-time = "2025-10-06T20:22:13.541Z" }, + { url = "https://files.pythonhosted.org/packages/05/df/4f80030d44682235bdaecd7346c90f67ae87ec8f3df4a3442cb53834f7e4/tiktoken-0.12.0-cp313-cp313t-manylinux_2_28_x86_64.whl", hash = "sha256:06a9f4f49884139013b138920a4c393aa6556b2f8f536345f11819389c703ebb", size = 1151875, upload-time = "2025-10-06T20:22:14.559Z" }, + { url = "https://files.pythonhosted.org/packages/22/1f/ae535223a8c4ef4c0c1192e3f9b82da660be9eb66b9279e95c99288e9dab/tiktoken-0.12.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:04f0e6a985d95913cabc96a741c5ffec525a2c72e9df086ff17ebe35985c800e", size = 1194451, upload-time = "2025-10-06T20:22:15.545Z" }, + { url = "https://files.pythonhosted.org/packages/78/a7/f8ead382fce0243cb625c4f266e66c27f65ae65ee9e77f59ea1653b6d730/tiktoken-0.12.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:0ee8f9ae00c41770b5f9b0bb1235474768884ae157de3beb5439ca0fd70f3e25", size = 1253794, upload-time = "2025-10-06T20:22:16.624Z" }, + { url = "https://files.pythonhosted.org/packages/93/e0/6cc82a562bc6365785a3ff0af27a2a092d57c47d7a81d9e2295d8c36f011/tiktoken-0.12.0-cp313-cp313t-win_amd64.whl", hash = "sha256:dc2dd125a62cb2b3d858484d6c614d136b5b848976794edfb63688d539b8b93f", size = 878777, upload-time = "2025-10-06T20:22:18.036Z" }, ] [[package]] @@ -7043,19 +7061,19 @@ wheels = [ [[package]] name = "tornado" -version = "6.5.7" +version = "6.5.5" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/64/24/95ec527ad67b76d59299e5465b3935d05e4294b7e0290a3924b7487df30b/tornado-6.5.7.tar.gz", hash = "sha256:66c513a76cda70d53907bc27cf1447557699c2e95aa48ba27a442ff61c3ddfc2", size = 519252, upload-time = "2026-06-08T17:34:51.232Z" } +sdist = { url = "https://files.pythonhosted.org/packages/f8/f1/3173dfa4a18db4a9b03e5d55325559dab51ee653763bb8745a75af491286/tornado-6.5.5.tar.gz", hash = "sha256:192b8f3ea91bd7f1f50c06955416ed76c6b72f96779b962f07f911b91e8d30e9", size = 516006, upload-time = "2026-03-10T21:31:02.067Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/02/dc/c7043cab6fed8ae159fc1923ce829ada35c4dbd797d408a43858ffaf9639/tornado-6.5.7-cp39-abi3-macosx_10_9_universal2.whl", hash = "sha256:148b2eb15c2c765a50796172c1e499649b35f30d2e3c3d3e15913cfa56bfb163", size = 448543, upload-time = "2026-06-08T17:34:38.052Z" }, - { url = "https://files.pythonhosted.org/packages/92/4f/090b1431e5a43df696feceffc268c5383cc079ecb5f08ce58f917109aafe/tornado-6.5.7-cp39-abi3-macosx_10_9_x86_64.whl", hash = "sha256:9da38de27f1da3b78a966f0dae12b5a1ea9afe72ca805d84ff06508272ddf100", size = 446707, upload-time = "2026-06-08T17:34:39.594Z" }, - { url = "https://files.pythonhosted.org/packages/37/d8/ef374952fd5da67d4463122c2b8e5a96536ec10b4b339254c6dcde81d01c/tornado-6.5.7-cp39-abi3-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:8d759e71906ee783f8867b93bf26a265743da4c1e2f4a018464c1ba019862972", size = 449774, upload-time = "2026-06-08T17:34:41.204Z" }, - { url = "https://files.pythonhosted.org/packages/35/37/d434c73f4c6e014b745b9b37085f34f40c022f007efff3d7fe65991899f3/tornado-6.5.7-cp39-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8a46347a18f23fb92b396beebe0fb78f61dda0cc302445202c16203d8a18848b", size = 450745, upload-time = "2026-06-08T17:34:42.531Z" }, - { url = "https://files.pythonhosted.org/packages/b6/2b/56b9aff361d7f1ab728a805ec7d7ea835f8807afa9f5cc690ea0e630efb9/tornado-6.5.7-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:7778b30bef919231265e91c69963ce0f49a1e9c07ac900bbe75b19ce2575ba92", size = 450578, upload-time = "2026-06-08T17:34:43.787Z" }, - { url = "https://files.pythonhosted.org/packages/02/30/a7444fb23aa76860a14198fab96ac79f1866b0a6e19e26c4381b0938e50f/tornado-6.5.7-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:e726f0c75da7726eec023aa62751ff8878bd2737e34fbdd33b1ae5897d2200f5", size = 449985, upload-time = "2026-06-08T17:34:45.326Z" }, - { url = "https://files.pythonhosted.org/packages/5c/42/5f0e56c01e8d9d36f4e23f367b85ae6cae0c1ecddd5e6977d8388ad27488/tornado-6.5.7-cp39-abi3-win32.whl", hash = "sha256:f8de3bf12d3efdd0cbe7c8887868198f8a91415e3f29fcf258d9b8eb7b1d9ae4", size = 451047, upload-time = "2026-06-08T17:34:46.784Z" }, - { url = "https://files.pythonhosted.org/packages/c9/a4/b393076ffb21b469eec5b328a0534cf03a3b90bfc6b1f09507cdd075d938/tornado-6.5.7-cp39-abi3-win_amd64.whl", hash = "sha256:de942f843533a039ef9fa3d9c88c7cd8a7c94553fb5ad0154270989b3d99a2c4", size = 451485, upload-time = "2026-06-08T17:34:48.248Z" }, - { url = "https://files.pythonhosted.org/packages/71/2e/7b1c769803121b809112cf9a00681c472eae1d80e32d7ec0e0bd61d0d0e1/tornado-6.5.7-cp39-abi3-win_arm64.whl", hash = "sha256:ff934fce95643af5f11efdae618eaa73d469dc588641e5c8d19295a0c65c4796", size = 450506, upload-time = "2026-06-08T17:34:49.702Z" }, + { url = "https://files.pythonhosted.org/packages/59/8c/77f5097695f4dd8255ecbd08b2a1ed8ba8b953d337804dd7080f199e12bf/tornado-6.5.5-cp39-abi3-macosx_10_9_universal2.whl", hash = "sha256:487dc9cc380e29f58c7ab88f9e27cdeef04b2140862e5076a66fb6bb68bb1bfa", size = 445983, upload-time = "2026-03-10T21:30:44.28Z" }, + { url = "https://files.pythonhosted.org/packages/ab/5e/7625b76cd10f98f1516c36ce0346de62061156352353ef2da44e5c21523c/tornado-6.5.5-cp39-abi3-macosx_10_9_x86_64.whl", hash = "sha256:65a7f1d46d4bb41df1ac99f5fcb685fb25c7e61613742d5108b010975a9a6521", size = 444246, upload-time = "2026-03-10T21:30:46.571Z" }, + { url = "https://files.pythonhosted.org/packages/b2/04/7b5705d5b3c0fab088f434f9c83edac1573830ca49ccf29fb83bf7178eec/tornado-6.5.5-cp39-abi3-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:e74c92e8e65086b338fd56333fb9a68b9f6f2fe7ad532645a290a464bcf46be5", size = 447229, upload-time = "2026-03-10T21:30:48.273Z" }, + { url = "https://files.pythonhosted.org/packages/34/01/74e034a30ef59afb4097ef8659515e96a39d910b712a89af76f5e4e1f93c/tornado-6.5.5-cp39-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:435319e9e340276428bbdb4e7fa732c2d399386d1de5686cb331ec8eee754f07", size = 448192, upload-time = "2026-03-10T21:30:51.22Z" }, + { url = "https://files.pythonhosted.org/packages/be/00/fe9e02c5a96429fce1a1d15a517f5d8444f9c412e0bb9eadfbe3b0fc55bf/tornado-6.5.5-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:3f54aa540bdbfee7b9eb268ead60e7d199de5021facd276819c193c0fb28ea4e", size = 448039, upload-time = "2026-03-10T21:30:53.52Z" }, + { url = "https://files.pythonhosted.org/packages/82/9e/656ee4cec0398b1d18d0f1eb6372c41c6b889722641d84948351ae19556d/tornado-6.5.5-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:36abed1754faeb80fbd6e64db2758091e1320f6bba74a4cf8c09cd18ccce8aca", size = 447445, upload-time = "2026-03-10T21:30:55.541Z" }, + { url = "https://files.pythonhosted.org/packages/5a/76/4921c00511f88af86a33de770d64141170f1cfd9c00311aea689949e274e/tornado-6.5.5-cp39-abi3-win32.whl", hash = "sha256:dd3eafaaeec1c7f2f8fdcd5f964e8907ad788fe8a5a32c4426fbbdda621223b7", size = 448582, upload-time = "2026-03-10T21:30:57.142Z" }, + { url = "https://files.pythonhosted.org/packages/2c/23/f6c6112a04d28eed765e374435fb1a9198f73e1ec4b4024184f21faeb1ad/tornado-6.5.5-cp39-abi3-win_amd64.whl", hash = "sha256:6443a794ba961a9f619b1ae926a2e900ac20c34483eea67be4ed8f1e58d3ef7b", size = 448990, upload-time = "2026-03-10T21:30:58.857Z" }, + { url = "https://files.pythonhosted.org/packages/b7/c8/876602cbc96469911f0939f703453c1157b0c826ecb05bdd32e023397d4e/tornado-6.5.5-cp39-abi3-win_arm64.whl", hash = "sha256:2c9a876e094109333f888539ddb2de4361743e5d21eece20688e3e351e4990a6", size = 448016, upload-time = "2026-03-10T21:31:00.43Z" }, ] [[package]] @@ -7072,11 +7090,11 @@ wheels = [ [[package]] name = "traitlets" -version = "5.15.1" +version = "5.14.3" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/57/a9/a2584b8313b89f94869ddb3c4074617a691de1812a614d2d50e32ca5a7a6/traitlets-5.15.1.tar.gz", hash = "sha256:7b1c07854fe25acb39e009bae49f11b79ff6cbb2f27999104e9110e7a6b53722", size = 163344, upload-time = "2026-06-03T12:26:06.181Z" } +sdist = { url = "https://files.pythonhosted.org/packages/eb/79/72064e6a701c2183016abbbfedaba506d81e30e232a68c9f0d6f6fcd1574/traitlets-5.14.3.tar.gz", hash = "sha256:9ed0579d3502c94b4b3732ac120375cda96f923114522847de4b3bb98b96b6b7", size = 161621, upload-time = "2024-04-19T11:11:49.746Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/96/8d/1080ee4c231f361b6ce4470d556c8c435b67c7e0753aaa641497ee92f88b/traitlets-5.15.1-py3-none-any.whl", hash = "sha256:770a53705f84b81ac107e83a1b3328ff2dae16094d8fc3cfc004e4b22dfd8e92", size = 85858, upload-time = "2026-06-03T12:26:04.395Z" }, + { url = "https://files.pythonhosted.org/packages/00/c0/8f5d070730d7836adc9c9b6408dec68c6ced86b304a9b26a14df072a6e8c/traitlets-5.14.3-py3-none-any.whl", hash = "sha256:b74e89e397b1ed28cc831db7aea759ba6640cb3de13090ca145426688ff1ac4f", size = 85359, upload-time = "2024-04-19T11:11:46.763Z" }, ] [[package]] @@ -7127,17 +7145,17 @@ wheels = [ [[package]] name = "typer" -version = "0.26.7" +version = "0.24.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "annotated-doc" }, - { name = "colorama", marker = "sys_platform == 'win32'" }, + { name = "click" }, { name = "rich" }, { name = "shellingham" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/5e/ed/ef06584ccdd5c410df0837951ecd7e15d9a6144ea1bd4c73cecab1a89891/typer-0.26.7.tar.gz", hash = "sha256:e314a34c617e419c091b2830dda3ea1f257134ff593061a8f5b9717ab8dddb3a", size = 201709, upload-time = "2026-06-03T07:18:06.843Z" } +sdist = { url = "https://files.pythonhosted.org/packages/f5/24/cb09efec5cc954f7f9b930bf8279447d24618bb6758d4f6adf2574c41780/typer-0.24.1.tar.gz", hash = "sha256:e39b4732d65fbdcde189ae76cf7cd48aeae72919dea1fdfc16593be016256b45", size = 118613, upload-time = "2026-02-21T16:54:40.609Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/24/25/2201973529af2c954de0bb725323c3aaed6d7f0ceee8f550dec9185df013/typer-0.26.7-py3-none-any.whl", hash = "sha256:5c87cfbc5d34491c5346ebf49c23e18d56ccb863268d3a8d592b26087c2f5e58", size = 122456, upload-time = "2026-06-03T07:18:05.732Z" }, + { url = "https://files.pythonhosted.org/packages/4a/91/48db081e7a63bb37284f9fbcefda7c44c277b18b0e13fbc36ea2335b71e6/typer-0.24.1-py3-none-any.whl", hash = "sha256:112c1f0ce578bfb4cab9ffdabc68f031416ebcc216536611ba21f04e9aa84c9e", size = 56085, upload-time = "2026-02-21T16:54:41.616Z" }, ] [[package]] @@ -7361,38 +7379,24 @@ wheels = [ [[package]] name = "uuid-utils" -version = "0.16.0" +version = "0.14.1" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/01/a1/822ceef22d1c139cffebe4b1b660cfaa10253d5c770aa2598dc8e9497593/uuid_utils-0.16.0.tar.gz", hash = "sha256:d6902d4375dfba4c9902c736bb82d3c040417b67f7d0fa48910ddfdb1ac95de7", size = 42596, upload-time = "2026-05-19T07:44:23.28Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/60/9b/74c1f47a9b4f138a254e51528e5ffaeba6bf99ecead9f0c4b6fccccfbfcb/uuid_utils-0.16.0-cp313-cp313-macosx_10_12_x86_64.macosx_11_0_arm64.macosx_10_12_universal2.whl", hash = "sha256:d34cf9681e8892fad2a63e393068e544505408748cd8bf0c3517d753a01528d4", size = 563166, upload-time = "2026-05-19T07:44:10.494Z" }, - { url = "https://files.pythonhosted.org/packages/7c/1c/009e37b70f1f0ff17e7103a36bafde33d503d9ea7fe739761aa3e3c9fde6/uuid_utils-0.16.0-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:0681d1bdb7956e0c6d581e7601dabcfb2b08c25d2a65189f4e9b102c94f5ff46", size = 289529, upload-time = "2026-05-19T07:43:54.466Z" }, - { url = "https://files.pythonhosted.org/packages/5e/5e/e0323d54321166639eb2be5e8a464f5cb0fc04d72d91f3e78944bb6a1da8/uuid_utils-0.16.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ed45fb8732d216426227096b55accbb87cba57febc86a044d90780b090eb99d0", size = 326328, upload-time = "2026-05-19T07:45:31.901Z" }, - { url = "https://files.pythonhosted.org/packages/f0/a3/046f6cb958467c3bf4a163a8a53b178b64a62e21ed8ad5b2c1dacb3a2cfc/uuid_utils-0.16.0-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:b617a334bb01ef2ff8c22900f5a14125eb9063f602131494cc9dc59519beaa5b", size = 332322, upload-time = "2026-05-19T07:43:41.284Z" }, - { url = "https://files.pythonhosted.org/packages/67/80/01914e3949744db7acd0006885e5542fbebb6e39114857d007d29b3265c2/uuid_utils-0.16.0-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:a750d8aeb8ae880aa9a2529606bde0e994bcc7448730c953107f357a28e6102e", size = 445787, upload-time = "2026-05-19T07:45:36.102Z" }, - { url = "https://files.pythonhosted.org/packages/14/ef/f6908f41279f205d70c8a0d5dcb25dd6802741d7f88e3f0123453c3584d3/uuid_utils-0.16.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9a250e111903c4368745fce5ac2aa607bd477c62d3307e45347338fdb64b38e0", size = 324678, upload-time = "2026-05-19T07:45:12.77Z" }, - { url = "https://files.pythonhosted.org/packages/11/4a/bf841ba90f829c7779d82155e0f4b88ef6726ccc25507d064d50ac2cd329/uuid_utils-0.16.0-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:95b7f480010ea98a29ee809857a98aa923008c68129af1b39244adccff7377fb", size = 349704, upload-time = "2026-05-19T07:44:47.172Z" }, - { url = "https://files.pythonhosted.org/packages/e6/31/3b5c60172b8c57bf4ca485484b8e4edef550ca324f9287f1183be97422e2/uuid_utils-0.16.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:420aa3ca403cedb73490b6ea3aeefeea7e0455f5ce60bbf856390ee872ae3306", size = 502456, upload-time = "2026-05-19T07:45:00.821Z" }, - { url = "https://files.pythonhosted.org/packages/88/bf/3da8d497af80fd51d8bf85551c77ede67f07825924ec5987bf9b6031014a/uuid_utils-0.16.0-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:b8a9a7b1065a12d40f2cc25b7d705ab34954cc57095034367bca39ebcf4a876b", size = 607727, upload-time = "2026-05-19T07:44:30.058Z" }, - { url = "https://files.pythonhosted.org/packages/bd/4e/7c8cf03ec15cd6f40e4cbab81b2b4a625461327f68c7971e54723280ec3e/uuid_utils-0.16.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:f235ac5827d74ac630cc87f29278cdaa5d2f273613a6e05bbd96df7aa4170776", size = 566204, upload-time = "2026-05-19T07:44:51.225Z" }, - { url = "https://files.pythonhosted.org/packages/f9/5f/af955feae69cce7fd2121ca3f790ff4b85ad2e17b2149546f50753e1a047/uuid_utils-0.16.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:c8083284488b84ad178e74add64cfd1e74e8be5e30821e5acbc5019281c658b0", size = 529986, upload-time = "2026-05-19T07:45:57.85Z" }, - { url = "https://files.pythonhosted.org/packages/10/cf/3fec757e51bef10eb41ae8075f5442c60e85ff456b42d16a3063f5dc6c80/uuid_utils-0.16.0-cp313-cp313-pyemscripten_2025_0_wasm32.whl", hash = "sha256:27a071a899ba46a551d6524dbbc5a98b88be176d0f55ddf72cf71c005326ac10", size = 98683, upload-time = "2026-05-19T07:44:16.369Z" }, - { url = "https://files.pythonhosted.org/packages/40/a7/cd1adbea7ef882a70db064c00cd93b12e11027b4cdd7ffd79e95c35fc3e3/uuid_utils-0.16.0-cp313-cp313-win32.whl", hash = "sha256:924a8de04460e4cf65998ad0b6568084f7c51740ebd3254d07a0bcde35a84af6", size = 168822, upload-time = "2026-05-19T07:44:24.09Z" }, - { url = "https://files.pythonhosted.org/packages/74/99/617ceb9e3a95b23837012740979baf71afad723b70daf34862da3f7c17a1/uuid_utils-0.16.0-cp313-cp313-win_amd64.whl", hash = "sha256:5279bc7ab3c6683f1c67314695bee14d869015acbbc677bdb0015190fe753d16", size = 174967, upload-time = "2026-05-19T07:44:56.022Z" }, - { url = "https://files.pythonhosted.org/packages/d9/d8/148ae707bfc36d482e39db679c86b81bdce264d4feb9df5d40a03b7687e3/uuid_utils-0.16.0-cp313-cp313-win_arm64.whl", hash = "sha256:61a9c4c26ad12ac66fa4bfd0fdb8494724fe7a5b98a9fcd43e78e2b388663dbb", size = 173142, upload-time = "2026-05-19T07:43:50.171Z" }, - { url = "https://files.pythonhosted.org/packages/21/05/ca6d60705e71fdeaa3431dad94e279a8213c5573cb2925e1aabf3dc0330a/uuid_utils-0.16.0-cp313-cp313t-macosx_10_12_x86_64.macosx_11_0_arm64.macosx_10_12_universal2.whl", hash = "sha256:73486b6aa3f755a6c97000f5ea67e7ac78d6df89bf22980789a1e943e24b74f0", size = 564408, upload-time = "2026-05-19T07:44:38.351Z" }, - { url = "https://files.pythonhosted.org/packages/eb/8c/b9a0462c38535c1662acb1025768e2d626bee5ce9e1790bad6b5381162ea/uuid_utils-0.16.0-cp313-cp313t-macosx_10_12_x86_64.whl", hash = "sha256:f1614572fd9345cdc3dde3f40c237345719fabca1aa87d2d87b321d523cfa34d", size = 289923, upload-time = "2026-05-19T07:45:19.611Z" }, - { url = "https://files.pythonhosted.org/packages/f2/33/a53afeef1a56051551a0f5a801e4bce411dd73c6a8c99bad16902651256d/uuid_utils-0.16.0-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9346ce6eb1fbd8b03a6b331d66016afcb4edcdff6eac708e21391600529a016a", size = 325762, upload-time = "2026-05-19T07:45:18.261Z" }, - { url = "https://files.pythonhosted.org/packages/72/ca/4462a4f36365d7ee72d41e05e6bcfe127e861b073ab37c25b2c8a518317c/uuid_utils-0.16.0-cp313-cp313t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:a0fc6eb3fd821466fbab69cf356c6ec2b7327266bbbc740a2eb57c77c4bef965", size = 332359, upload-time = "2026-05-19T07:45:34.886Z" }, - { url = "https://files.pythonhosted.org/packages/c5/67/9d3373fa7c5a746fdecc64e30caf915c29eb632203508d87676f9243ed03/uuid_utils-0.16.0-cp313-cp313t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:13a797e5e8f0dadc18351a5aa013815ddac25dce6864072a539d510910c95f71", size = 445483, upload-time = "2026-05-19T07:44:49.598Z" }, - { url = "https://files.pythonhosted.org/packages/57/08/ce01aa6d897fc7f875844fe58cad0a542c8ebf089d9242b654b56260ecb8/uuid_utils-0.16.0-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:57c3583b1f1c00a94f59726a5e2b988fa209221143919a1af5c2fc24e318fc98", size = 326281, upload-time = "2026-05-19T07:44:59.677Z" }, - { url = "https://files.pythonhosted.org/packages/76/ef/2c719b2c26bb5b5e5061a1435c11ad2bd33ac3cd6d4cd0c7c3ac1d3396ed/uuid_utils-0.16.0-cp313-cp313t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:caac9c8b1d50e8fbddc76e93bfefbef472978eb45adbfdb6289d578816992953", size = 350809, upload-time = "2026-05-19T07:45:28.076Z" }, - { url = "https://files.pythonhosted.org/packages/e0/9b/c1ed447328b32229cca38ac4c62d309eab006e5e9c4020e2056a175bc607/uuid_utils-0.16.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:91db59bad97ed2b9d2c6ed25082fe9762b2c422e694fe06786b28cf4e776ac4c", size = 502088, upload-time = "2026-05-19T07:44:09.208Z" }, - { url = "https://files.pythonhosted.org/packages/c1/e0/8442f4efe7bde72f0b4ae5f675d0c7fbe209ad0b54718b8ddf43c46c6fae/uuid_utils-0.16.0-cp313-cp313t-musllinux_1_2_armv7l.whl", hash = "sha256:41985e342a30e76366a8becc60bbdb07d72cd1b86ec657b1f31654e9fb1baada", size = 607631, upload-time = "2026-05-19T07:44:19.384Z" }, - { url = "https://files.pythonhosted.org/packages/f1/1e/9a9fa261edf4c972f28ae83421377e3ab8dbd0bd7db58fd316e782d09a3b/uuid_utils-0.16.0-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:1b0dcedf9266bf34a54d5cbe78648eaa627e02352f2a6923ed647530aea2f661", size = 567618, upload-time = "2026-05-19T07:43:58.478Z" }, - { url = "https://files.pythonhosted.org/packages/cc/f7/1bcfdb9d539bd42736dd6076470a42fbb5db23f79712c0a06aa0a3752f7b/uuid_utils-0.16.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:26fe23ab60f05de4ad70aaa5b6a4c2a7bbd43055e3dd6f6b31efba0532ac9c71", size = 530971, upload-time = "2026-05-19T07:45:06.348Z" }, - { url = "https://files.pythonhosted.org/packages/24/0c/18945f417d6bb4d0dd2b7652fe36c58c4e83bcf593b9b326b83aa40b853a/uuid_utils-0.16.0-cp313-cp313t-win32.whl", hash = "sha256:7f8cf49c05d58523a0f977cb7f11afc05791a0fa164d7303b8365a34750638e7", size = 169369, upload-time = "2026-05-19T07:44:32.581Z" }, - { url = "https://files.pythonhosted.org/packages/cc/cc/c0eb0c3fab2ed80d706369b750029143b53126809b77b36bcbb77da66bab/uuid_utils-0.16.0-cp313-cp313t-win_amd64.whl", hash = "sha256:e99f9a8b2420b228faba23a637e96efaf5c6a678b2e225870f24431c82707f50", size = 175384, upload-time = "2026-05-19T07:45:56.623Z" }, +sdist = { url = "https://files.pythonhosted.org/packages/7b/d1/38a573f0c631c062cf42fa1f5d021d4dd3c31fb23e4376e4b56b0c9fbbed/uuid_utils-0.14.1.tar.gz", hash = "sha256:9bfc95f64af80ccf129c604fb6b8ca66c6f256451e32bc4570f760e4309c9b69", size = 22195, upload-time = "2026-02-20T22:50:38.833Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/43/b7/add4363039a34506a58457d96d4aa2126061df3a143eb4d042aedd6a2e76/uuid_utils-0.14.1-cp39-abi3-macosx_10_12_x86_64.macosx_11_0_arm64.macosx_10_12_universal2.whl", hash = "sha256:93a3b5dc798a54a1feb693f2d1cb4cf08258c32ff05ae4929b5f0a2ca624a4f0", size = 604679, upload-time = "2026-02-20T22:50:27.469Z" }, + { url = "https://files.pythonhosted.org/packages/dd/84/d1d0bef50d9e66d31b2019997c741b42274d53dde2e001b7a83e9511c339/uuid_utils-0.14.1-cp39-abi3-macosx_10_12_x86_64.whl", hash = "sha256:ccd65a4b8e83af23eae5e56d88034b2fe7264f465d3e830845f10d1591b81741", size = 309346, upload-time = "2026-02-20T22:50:31.857Z" }, + { url = "https://files.pythonhosted.org/packages/ef/ed/b6d6fd52a6636d7c3eddf97d68da50910bf17cd5ac221992506fb56cf12e/uuid_utils-0.14.1-cp39-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b56b0cacd81583834820588378e432b0696186683b813058b707aedc1e16c4b1", size = 344714, upload-time = "2026-02-20T22:50:42.642Z" }, + { url = "https://files.pythonhosted.org/packages/a8/a7/a19a1719fb626fe0b31882db36056d44fe904dc0cf15b06fdf56b2679cf7/uuid_utils-0.14.1-cp39-abi3-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:bb3cf14de789097320a3c56bfdfdd51b1225d11d67298afbedee7e84e3837c96", size = 350914, upload-time = "2026-02-20T22:50:36.487Z" }, + { url = "https://files.pythonhosted.org/packages/1d/fc/f6690e667fdc3bb1a73f57951f97497771c56fe23e3d302d7404be394d4f/uuid_utils-0.14.1-cp39-abi3-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:60e0854a90d67f4b0cc6e54773deb8be618f4c9bad98d3326f081423b5d14fae", size = 482609, upload-time = "2026-02-20T22:50:37.511Z" }, + { url = "https://files.pythonhosted.org/packages/54/6e/dcd3fa031320921a12ec7b4672dea3bd1dd90ddffa363a91831ba834d559/uuid_utils-0.14.1-cp39-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ce6743ba194de3910b5feb1a62590cd2587e33a73ab6af8a01b642ceb5055862", size = 345699, upload-time = "2026-02-20T22:50:46.87Z" }, + { url = "https://files.pythonhosted.org/packages/04/28/e5220204b58b44ac0047226a9d016a113fde039280cc8732d9e6da43b39f/uuid_utils-0.14.1-cp39-abi3-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:043fb58fde6cf1620a6c066382f04f87a8e74feb0f95a585e4ed46f5d44af57b", size = 372205, upload-time = "2026-02-20T22:50:28.438Z" }, + { url = "https://files.pythonhosted.org/packages/c7/d9/3d2eb98af94b8dfffc82b6a33b4dfc87b0a5de2c68a28f6dde0db1f8681b/uuid_utils-0.14.1-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:c915d53f22945e55fe0d3d3b0b87fd965a57f5fd15666fd92d6593a73b1dd297", size = 521836, upload-time = "2026-02-20T22:50:23.057Z" }, + { url = "https://files.pythonhosted.org/packages/a8/15/0eb106cc6fe182f7577bc0ab6e2f0a40be247f35c5e297dbf7bbc460bd02/uuid_utils-0.14.1-cp39-abi3-musllinux_1_2_armv7l.whl", hash = "sha256:0972488e3f9b449e83f006ead5a0e0a33ad4a13e4462e865b7c286ab7d7566a3", size = 625260, upload-time = "2026-02-20T22:50:25.949Z" }, + { url = "https://files.pythonhosted.org/packages/3c/17/f539507091334b109e7496830af2f093d9fc8082411eafd3ece58af1f8ba/uuid_utils-0.14.1-cp39-abi3-musllinux_1_2_i686.whl", hash = "sha256:1c238812ae0c8ffe77d8d447a32c6dfd058ea4631246b08b5a71df586ff08531", size = 587824, upload-time = "2026-02-20T22:50:35.225Z" }, + { url = "https://files.pythonhosted.org/packages/2e/c2/d37a7b2e41f153519367d4db01f0526e0d4b06f1a4a87f1c5dfca5d70a8b/uuid_utils-0.14.1-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:bec8f8ef627af86abf8298e7ec50926627e29b34fa907fcfbedb45aaa72bca43", size = 551407, upload-time = "2026-02-20T22:50:44.915Z" }, + { url = "https://files.pythonhosted.org/packages/65/36/2d24b2cbe78547c6532da33fb8613debd3126eccc33a6374ab788f5e46e9/uuid_utils-0.14.1-cp39-abi3-win32.whl", hash = "sha256:b54d6aa6252d96bac1fdbc80d26ba71bad9f220b2724d692ad2f2310c22ef523", size = 183476, upload-time = "2026-02-20T22:50:32.745Z" }, + { url = "https://files.pythonhosted.org/packages/83/92/2d7e90df8b1a69ec4cff33243ce02b7a62f926ef9e2f0eca5a026889cd73/uuid_utils-0.14.1-cp39-abi3-win_amd64.whl", hash = "sha256:fc27638c2ce267a0ce3e06828aff786f91367f093c80625ee21dad0208e0f5ba", size = 187147, upload-time = "2026-02-20T22:50:45.807Z" }, + { url = "https://files.pythonhosted.org/packages/d9/26/529f4beee17e5248e37e0bc17a2761d34c0fa3b1e5729c88adb2065bae6e/uuid_utils-0.14.1-cp39-abi3-win_arm64.whl", hash = "sha256:b04cb49b42afbc4ff8dbc60cf054930afc479d6f4dd7f1ec3bbe5dbfdde06b7a", size = 188132, upload-time = "2026-02-20T22:50:41.718Z" }, ] [[package]] @@ -7437,11 +7441,11 @@ wheels = [ [[package]] name = "wcwidth" -version = "0.8.1" +version = "0.6.0" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/49/b4/51fe890511f0f242d07cb1ebe6a5b6db417262b9d2568b460347c57d95cc/wcwidth-0.8.1.tar.gz", hash = "sha256:faf5b4a5366a72dc49cad48cdf21f52bdf63bdda995178e483ba247ff79089b9", size = 1466072, upload-time = "2026-06-08T05:57:23.146Z" } +sdist = { url = "https://files.pythonhosted.org/packages/35/a2/8e3becb46433538a38726c948d3399905a4c7cabd0df578ede5dc51f0ec2/wcwidth-0.6.0.tar.gz", hash = "sha256:cdc4e4262d6ef9a1a57e018384cbeb1208d8abbc64176027e2c2455c81313159", size = 159684, upload-time = "2026-02-06T19:19:40.919Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/bd/6e/95b0e537de1f4d4301f76f944642c6da50d1511cc7b3d64dc418a66c7509/wcwidth-0.8.1-py3-none-any.whl", hash = "sha256:f453740b1e4a4f3291faa37944c555d71056c4da08d59809b307ef4feba695c8", size = 323092, upload-time = "2026-06-08T05:57:21.413Z" }, + { url = "https://files.pythonhosted.org/packages/68/5a/199c59e0a824a3db2b89c5d2dade7ab5f9624dbf6448dc291b46d5ec94d3/wcwidth-0.6.0-py3-none-any.whl", hash = "sha256:1a3a1e510b553315f8e146c54764f4fb6264ffad731b3d78088cdb1478ffbdad", size = 94189, upload-time = "2026-02-06T19:19:39.646Z" }, ] [[package]] @@ -7475,14 +7479,14 @@ wheels = [ [[package]] name = "werkzeug" -version = "3.1.8" +version = "3.1.7" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "markupsafe" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/dd/b2/381be8cfdee792dd117872481b6e378f85c957dd7c5bca38897b08f765fd/werkzeug-3.1.8.tar.gz", hash = "sha256:9bad61a4268dac112f1c5cd4630a56ede601b6ed420300677a869083d70a4c44", size = 875852, upload-time = "2026-04-02T18:49:14.268Z" } +sdist = { url = "https://files.pythonhosted.org/packages/b5/43/76ded108b296a49f52de6bac5192ca1c4be84e886f9b5c9ba8427d9694fd/werkzeug-3.1.7.tar.gz", hash = "sha256:fb8c01fe6ab13b9b7cdb46892b99b1d66754e1d7ab8e542e865ec13f526b5351", size = 875700, upload-time = "2026-03-24T01:08:07.687Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/93/8c/2e650f2afeb7ee576912636c23ddb621c91ac6a98e66dc8d29c3c69446e1/werkzeug-3.1.8-py3-none-any.whl", hash = "sha256:63a77fb8892bf28ebc3178683445222aa500e48ebad5ec77b0ad80f8726b1f50", size = 226459, upload-time = "2026-04-02T18:49:12.72Z" }, + { url = "https://files.pythonhosted.org/packages/7f/b2/0bba9bbb4596d2d2f285a16c2ab04118f6b957d8441566e1abb892e6a6b2/werkzeug-3.1.7-py3-none-any.whl", hash = "sha256:4b314d81163a3e1a169b6a0be2a000a0e204e8873c5de6586f453c55688d422f", size = 226295, upload-time = "2026-03-24T01:08:06.133Z" }, ] [[package]] @@ -7527,53 +7531,40 @@ wheels = [ [[package]] name = "xxhash" -version = "3.7.0" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/24/2f/e183a1b407002f5af81822bee18b61cdb94b8670208ef34734d8d2b8ebe9/xxhash-3.7.0.tar.gz", hash = "sha256:6cc4eefbb542a5d6ffd6d70ea9c502957c925e800f998c5630ecc809d6702bae", size = 82022, upload-time = "2026-04-25T11:10:32.553Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/c1/ca/d5174b4c36d10f64d4ca7050563138c5a599efb01a765858ddefc9c1202a/xxhash-3.7.0-cp313-cp313-android_21_arm64_v8a.whl", hash = "sha256:4b6d6b33f141158692bd4eafbb96edbc5aa0dabdb593a962db01a91983d4f8fa", size = 36813, upload-time = "2026-04-25T11:06:51.73Z" }, - { url = "https://files.pythonhosted.org/packages/41/d0/abc6c9d347ba1f1e1e1d98125d0881a0452c7f9a76a9dd03a7b5d2197f23/xxhash-3.7.0-cp313-cp313-android_21_x86_64.whl", hash = "sha256:845d347df254d6c619f616afa921331bada8614b8d373d58725c663ba97c3605", size = 35121, upload-time = "2026-04-25T11:06:53.048Z" }, - { url = "https://files.pythonhosted.org/packages/bf/11/4cc834eb3d79f2f2b3a6ef7324195208bcdfbdcf7534d2b17267aa5f3a8f/xxhash-3.7.0-cp313-cp313-ios_13_0_arm64_iphoneos.whl", hash = "sha256:fddbbb69a6fff4f421e7a0d1fa28f894b20112e9e3fab306af451e2dfd0e459b", size = 29624, upload-time = "2026-04-25T11:06:54.311Z" }, - { url = "https://files.pythonhosted.org/packages/23/83/e97d3e7b635fe73a1dfb1e91f805324dd6d930bb42041cbf18f183bc0b6d/xxhash-3.7.0-cp313-cp313-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:54876a4e45101cec2bf8f31a973cda073a23e2e108538dad224ba07f85f22487", size = 30638, upload-time = "2026-04-25T11:06:55.864Z" }, - { url = "https://files.pythonhosted.org/packages/f4/40/d84951d80c35db1f4c40a29a64a8520eea5d56e764c603906b4fe763580f/xxhash-3.7.0-cp313-cp313-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:0c72fe9c7e3d6dfd7f1e21e224a877917fa09c465694ba4e06464b9511b65544", size = 33323, upload-time = "2026-04-25T11:06:57.336Z" }, - { url = "https://files.pythonhosted.org/packages/89/cc/c7dc6558d97e9ab023f663d69ab28b340ed9bf4d2d94f2c259cf896bb354/xxhash-3.7.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:a6d73a830b17ef49bc04e00182bd839164c1b3c59c127cd7c54fcb10c7ed8ee8", size = 33362, upload-time = "2026-04-25T11:06:58.656Z" }, - { url = "https://files.pythonhosted.org/packages/2a/6e/46b84017b1301d54091430353d4ad5901654a3e0871649877a416f7f1644/xxhash-3.7.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:91c3b07cf3362086d8f126c6aecd8e5e9396ad8b2f2219ea7e49a8250c318acd", size = 30874, upload-time = "2026-04-25T11:06:59.834Z" }, - { url = "https://files.pythonhosted.org/packages/df/5e/8f9158e3ab906ad3fec51e09b5ea0093e769f12207bfa42a368ca204e7ab/xxhash-3.7.0-cp313-cp313-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:50e879ebbac351c81565ca108db766d7832f5b8b6a5b14b8c0151f7190028e3d", size = 194185, upload-time = "2026-04-25T11:07:01.658Z" }, - { url = "https://files.pythonhosted.org/packages/f3/29/a804ded9f5d3d3758292678d23e7528b08fda7b7e750688d08b052322475/xxhash-3.7.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:921c14e93817842dd0dd9f372890a0f0c72e534650b6ab13c5be5cd0db11d47e", size = 213033, upload-time = "2026-04-25T11:07:03.606Z" }, - { url = "https://files.pythonhosted.org/packages/8b/91/1ce5a7d2fdc975267320e2c78fc1cecfe7ab735ccbcf6993ec5dd541cb2c/xxhash-3.7.0-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:e64a7c9d7dfca3e0fafcbc5e455519090706a3e36e95d655cec3e04e79f95aaa", size = 236140, upload-time = "2026-04-25T11:07:05.396Z" }, - { url = "https://files.pythonhosted.org/packages/34/04/fd595a4fd8617b05fa27bd9b684ecb4985bfed27917848eea85d54036d06/xxhash-3.7.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:2220af08163baf5fa36c2b8af079dc2cbe6e66ae061385267f9472362dfd53c6", size = 212291, upload-time = "2026-04-25T11:07:06.966Z" }, - { url = "https://files.pythonhosted.org/packages/03/fb/f1a379cbc372ae5b9f4ab36154c48a849ca6ebe3ac477067a57865bf3bc6/xxhash-3.7.0-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:f14bb8b22a4a91325813e3d553b8963c10cf8c756cff65ee50c194431296c655", size = 445532, upload-time = "2026-04-25T11:07:08.525Z" }, - { url = "https://files.pythonhosted.org/packages/65/59/172424b79f8cfd4b6d8a122b2193e6b8ad4b11f7159bb3b6f9b3191329bb/xxhash-3.7.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:496736f86a9bedaf64b0dc70e3539d0766df01c71ea22032698e88f3f04a1ce9", size = 193990, upload-time = "2026-04-25T11:07:10.315Z" }, - { url = "https://files.pythonhosted.org/packages/b9/19/aeac22161d953f139f07ba5586cb4a17c5b7b6dff985122803bb12933500/xxhash-3.7.0-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:0ff71596bd79816975b3de7130ab1ff4541410285a3c084584eeb1c8239996fd", size = 284876, upload-time = "2026-04-25T11:07:12.15Z" }, - { url = "https://files.pythonhosted.org/packages/77/d5/4fd0b59e7a02242953da05ff679fbb961b0a4368eac97a217e11dae110c1/xxhash-3.7.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:1ad86695c19b1d46fe106925db3c7a37f16be37669dcf58dcc70a9dd6e324676", size = 210495, upload-time = "2026-04-25T11:07:13.952Z" }, - { url = "https://files.pythonhosted.org/packages/aa/fb/976a3165c728c7faf74aa1b5ab3cf6a85e6d731612894741840524c7d28c/xxhash-3.7.0-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:970f9f8c50961d639cbd0d988c96f80ddf66006de93641719282c4fe7a87c5e6", size = 241331, upload-time = "2026-04-25T11:07:15.557Z" }, - { url = "https://files.pythonhosted.org/packages/4a/2c/6763d5901d53ac9e6ba296e5717ae599025c9d268396e8faa8b4b0a8e0ac/xxhash-3.7.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:5886ad85e9e347911783760a1d16cb6b393e8f9e3b52c982568226cb56927bdc", size = 198037, upload-time = "2026-04-25T11:07:17.563Z" }, - { url = "https://files.pythonhosted.org/packages/61/2b/876e722d533833f5f9a83473e6ba993e48745701096944e77bbecf29b2c3/xxhash-3.7.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:6e934bbae1e0ec74e27d5f0d7f37ef547ce5ff9f0a7e63fb39e559fc99526734", size = 210744, upload-time = "2026-04-25T11:07:19.055Z" }, - { url = "https://files.pythonhosted.org/packages/21/e6/d7e7baef7ce24166b4668d3c48557bb35a23b92ecadcac7e7718d099ab69/xxhash-3.7.0-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:3b6b3d28228af044ebcded71c4a3dd86e1dbd7e2f4645bf40f7b5da65bb5fb5a", size = 275406, upload-time = "2026-04-25T11:07:20.908Z" }, - { url = "https://files.pythonhosted.org/packages/92/fe/198b3763b2e01ca908f2154969a2352ec99bda892b574a11a9a151c5ede4/xxhash-3.7.0-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:6be4d70d9ab76c9f324ead9c01af6ff52c324745ea0c3731682a0cf99720f1fe", size = 414125, upload-time = "2026-04-25T11:07:23.037Z" }, - { url = "https://files.pythonhosted.org/packages/3a/6d/019a11affd5a5499137cacca53808659964785439855b5aa40dfd3412916/xxhash-3.7.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:151d7520838d4465461a0b7f4ae488b3b00de16183dd3214c1a6b14bf89d7fb6", size = 191555, upload-time = "2026-04-25T11:07:24.991Z" }, - { url = "https://files.pythonhosted.org/packages/76/21/b96d58568df2d01533244c3e0e5cbdd0c8b2b25c4bec4d72f19259a292d7/xxhash-3.7.0-cp313-cp313-win32.whl", hash = "sha256:d798c1e291bffb8e37b5bbe0dda77fc767cd19e89cadaf66e6ed5d0ff88c9fe6", size = 30668, upload-time = "2026-04-25T11:07:26.665Z" }, - { url = "https://files.pythonhosted.org/packages/99/57/d849a8d3afa1f8f4bc6a831cd89f49f9706fbbad94d2975d6140a171988c/xxhash-3.7.0-cp313-cp313-win_amd64.whl", hash = "sha256:875811ba23c543b1a1c3143c926e43996eb27ebb8f52d3500744aa608c275aed", size = 31524, upload-time = "2026-04-25T11:07:27.92Z" }, - { url = "https://files.pythonhosted.org/packages/81/52/bacc753e92dee78b058af8dcef0a50815f5f860986c664a92d75f965b6a5/xxhash-3.7.0-cp313-cp313-win_arm64.whl", hash = "sha256:54a675cb300dda83d71daae2a599389d22db8021a0f8db0dd659e14626eb3ecc", size = 27768, upload-time = "2026-04-25T11:07:29.113Z" }, - { url = "https://files.pythonhosted.org/packages/1c/47/ddbd683b7fc7e592c1a8d9d65f73ce9ab513f082b3967eee2baf549b8fc6/xxhash-3.7.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:a3b19a42111c4057c1547a4a1396a53961dca576a0f6b82bfa88a2d1561764b2", size = 33576, upload-time = "2026-04-25T11:07:30.469Z" }, - { url = "https://files.pythonhosted.org/packages/07/f2/36d3310161db7f72efb4562aadde0ed429f1d0531782dd6345b12d2da527/xxhash-3.7.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:8f4608a06e4d61b7a3425665a46d00e0579122e1a2fae97a0c52953a3aad9aa3", size = 31123, upload-time = "2026-04-25T11:07:31.989Z" }, - { url = "https://files.pythonhosted.org/packages/0d/3f/75937a5c69556ed213021e43cbedd84c8e0279d0d74e7d41a255d84ba4b1/xxhash-3.7.0-cp313-cp313t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:ad37c7792479e49cf96c1ab25517d7003fe0d93687a772ba19a097d235bbe41e", size = 196491, upload-time = "2026-04-25T11:07:33.358Z" }, - { url = "https://files.pythonhosted.org/packages/22/29/f10d7ff8c7a733d4403a43b9de18c8fabc005f98cec054644f04418659ee/xxhash-3.7.0-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:dc026e3b89d98e30a8288c95cb696e77d150b3f0fb7a51f73dcd49ee6b5577fa", size = 215793, upload-time = "2026-04-25T11:07:34.919Z" }, - { url = "https://files.pythonhosted.org/packages/8b/fd/778f60aa295f58907938f030a8b514611f391405614a525cccd2ffc00eb5/xxhash-3.7.0-cp313-cp313t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:c9b31ab1f28b078a6a1ac1a54eb35e7d5390deddd56870d0be3a0a733d1c321c", size = 237993, upload-time = "2026-04-25T11:07:36.638Z" }, - { url = "https://files.pythonhosted.org/packages/70/f5/736db5de387b4a540e37a05b84b40dc58a1ce974bfd2b4e5754ce29b68c3/xxhash-3.7.0-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:3bb5fd680c038fd5229e44e9c493782f90df9bef632fd0499d442374688ff70b", size = 214887, upload-time = "2026-04-25T11:07:38.564Z" }, - { url = "https://files.pythonhosted.org/packages/4d/aa/09a095f22fdb9a27fbb716841fbff52119721f9ca4261952d07a912f7839/xxhash-3.7.0-cp313-cp313t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:030c0fd688fce3569fbb49a2feefd4110cbb0b650186fb4610759ecfac677548", size = 448407, upload-time = "2026-04-25T11:07:40.552Z" }, - { url = "https://files.pythonhosted.org/packages/74/8a/b745efeeca9e34a91c26fdc97ad8514c43d5a81ac78565cba80a1353870a/xxhash-3.7.0-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5b1bde10324f4c31812ae0d0502e92d916ae8917cad7209353f122b8b8f610c3", size = 196119, upload-time = "2026-04-25T11:07:42.101Z" }, - { url = "https://files.pythonhosted.org/packages/8a/5c/0cfceb024af90c191f665c7933b1f318ee234f4797858383bebd1881d52f/xxhash-3.7.0-cp313-cp313t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:503722d52a615f2604f5e7611de7d43878df010dc0053094ef91cb9a9ac3d987", size = 286751, upload-time = "2026-04-25T11:07:43.568Z" }, - { url = "https://files.pythonhosted.org/packages/0b/0a/0793e405dc3cf8f4ebe2c1acec1e4e4608cd9e7e50ea691dabbc2a95ccbb/xxhash-3.7.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:c72500a3b6d6c30ebfc135035bcace9eb5884f2dc220804efcaaba43e9f611dd", size = 212961, upload-time = "2026-04-25T11:07:45.388Z" }, - { url = "https://files.pythonhosted.org/packages/0c/7e/721118ffc63bfff94aa565bcf2555a820f9f4bdb0f001e0d609bdfad70de/xxhash-3.7.0-cp313-cp313t-musllinux_1_2_armv7l.whl", hash = "sha256:43475925a766d01ca8cd9a857fd87f3d50406983c8506a4c07c4df12adcc867f", size = 243703, upload-time = "2026-04-25T11:07:47.053Z" }, - { url = "https://files.pythonhosted.org/packages/6e/18/16f6267160488b8276fd3d449d425712512add292ba545c1b6946bfdb7dd/xxhash-3.7.0-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:8d09dfd2ab135b985daf868b594315ebe11ad86cd9fea46e6c69f19b28f7d25a", size = 200894, upload-time = "2026-04-25T11:07:48.657Z" }, - { url = "https://files.pythonhosted.org/packages/2d/94/80ba841287fd97e3e9cac1d228788c8ef623746f570404961eec748ecb5c/xxhash-3.7.0-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:c50269d0055ac1faecfd559886d2cbe4b730de236585aba0e873f9d9dadbe585", size = 213357, upload-time = "2026-04-25T11:07:50.257Z" }, - { url = "https://files.pythonhosted.org/packages/a1/7e/106d4067130c59f1e18a55ffadcd876d8c68534883a1e02685b29d3d8153/xxhash-3.7.0-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:1910df4756a5ab58cfad8744fc2d0f23926e3efcc346ee76e87b974abab922f4", size = 277600, upload-time = "2026-04-25T11:07:51.745Z" }, - { url = "https://files.pythonhosted.org/packages/c5/86/a081dd30da71d720b2612a792bfd55e45fa9a07ac76a0507f60487473c25/xxhash-3.7.0-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:d006faf3b491957efcb433489be3c149efe4787b7063d5cddb8ddaefdc60e0c1", size = 416980, upload-time = "2026-04-25T11:07:53.504Z" }, - { url = "https://files.pythonhosted.org/packages/35/29/1a95221a029a3c1293773869e1ab47b07cbbdd82444a42809e8c60156626/xxhash-3.7.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:abb65b4e947e958f7b3b0d71db3ce447d1bc5f37f5eab871ce7223bda8768a04", size = 193840, upload-time = "2026-04-25T11:07:55.103Z" }, - { url = "https://files.pythonhosted.org/packages/c5/e0/db909dd0823285de2286f67e10ee4d81e96ad35d7d8e964ecb07fccd8af9/xxhash-3.7.0-cp313-cp313t-win32.whl", hash = "sha256:178959906cb1716a1ce08e0d69c82886c70a15a6f2790fc084fdd146ca30cd49", size = 30966, upload-time = "2026-04-25T11:07:56.524Z" }, - { url = "https://files.pythonhosted.org/packages/7b/ff/d705b15b22f21ee106adce239cb65d35067a158c630b240270f09b17c2e6/xxhash-3.7.0-cp313-cp313t-win_amd64.whl", hash = "sha256:2524a1e20d4c231d13b50f7cf39e44265b055669a64a7a4b9a2a44faa03f19b6", size = 31784, upload-time = "2026-04-25T11:07:57.758Z" }, - { url = "https://files.pythonhosted.org/packages/a2/1f/b2cf83c3638fd0588e0b17f22e5a9400bdfb1a3e3755324ac0aee2250b88/xxhash-3.7.0-cp313-cp313t-win_arm64.whl", hash = "sha256:37d994d0ffe81ef087bb330d392caa809bb5853c77e22ea3f71db024a0543dba", size = 27932, upload-time = "2026-04-25T11:07:59.109Z" }, +version = "3.6.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/02/84/30869e01909fb37a6cc7e18688ee8bf1e42d57e7e0777636bd47524c43c7/xxhash-3.6.0.tar.gz", hash = "sha256:f0162a78b13a0d7617b2845b90c763339d1f1d82bb04a4b07f4ab535cc5e05d6", size = 85160, upload-time = "2025-10-02T14:37:08.097Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/33/76/35d05267ac82f53ae9b0e554da7c5e281ee61f3cad44c743f0fcd354f211/xxhash-3.6.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:599e64ba7f67472481ceb6ee80fa3bd828fd61ba59fb11475572cc5ee52b89ec", size = 32738, upload-time = "2025-10-02T14:34:55.839Z" }, + { url = "https://files.pythonhosted.org/packages/31/a8/3fbce1cd96534a95e35d5120637bf29b0d7f5d8fa2f6374e31b4156dd419/xxhash-3.6.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:7d8b8aaa30fca4f16f0c84a5c8d7ddee0e25250ec2796c973775373257dde8f1", size = 30821, upload-time = "2025-10-02T14:34:57.219Z" }, + { url = "https://files.pythonhosted.org/packages/0c/ea/d387530ca7ecfa183cb358027f1833297c6ac6098223fd14f9782cd0015c/xxhash-3.6.0-cp313-cp313-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:d597acf8506d6e7101a4a44a5e428977a51c0fadbbfd3c39650cca9253f6e5a6", size = 194127, upload-time = "2025-10-02T14:34:59.21Z" }, + { url = "https://files.pythonhosted.org/packages/ba/0c/71435dcb99874b09a43b8d7c54071e600a7481e42b3e3ce1eb5226a5711a/xxhash-3.6.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:858dc935963a33bc33490128edc1c12b0c14d9c7ebaa4e387a7869ecc4f3e263", size = 212975, upload-time = "2025-10-02T14:35:00.816Z" }, + { url = "https://files.pythonhosted.org/packages/84/7a/c2b3d071e4bb4a90b7057228a99b10d51744878f4a8a6dd643c8bd897620/xxhash-3.6.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ba284920194615cb8edf73bf52236ce2e1664ccd4a38fdb543506413529cc546", size = 212241, upload-time = "2025-10-02T14:35:02.207Z" }, + { url = "https://files.pythonhosted.org/packages/81/5f/640b6eac0128e215f177df99eadcd0f1b7c42c274ab6a394a05059694c5a/xxhash-3.6.0-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:4b54219177f6c6674d5378bd862c6aedf64725f70dd29c472eaae154df1a2e89", size = 445471, upload-time = "2025-10-02T14:35:03.61Z" }, + { url = "https://files.pythonhosted.org/packages/5e/1e/3c3d3ef071b051cc3abbe3721ffb8365033a172613c04af2da89d5548a87/xxhash-3.6.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:42c36dd7dbad2f5238950c377fcbf6811b1cdb1c444fab447960030cea60504d", size = 193936, upload-time = "2025-10-02T14:35:05.013Z" }, + { url = "https://files.pythonhosted.org/packages/2c/bd/4a5f68381939219abfe1c22a9e3a5854a4f6f6f3c4983a87d255f21f2e5d/xxhash-3.6.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:f22927652cba98c44639ffdc7aaf35828dccf679b10b31c4ad72a5b530a18eb7", size = 210440, upload-time = "2025-10-02T14:35:06.239Z" }, + { url = "https://files.pythonhosted.org/packages/eb/37/b80fe3d5cfb9faff01a02121a0f4d565eb7237e9e5fc66e73017e74dcd36/xxhash-3.6.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:b45fad44d9c5c119e9c6fbf2e1c656a46dc68e280275007bbfd3d572b21426db", size = 197990, upload-time = "2025-10-02T14:35:07.735Z" }, + { url = "https://files.pythonhosted.org/packages/d7/fd/2c0a00c97b9e18f72e1f240ad4e8f8a90fd9d408289ba9c7c495ed7dc05c/xxhash-3.6.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:6f2580ffab1a8b68ef2b901cde7e55fa8da5e4be0977c68f78fc80f3c143de42", size = 210689, upload-time = "2025-10-02T14:35:09.438Z" }, + { url = "https://files.pythonhosted.org/packages/93/86/5dd8076a926b9a95db3206aba20d89a7fc14dd5aac16e5c4de4b56033140/xxhash-3.6.0-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:40c391dd3cd041ebc3ffe6f2c862f402e306eb571422e0aa918d8070ba31da11", size = 414068, upload-time = "2025-10-02T14:35:11.162Z" }, + { url = "https://files.pythonhosted.org/packages/af/3c/0bb129170ee8f3650f08e993baee550a09593462a5cddd8e44d0011102b1/xxhash-3.6.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:f205badabde7aafd1a31e8ca2a3e5a763107a71c397c4481d6a804eb5063d8bd", size = 191495, upload-time = "2025-10-02T14:35:12.971Z" }, + { url = "https://files.pythonhosted.org/packages/e9/3a/6797e0114c21d1725e2577508e24006fd7ff1d8c0c502d3b52e45c1771d8/xxhash-3.6.0-cp313-cp313-win32.whl", hash = "sha256:2577b276e060b73b73a53042ea5bd5203d3e6347ce0d09f98500f418a9fcf799", size = 30620, upload-time = "2025-10-02T14:35:14.129Z" }, + { url = "https://files.pythonhosted.org/packages/86/15/9bc32671e9a38b413a76d24722a2bf8784a132c043063a8f5152d390b0f9/xxhash-3.6.0-cp313-cp313-win_amd64.whl", hash = "sha256:757320d45d2fbcce8f30c42a6b2f47862967aea7bf458b9625b4bbe7ee390392", size = 31542, upload-time = "2025-10-02T14:35:15.21Z" }, + { url = "https://files.pythonhosted.org/packages/39/c5/cc01e4f6188656e56112d6a8e0dfe298a16934b8c47a247236549a3f7695/xxhash-3.6.0-cp313-cp313-win_arm64.whl", hash = "sha256:457b8f85dec5825eed7b69c11ae86834a018b8e3df5e77783c999663da2f96d6", size = 27880, upload-time = "2025-10-02T14:35:16.315Z" }, + { url = "https://files.pythonhosted.org/packages/f3/30/25e5321c8732759e930c555176d37e24ab84365482d257c3b16362235212/xxhash-3.6.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:a42e633d75cdad6d625434e3468126c73f13f7584545a9cf34e883aa1710e702", size = 32956, upload-time = "2025-10-02T14:35:17.413Z" }, + { url = "https://files.pythonhosted.org/packages/9f/3c/0573299560d7d9f8ab1838f1efc021a280b5ae5ae2e849034ef3dee18810/xxhash-3.6.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:568a6d743219e717b07b4e03b0a828ce593833e498c3b64752e0f5df6bfe84db", size = 31072, upload-time = "2025-10-02T14:35:18.844Z" }, + { url = "https://files.pythonhosted.org/packages/7a/1c/52d83a06e417cd9d4137722693424885cc9878249beb3a7c829e74bf7ce9/xxhash-3.6.0-cp313-cp313t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:bec91b562d8012dae276af8025a55811b875baace6af510412a5e58e3121bc54", size = 196409, upload-time = "2025-10-02T14:35:20.31Z" }, + { url = "https://files.pythonhosted.org/packages/e3/8e/c6d158d12a79bbd0b878f8355432075fc82759e356ab5a111463422a239b/xxhash-3.6.0-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:78e7f2f4c521c30ad5e786fdd6bae89d47a32672a80195467b5de0480aa97b1f", size = 215736, upload-time = "2025-10-02T14:35:21.616Z" }, + { url = "https://files.pythonhosted.org/packages/bc/68/c4c80614716345d55071a396cf03d06e34b5f4917a467faf43083c995155/xxhash-3.6.0-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:3ed0df1b11a79856df5ffcab572cbd6b9627034c1c748c5566fa79df9048a7c5", size = 214833, upload-time = "2025-10-02T14:35:23.32Z" }, + { url = "https://files.pythonhosted.org/packages/7e/e9/ae27c8ffec8b953efa84c7c4a6c6802c263d587b9fc0d6e7cea64e08c3af/xxhash-3.6.0-cp313-cp313t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:0e4edbfc7d420925b0dd5e792478ed393d6e75ff8fc219a6546fb446b6a417b1", size = 448348, upload-time = "2025-10-02T14:35:25.111Z" }, + { url = "https://files.pythonhosted.org/packages/d7/6b/33e21afb1b5b3f46b74b6bd1913639066af218d704cc0941404ca717fc57/xxhash-3.6.0-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:fba27a198363a7ef87f8c0f6b171ec36b674fe9053742c58dd7e3201c1ab30ee", size = 196070, upload-time = "2025-10-02T14:35:26.586Z" }, + { url = "https://files.pythonhosted.org/packages/96/b6/fcabd337bc5fa624e7203aa0fa7d0c49eed22f72e93229431752bddc83d9/xxhash-3.6.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:794fe9145fe60191c6532fa95063765529770edcdd67b3d537793e8004cabbfd", size = 212907, upload-time = "2025-10-02T14:35:28.087Z" }, + { url = "https://files.pythonhosted.org/packages/4b/d3/9ee6160e644d660fcf176c5825e61411c7f62648728f69c79ba237250143/xxhash-3.6.0-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:6105ef7e62b5ac73a837778efc331a591d8442f8ef5c7e102376506cb4ae2729", size = 200839, upload-time = "2025-10-02T14:35:29.857Z" }, + { url = "https://files.pythonhosted.org/packages/0d/98/e8de5baa5109394baf5118f5e72ab21a86387c4f89b0e77ef3e2f6b0327b/xxhash-3.6.0-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:f01375c0e55395b814a679b3eea205db7919ac2af213f4a6682e01220e5fe292", size = 213304, upload-time = "2025-10-02T14:35:31.222Z" }, + { url = "https://files.pythonhosted.org/packages/7b/1d/71056535dec5c3177eeb53e38e3d367dd1d16e024e63b1cee208d572a033/xxhash-3.6.0-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:d706dca2d24d834a4661619dcacf51a75c16d65985718d6a7d73c1eeeb903ddf", size = 416930, upload-time = "2025-10-02T14:35:32.517Z" }, + { url = "https://files.pythonhosted.org/packages/dc/6c/5cbde9de2cd967c322e651c65c543700b19e7ae3e0aae8ece3469bf9683d/xxhash-3.6.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:5f059d9faeacd49c0215d66f4056e1326c80503f51a1532ca336a385edadd033", size = 193787, upload-time = "2025-10-02T14:35:33.827Z" }, + { url = "https://files.pythonhosted.org/packages/19/fa/0172e350361d61febcea941b0cc541d6e6c8d65d153e85f850a7b256ff8a/xxhash-3.6.0-cp313-cp313t-win32.whl", hash = "sha256:1244460adc3a9be84731d72b8e80625788e5815b68da3da8b83f78115a40a7ec", size = 30916, upload-time = "2025-10-02T14:35:35.107Z" }, + { url = "https://files.pythonhosted.org/packages/ad/e6/e8cf858a2b19d6d45820f072eff1bea413910592ff17157cabc5f1227a16/xxhash-3.6.0-cp313-cp313t-win_amd64.whl", hash = "sha256:b1e420ef35c503869c4064f4a2f2b08ad6431ab7b229a05cce39d74268bca6b8", size = 31799, upload-time = "2025-10-02T14:35:36.165Z" }, + { url = "https://files.pythonhosted.org/packages/56/15/064b197e855bfb7b343210e82490ae672f8bc7cdf3ddb02e92f64304ee8a/xxhash-3.6.0-cp313-cp313t-win_arm64.whl", hash = "sha256:ec44b73a4220623235f67a996c862049f375df3b1052d9899f40a6382c32d746", size = 28044, upload-time = "2025-10-02T14:35:37.195Z" }, ] [[package]] @@ -7633,14 +7624,23 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/80/ab/11a76c1e2126084fde2639514f24e6111b789b0bfa4fc6264a8975c7e1f1/zict-3.0.0-py2.py3-none-any.whl", hash = "sha256:5796e36bd0e0cc8cf0fbc1ace6a68912611c1dbd74750a3f3026b9b9d6a327ae", size = 43332, upload-time = "2023-04-17T21:41:13.444Z" }, ] +[[package]] +name = "zipp" +version = "3.23.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/e3/02/0f2892c661036d50ede074e376733dca2ae7c6eb617489437771209d4180/zipp-3.23.0.tar.gz", hash = "sha256:a07157588a12518c9d4034df3fbbee09c814741a33ff63c05fa29d26a2404166", size = 25547, upload-time = "2025-06-08T17:06:39.4Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/2e/54/647ade08bf0db230bfea292f893923872fd20be6ac6f53b2b936ba839d75/zipp-3.23.0-py3-none-any.whl", hash = "sha256:071652d6115ed432f5ce1d34c336c0adfd6a884660d1e9712a256d3d3bd4b14e", size = 10276, upload-time = "2025-06-08T17:06:38.034Z" }, +] + [[package]] name = "zlib-state" -version = "0.1.12" +version = "0.1.10" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/53/f2/c1b3dfb76ff3eac8eb2a96eb1e8e05c13534c73f0d1d582dfadadb5a863a/zlib_state-0.1.12.tar.gz", hash = "sha256:ccbb06321daf165b022aa4d22d62effb7df76f55035d50bbe8b93696db416cf0", size = 9618, upload-time = "2026-04-14T19:08:30.079Z" } +sdist = { url = "https://files.pythonhosted.org/packages/35/3e/dd482d5bf99d1dabcce0a20a479859cb7a6bd8a365b07b41ebf46b3c0f3d/zlib_state-0.1.10.tar.gz", hash = "sha256:c29b6b93cea1b80025fbc96fa91ceed8b5e7b54ef08f16d6e4c7f8fb56aad777", size = 9573, upload-time = "2025-09-09T07:14:12.205Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/6c/09/bafb78fbd0471aadeb96c4d79dc76b25c172153935563357b250c1f0d80b/zlib_state-0.1.12-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:940674e4b4d6c4df7e3be75be48c6ad1f07c0f42cab2d0b5655f67b8f0532073", size = 22049, upload-time = "2026-04-14T19:09:46.601Z" }, - { url = "https://files.pythonhosted.org/packages/31/0d/76a524ee21b62cecd00c469d5cf1093ec2310684ba9e2cdbf6d323681d0f/zlib_state-0.1.12-cp313-cp313-win_amd64.whl", hash = "sha256:6466325e9e20a7e30b0c0291024fef2cb80a534324393609b5b30db42c065d1b", size = 12803, upload-time = "2026-04-14T19:09:16.351Z" }, + { url = "https://files.pythonhosted.org/packages/70/0c/2b0803cb9f30bddbc9eda87d251d958d21cfdde826bc1deb1e19ca0ff320/zlib_state-0.1.10-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:dfecba070cdeeab073573ac721459727d60e0b8ef7b38dac3c965459781b0eeb", size = 22045, upload-time = "2025-09-09T07:15:31.86Z" }, + { url = "https://files.pythonhosted.org/packages/b1/d2/74ff59bb480801eae2731523f98be198eec135a9d37e27791b635f2c9124/zlib_state-0.1.10-cp313-cp313-win_amd64.whl", hash = "sha256:72e354f09c942055677ba59d76ca8c311a8129dfc98c3b44db33302843090204", size = 12801, upload-time = "2025-09-09T07:15:07.099Z" }, ] [[package]] From f17c4d4a41eb4db03b3a7690cfd6c24e6b127ccf Mon Sep 17 00:00:00 2001 From: Carolin Walter Date: Fri, 24 Jul 2026 17:48:31 +0200 Subject: [PATCH 42/47] pin dependencies, use smac 2.4.0 (no swig required) --- pyproject.toml | 30 +++++++++++++++--------------- uv.lock | 19 ++++--------------- 2 files changed, 19 insertions(+), 30 deletions(-) diff --git a/pyproject.toml b/pyproject.toml index 65ece3a..6cb1da8 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -182,22 +182,22 @@ dependencies = [ "wrapt==1.17.2", "yarl==1.20.1", "zstandard==0.23.0", - "o365 (>=2.1.8,<3.0.0)", - "azure-identity (>=1.25.1,<2.0.0)", - "msal (>=1.34.0,<2.0.0)", - "openpyxl (>=3.1.5,<4.0.0)", - "types-psutil (>=7.2.2.20260130,<8.0.0.0)", - "types-pyxdg (>=0.28.0.20251115,<0.29.0.0)", - "types-requests (>=2.32.4.20260107,<3.0.0.0)", - "pandas-stubs (>=3.0.0.260204,<4.0.0.0)", - "python-pptx (>=1.0.2,<2.0.0)", - "msoffcrypto-tool (>=6.0.0,<7.0.0)", - "ebooklib (>=0.20,<0.21)", + "o365==2.1.9", + "azure-identity==1.25.3", + "msal==1.35.1", + "openpyxl==3.1.5", + "types-psutil==7.2.2.20260130", + "types-pyxdg==0.28.0.20251115", + "types-requests==2.32.4.20260324", + "pandas-stubs==3.0.0.260204", + "python-pptx==1.0.2", + "msoffcrypto-tool==6.0.0", + "ebooklib==0.20", "apscheduler==3.11.2", - "configspace>=1.2.2", - "smac>=2.4.0", - "bert-score>=0.3.13", - "scikit-learn>=1.8.0", + "ConfigSpace==1.2.2", + "smac==2.4.0", + "bert-score==0.3.13", + "scikit-learn==1.8.0", ] description = "" license = "MIT" diff --git a/uv.lock b/uv.lock index 8ed621b..6516a08 100644 --- a/uv.lock +++ b/uv.lock @@ -1995,10 +1995,9 @@ requires-dist = [ { name = "apscheduler", specifier = "==3.11.2" }, { name = "attrs", specifier = "==25.3.0" }, { name = "azure-identity", specifier = "==1.25.3" }, - { name = "azure-identity", specifier = ">=1.25.1,<2.0.0" }, { name = "backoff", specifier = "==2.2.1" }, { name = "beautifulsoup4", specifier = "==4.14.3" }, - { name = "bert-score", specifier = ">=0.3.13" }, + { name = "bert-score", specifier = "==0.3.13" }, { name = "build", specifier = "==1.3.0" }, { name = "cachetools", specifier = "==5.5.2" }, { name = "certifi", specifier = "==2025.8.3" }, @@ -2008,7 +2007,7 @@ requires-dist = [ { name = "colorama", specifier = "==0.4.6" }, { name = "coloredlogs", specifier = "==15.0.1" }, { name = "colorlog", specifier = "==6.10.1" }, - { name = "configspace", specifier = ">=1.2.2" }, + { name = "configspace", specifier = "==1.2.2" }, { name = "contourpy", specifier = "==1.3.3" }, { name = "cryptography", specifier = "==45.0.6" }, { name = "cycler", specifier = "==0.12.1" }, @@ -2016,7 +2015,6 @@ requires-dist = [ { name = "datasets", specifier = "==4.8.4" }, { name = "deprecated", specifier = "==1.2.18" }, { name = "ebooklib", specifier = "==0.20" }, - { name = "ebooklib", specifier = ">=0.20,<0.21" }, { name = "effdet", specifier = "==0.4.1" }, { name = "emoji", specifier = "==2.15.0" }, { name = "fastapi", specifier = "==0.115.11" }, @@ -2072,10 +2070,8 @@ requires-dist = [ { name = "matplotlib", specifier = "==3.10.5" }, { name = "mpmath", specifier = "==1.3.0" }, { name = "msal", specifier = "==1.35.1" }, - { name = "msal", specifier = ">=1.34.0,<2.0.0" }, { name = "msgraph-sdk", specifier = "==1.54.0" }, { name = "msoffcrypto-tool", specifier = "==6.0.0" }, - { name = "msoffcrypto-tool", specifier = ">=6.0.0,<7.0.0" }, { name = "multidict", specifier = "==6.6.4" }, { name = "mypy", specifier = "==1.19.1" }, { name = "mypy-extensions", specifier = "==1.1.0" }, @@ -2083,7 +2079,6 @@ requires-dist = [ { name = "nltk", specifier = "==3.9.1" }, { name = "numpy", specifier = "==2.2.6" }, { name = "o365", specifier = "==2.1.9" }, - { name = "o365", specifier = ">=2.1.8,<3.0.0" }, { name = "olefile", specifier = "==0.47" }, { name = "ollama", specifier = "==0.6.1" }, { name = "omegaconf", specifier = "==2.3.0" }, @@ -2092,12 +2087,10 @@ requires-dist = [ { name = "openai", specifier = "==2.33.0" }, { name = "opencv-python", specifier = "==4.12.0.88" }, { name = "openpyxl", specifier = "==3.1.5" }, - { name = "openpyxl", specifier = ">=3.1.5,<4.0.0" }, { name = "orjson", specifier = "==3.11.1" }, { name = "packaging", specifier = "==25.0" }, { name = "pandas", specifier = "==2.3.3" }, { name = "pandas-stubs", specifier = "==3.0.0.260204" }, - { name = "pandas-stubs", specifier = ">=3.0.0.260204,<4.0.0.0" }, { name = "pdf2image", specifier = "==1.17.0" }, { name = "pdfminer-six", specifier = "==20250506" }, { name = "pi-heif", specifier = "==1.1.0" }, @@ -2128,7 +2121,6 @@ requires-dist = [ { name = "python-multipart", specifier = "==0.0.20" }, { name = "python-oxmsg", specifier = "==0.0.2" }, { name = "python-pptx", specifier = "==1.0.2" }, - { name = "python-pptx", specifier = ">=1.0.2,<2.0.0" }, { name = "pytz", specifier = "==2025.2" }, { name = "pyxdg", specifier = "==0.28" }, { name = "pyyaml", specifier = "==6.0.3" }, @@ -2139,13 +2131,13 @@ requires-dist = [ { name = "requests-toolbelt", specifier = "==1.0.0" }, { name = "rsa", specifier = "==4.9.1" }, { name = "safetensors", specifier = "==0.6.2" }, - { name = "scikit-learn", specifier = ">=1.8.0" }, + { name = "scikit-learn", specifier = "==1.8.0" }, { name = "scipy", specifier = "==1.16.1" }, { name = "sentence-transformers", specifier = "==5.3.0" }, { name = "setuptools", specifier = "==80.9.0" }, { name = "simsimd", specifier = "==6.5.16" }, { name = "six", specifier = "==1.17.0" }, - { name = "smac", specifier = ">=2.4.0" }, + { name = "smac", specifier = "==2.4.0" }, { name = "sniffio", specifier = "==1.3.1" }, { name = "soupsieve", specifier = "==2.7" }, { name = "sqlalchemy", specifier = "==2.0.42" }, @@ -2158,12 +2150,9 @@ requires-dist = [ { name = "tqdm", specifier = "==4.67.3" }, { name = "transformers", specifier = "==4.55.0" }, { name = "types-psutil", specifier = "==7.2.2.20260130" }, - { name = "types-psutil", specifier = ">=7.2.2.20260130,<8.0.0.0" }, { name = "types-pyxdg", specifier = "==0.28.0.20251115" }, - { name = "types-pyxdg", specifier = ">=0.28.0.20251115,<0.29.0.0" }, { name = "types-pyyaml", specifier = "==6.0.12.20250915" }, { name = "types-requests", specifier = "==2.32.4.20260324" }, - { name = "types-requests", specifier = ">=2.32.4.20260107,<3.0.0.0" }, { name = "typing-extensions", specifier = "==4.15.0" }, { name = "typing-inspect", specifier = "==0.9.0" }, { name = "typing-inspection", specifier = "==0.4.1" }, From ac80d0eb67c50b1d1a20374dca1639e3a0737624 Mon Sep 17 00:00:00 2001 From: farshad68 Date: Mon, 27 Jul 2026 12:35:15 +0200 Subject: [PATCH 43/47] use ; as seperator --- learn2rag/tests/data/rabbit_eval.csv | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/learn2rag/tests/data/rabbit_eval.csv b/learn2rag/tests/data/rabbit_eval.csv index 0f823e0..431e7ce 100644 --- a/learn2rag/tests/data/rabbit_eval.csv +++ b/learn2rag/tests/data/rabbit_eval.csv @@ -1,7 +1,7 @@ -answer,question -"Answer: Rabbits belong to the family Leporidae, which also includes hares, and the order Lagomorpha, which includes pikas.","Question: What family and order do rabbits belong to, and what other animals are included in these classifications?" -"Answer: The most widespread rabbit genera are Oryctolagus and Sylvilagus. The European rabbit, which belongs to the genus Oryctolagus, has been introduced on every continent except Antarctica.","Question: What are the most widespread rabbit genera, and on which continents can the European rabbit be found?" -"Answer: Rabbits do not constitute a clade because they are a paraphyletic grouping, as hares are nested within the Leporidae clade but not described as rabbits. They differ from rodents by having a number of traits rodents lack, including two extra incisors.","Question: Why do rabbits not constitute a clade, and how do they physically differ from rodents despite once being classified as such?" -"Answer: A rabbit's hind legs are longer than its fore legs, allowing for quick hopping to escape predators and providing powerful kicks if captured. Rabbits are typically nocturnal and often sleep with their eyes open.","Question: How does the bone structure of a rabbit's legs aid in its survival against predators, and what are their typical sleep habits?" -"Answer: A rabbit's ears are essential for thermoregulation, containing a high density of blood vessels. They also have a high surface area to help detect potential predators.","Question: What functions do a rabbit's ears serve regarding survival and physiology?" -"Answer: Humans have used rabbits as livestock since at least the first century BC in ancient Rome, raising them for meat, fur, and wool. The practice of raising and breeding them is known as cuniculture.","Question: When did humans begin using rabbits as livestock, for what purposes, and what is the practice of breeding them called?" \ No newline at end of file +answer;question;id +"Answer: Rabbits belong to the family Leporidae, which also includes hares, and the order Lagomorpha, which includes pikas.";"Question: What family and order do rabbits belong to, and what other animals are included in these classifications?";"id:1" +"Answer: The most widespread rabbit genera are Oryctolagus and Sylvilagus. The European rabbit, which belongs to the genus Oryctolagus, has been introduced on every continent except Antarctica.";"Question: What are the most widespread rabbit genera, and on which continents can the European rabbit be found?";"id:2" +"Answer: Rabbits do not constitute a clade because they are a paraphyletic grouping, as hares are nested within the Leporidae clade but not described as rabbits. They differ from rodents by having a number of traits rodents lack, including two extra incisors.";"Question: Why do rabbits not constitute a clade, and how do they physically differ from rodents despite once being classified as such?";"id:3" +"Answer: A rabbit's hind legs are longer than its fore legs, allowing for quick hopping to escape predators and providing powerful kicks if captured. Rabbits are typically nocturnal and often sleep with their eyes open.";"Question: How does the bone structure of a rabbit's legs aid in its survival against predators, and what are their typical sleep habits?";"id:4" +"Answer: A rabbit's ears are essential for thermoregulation, containing a high density of blood vessels. They also have a high surface area to help detect potential predators.";"Question: What functions do a rabbit's ears serve regarding survival and physiology?";"id:5" +"Answer: Humans have used rabbits as livestock since at least the first century BC in ancient Rome, raising them for meat, fur, and wool. The practice of raising and breeding them is known as cuniculture.";"Question: When did humans begin using rabbits as livestock, for what purposes, and what is the practice of breeding them called?";"id:6" \ No newline at end of file From 67b1c0e996c5c729c20f5d88caa093772892e4da Mon Sep 17 00:00:00 2001 From: farshad68 Date: Tue, 4 Aug 2026 16:43:39 +0200 Subject: [PATCH 44/47] HF decide for seperator of a csv file --- learn2rag/evaluation/tools.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/learn2rag/evaluation/tools.py b/learn2rag/evaluation/tools.py index 2b82471..69e2dbb 100644 --- a/learn2rag/evaluation/tools.py +++ b/learn2rag/evaluation/tools.py @@ -87,8 +87,8 @@ def read_dataset_qa(file_path: pathlib.Path | str, split: str | None = None) -> raise FileNotFoundError(f"Dataset path does not exist: {target_path}") if target_path.suffix.lower() == '.csv': - logging.debug(f'load csv file ') - dataset_dict = datasets.load_dataset('csv', data_files=str(target_path), sep=';') + logging.debug('load csv file') + dataset_dict = datasets.load_dataset('csv', data_files=str(target_path)) else: logging.debug(f'load HF dataset ') dataset_dict = datasets.load_from_disk(str(target_path)) From 2f6e7f37df9f4f2e09cdf52c83bd66f4526957b5 Mon Sep 17 00:00:00 2001 From: denkv Date: Wed, 5 Aug 2026 02:13:19 +0200 Subject: [PATCH 45/47] Fix the optimization pipeline --- .../ui/templates/compose/pipelines/optimization.yml | 13 ++++--------- 1 file changed, 4 insertions(+), 9 deletions(-) diff --git a/learn2rag/ui/templates/compose/pipelines/optimization.yml b/learn2rag/ui/templates/compose/pipelines/optimization.yml index 4e6b999..3d139b5 100644 --- a/learn2rag/ui/templates/compose/pipelines/optimization.yml +++ b/learn2rag/ui/templates/compose/pipelines/optimization.yml @@ -20,11 +20,11 @@ files: force: false - path: '{{storage_path}}/qdrant_config.yml' content: | - log_level: INFO + log_level: ERROR service: api_key: '{{qdrant_api_key}}' grpc_port: null - http_port: '{{ports.qdrant_http}}' + http_port: {{ports.qdrant_http}} host: '127.0.0.1' telemetry_disabled: true - path: '{{storage_path}}/logging_config.yml' @@ -116,12 +116,6 @@ services: - '{{learn2rag_path}}/services/qdrant/qdrant{% if is_windows %}.exe{% endif %}' - '--config-path' - '{{storage_path}}/qdrant_config.yml' - # https://qdrant.tech/documentation/guides/configuration/ - environment: - QDRANT__LOG_LEVEL: 'ERROR' - QDRANT__SERVICE__HOST: '127.0.0.1' - QDRANT__SERVICE__HTTP_PORT: '{{ports.qdrant_http}}' - QDRANT__TELEMETRY_DISABLED: 'true' main: working_dir: '{{storage_path}}' command: @@ -135,7 +129,8 @@ services: - 'training' environment: LEARN2RAG_PATH: '{{learn2rag_path}}' - QDRANT__SERVICE__HTTP_PORT: '{{ports.qdrant_http}}' + QDRANT_LOCATION: '{{ pipeline.qdrant_location or "http://localhost:" ~ ports.qdrant_http }}' + QDRANT_PATH: '{{ pipeline.qdrant_path }}' QDRANT__SERVICE__API_KEY: '{{qdrant_api_key}}' PIPELINE_USER_CONFIG: '{{storage_path}}/basic_user_config.json' IMPORTER_CONFIG: '{{storage_path}}/importer_config.json' From a5e0f83db010f1b5e6f868009f9f6ea71280e1a1 Mon Sep 17 00:00:00 2001 From: farshad68 Date: Wed, 5 Aug 2026 10:56:14 +0200 Subject: [PATCH 46/47] we detect the csv file seperator first --- learn2rag/evaluation/tools.py | 13 ++++++++++++- learn2rag/tests/data/rabbit_eval.csv | 14 +++++++------- 2 files changed, 19 insertions(+), 8 deletions(-) diff --git a/learn2rag/evaluation/tools.py b/learn2rag/evaluation/tools.py index 69e2dbb..6079f1c 100644 --- a/learn2rag/evaluation/tools.py +++ b/learn2rag/evaluation/tools.py @@ -88,7 +88,18 @@ def read_dataset_qa(file_path: pathlib.Path | str, split: str | None = None) -> if target_path.suffix.lower() == '.csv': logging.debug('load csv file') - dataset_dict = datasets.load_dataset('csv', data_files=str(target_path)) + with open(target_path, 'r', encoding='utf-8') as f: + first_line = f.readline() + try: + # Sniff for comma, semicolon, or tab + dialect = csv.Sniffer().sniff(first_line, delimiters=[',', ';', '\t']) + detected_sep = dialect.delimiter + except csv.Error: + # Fallback to standard comma if sniffing fails + detected_sep = ',' + + logging.debug(f'load csv file with delimiter: "{detected_sep}"') + dataset_dict = datasets.load_dataset('csv', data_files=str(target_path), sep=detected_sep) else: logging.debug(f'load HF dataset ') dataset_dict = datasets.load_from_disk(str(target_path)) diff --git a/learn2rag/tests/data/rabbit_eval.csv b/learn2rag/tests/data/rabbit_eval.csv index 431e7ce..df81046 100644 --- a/learn2rag/tests/data/rabbit_eval.csv +++ b/learn2rag/tests/data/rabbit_eval.csv @@ -1,7 +1,7 @@ -answer;question;id -"Answer: Rabbits belong to the family Leporidae, which also includes hares, and the order Lagomorpha, which includes pikas.";"Question: What family and order do rabbits belong to, and what other animals are included in these classifications?";"id:1" -"Answer: The most widespread rabbit genera are Oryctolagus and Sylvilagus. The European rabbit, which belongs to the genus Oryctolagus, has been introduced on every continent except Antarctica.";"Question: What are the most widespread rabbit genera, and on which continents can the European rabbit be found?";"id:2" -"Answer: Rabbits do not constitute a clade because they are a paraphyletic grouping, as hares are nested within the Leporidae clade but not described as rabbits. They differ from rodents by having a number of traits rodents lack, including two extra incisors.";"Question: Why do rabbits not constitute a clade, and how do they physically differ from rodents despite once being classified as such?";"id:3" -"Answer: A rabbit's hind legs are longer than its fore legs, allowing for quick hopping to escape predators and providing powerful kicks if captured. Rabbits are typically nocturnal and often sleep with their eyes open.";"Question: How does the bone structure of a rabbit's legs aid in its survival against predators, and what are their typical sleep habits?";"id:4" -"Answer: A rabbit's ears are essential for thermoregulation, containing a high density of blood vessels. They also have a high surface area to help detect potential predators.";"Question: What functions do a rabbit's ears serve regarding survival and physiology?";"id:5" -"Answer: Humans have used rabbits as livestock since at least the first century BC in ancient Rome, raising them for meat, fur, and wool. The practice of raising and breeding them is known as cuniculture.";"Question: When did humans begin using rabbits as livestock, for what purposes, and what is the practice of breeding them called?";"id:6" \ No newline at end of file +answer;question +"Answer: Rabbits belong to the family Leporidae, which also includes hares, and the order Lagomorpha, which includes pikas.";"Question: What family and order do rabbits belong to, and what other animals are included in these classifications?" +"Answer: The most widespread rabbit genera are Oryctolagus and Sylvilagus. The European rabbit, which belongs to the genus Oryctolagus, has been introduced on every continent except Antarctica.";"Question: What are the most widespread rabbit genera, and on which continents can the European rabbit be found?" +"Answer: Rabbits do not constitute a clade because they are a paraphyletic grouping, as hares are nested within the Leporidae clade but not described as rabbits. They differ from rodents by having a number of traits rodents lack, including two extra incisors.";"Question: Why do rabbits not constitute a clade, and how do they physically differ from rodents despite once being classified as such?" +"Answer: A rabbit's hind legs are longer than its fore legs, allowing for quick hopping to escape predators and providing powerful kicks if captured. Rabbits are typically nocturnal and often sleep with their eyes open.";"Question: How does the bone structure of a rabbit's legs aid in its survival against predators, and what are their typical sleep habits?" +"Answer: A rabbit's ears are essential for thermoregulation, containing a high density of blood vessels. They also have a high surface area to help detect potential predators.";"Question: What functions do a rabbit's ears serve regarding survival and physiology?" +"Answer: Humans have used rabbits as livestock since at least the first century BC in ancient Rome, raising them for meat, fur, and wool. The practice of raising and breeding them is known as cuniculture.";"Question: When did humans begin using rabbits as livestock, for what purposes, and what is the practice of breeding them called?" \ No newline at end of file From cebae414809184ffe37c5cba576fc92316c43f12 Mon Sep 17 00:00:00 2001 From: farshad68 Date: Fri, 7 Aug 2026 13:09:28 +0200 Subject: [PATCH 47/47] merge --- learn2rag/evaluation/tools.py | 2 +- learn2rag/optimization/retrieval_optimization.py | 3 +++ 2 files changed, 4 insertions(+), 1 deletion(-) diff --git a/learn2rag/evaluation/tools.py b/learn2rag/evaluation/tools.py index 6079f1c..7e7c8c3 100644 --- a/learn2rag/evaluation/tools.py +++ b/learn2rag/evaluation/tools.py @@ -92,7 +92,7 @@ def read_dataset_qa(file_path: pathlib.Path | str, split: str | None = None) -> first_line = f.readline() try: # Sniff for comma, semicolon, or tab - dialect = csv.Sniffer().sniff(first_line, delimiters=[',', ';', '\t']) + dialect = csv.Sniffer().sniff(first_line, delimiters=",;\t") detected_sep = dialect.delimiter except csv.Error: # Fallback to standard comma if sniffing fails diff --git a/learn2rag/optimization/retrieval_optimization.py b/learn2rag/optimization/retrieval_optimization.py index adb8e57..586d917 100644 --- a/learn2rag/optimization/retrieval_optimization.py +++ b/learn2rag/optimization/retrieval_optimization.py @@ -518,6 +518,7 @@ def run( for i, r in enumerate(qa) ] + prompt_map = registry["prompts"] cs = ConfigurationSpace(seed=42) cs.add([ Categorical("chunk_size", [250, 1000, 2000], default=1000), @@ -528,6 +529,8 @@ def run( Categorical("fusion_mode", ["none", "DBSF", "RRF"], default="none"), Categorical("reranking", ["True", "False"], default="False"), Categorical("rewrite", ["True", "False"], default="False"), + Integer("top_k", (1, 20), default=4), + Categorical("prompt_template", list(prompt_map.keys()), default="default"), ]) cs.add(ForbiddenGreaterThanRelation(cs["chunk_overlap"], cs["chunk_size"]))