Publier votre travail

DispatchAtlas auto-publie depuis ses registres directement vers les sections dédiées et visibles du site web : un solveur enregistré apparaît dans le Recommandeur de solveurs, un sous-ensemble de benchmarks exporté devient un paquet téléchargeable, et un résultat de campagne exporté est rendu par l'Explorateur de résultats. Chaque étape utilise l'API publique installée -- aucun outillage uniquement-de-dépôt -- de sorte que vos propres solveurs, benchmarks, et résultats atteignent les mêmes surfaces que ceux livrés. L'exécutable examples/publish_to_portal.py parcourt tout le chemin de bout en bout en moins d'une seconde.

Publier un solveur

Un solveur porte des métadonnées de registre (un profil). Enregistrez-le dans un SolverRegistry, et un profil publiquement-catalogué entre dans le catalogue public que le portail rend :

from dispatchatlas.solve import SolverRegistry
 
catalog = SolverRegistry()
catalog.register_instance(your_solver)
published = {metadata.solver_id for metadata in catalog.public_catalog()}

Le paquet de solveurs dérivé-du-registre que le site web sert porte chaque solveur catalogué, de sorte qu'un solveur public enregistré atteint le Recommandeur de solveurs sans étape supplémentaire.

Publier un sous-ensemble de benchmarks

Projetez n'importe quel catalogue en un paquet portable et auto-descriptif et une table CSV plate -- les artefacts exacts que le centre de téléchargement du portail sert à un visiteur :

from dispatchatlas.bench import (
    build_continuum_catalog,
    catalog_metadata_for_sets,
    catalog_subset_to_bundle,
    catalog_subset_to_csv,
)
 
records = catalog_metadata_for_sets(build_continuum_catalog(root_seed=23))
bundle_bytes = catalog_subset_to_bundle(records)  # une archive téléchargeable
csv_text = catalog_subset_to_csv(records)  # une table plate des mêmes lignes

Les deux sont les artefacts téléchargeables que le centre de Téléchargements offre, et le catalogue continu complet est déjà navigable dans le Catalogue de benchmarks.

build_continuum_catalog matérialise un aperçu rapide à trois-ressources -- idéal pour le filtrage du portail et un coup d'œil rapide. Pour des benchmarks de référence à l'échelle-de-recherche, remplacez par build_continuum_full_catalog, qui construit chaque famille à son échelle déclarée -- un pool de ressources et un nombre de tâches plus grands, où la structure de co-allocation, de contention, et de placement se manifeste véritablement -- et passe par la même surface d'export catalog_metadata_for_sets et catalog_subset_to_bundle :

from dispatchatlas.bench import build_continuum_full_catalog
 
research_records = catalog_metadata_for_sets(
    build_continuum_full_catalog(root_seed=23, problem_count_per_family=4)
)
research_bundle = catalog_subset_to_bundle(research_records)  # échelle-de-recherche

Publier depuis un paquet installable

Les sections ci-dessus enregistrent un solveur ou un générateur depuis votre propre script. Pour une extension réutilisable — qu’un autre projet installe et récupère sans code de liaison — DispatchAtlas lit les points d’entrée d’empaquetage, de sorte qu’une distribution installée fournit des solveurs et des générateurs de benchmarks sans toucher aux registres internes. Déclarez un fournisseur sans argument sous le groupe de points d’entrée correspondant dans le pyproject.toml de votre paquet :

[project.entry-points."dispatchatlas.solvers"]
my-solvers = "my_package.providers:scheduling_solvers"
 
[project.entry-points."dispatchatlas.benchmark_generators"]
my-generators = "my_package.providers:scheduling_generators"

Chaque cible est un appelable qui ne prend aucun argument et renvoie un itérable — de ProfiledSolver pour le groupe des solveurs, de BenchmarkGenerator pour le groupe des générateurs — de la même forme que renvoient les fournisseurs livrés. La découverte n’est jamais automatique, donc les catalogues fournis restent déterministes ; l’appelant choisit explicitement d’y adhérer :

from dispatchatlas.bench import GeneratorRegistry, discover_plugin_generators
from dispatchatlas.solve import default_solver_registry, discover_plugin_solvers
 
solvers = default_solver_registry()
discover_plugin_solvers(solvers)  # identifiants des solveurs tiers enregistrés
 
generators = GeneratorRegistry()
discover_plugin_generators(generators)  # identifiants des générateurs tiers enregistrés

Un solveur découvert suit le même chemin register_instance que ci-dessus, donc un solveur d’extension catalogué publiquement atteint le Recommandeur de solveurs sans étape supplémentaire. La découverte est fail-closed sur les preuves : un solveur d’extension qui ne déclare aucune référence de citation, ou un générateur qui prétend être adossé à une citation sans citer de source, est rejeté avant d’entrer dans un registre — une extension tierce porte le même invariant d’adossement par citation que le catalogue livré.

Publier des résultats

Exécutez une campagne, puis exportez-la à travers une politique de divulgation vers le paquet portal-results que l'explorateur de résultats du site rend :

from dispatchatlas.analytica import (
    AnalysisConfig,
    EvidenceTier,
    default_disclosure_policy,
    load_result_dataset,
    write_portal_dataset,
)
 
dataset = load_result_dataset(workspace, "your-campaign-id")
write_portal_dataset(
    dataset,
    default_disclosure_policy(EvidenceTier.CORE),
    target_dir,
    AnalysisConfig(objective_name="makespan"),
)

write_portal_dataset écrit un portal-results.json à-hachage-de-contenu filtré au niveau de divulgation déclaré -- le paquet exact que l'Explorateur de résultats rend, de sorte que l'export est vos résultats publiés au portail. Le filtre de divulgation est fail-closed : un résultat que le niveau ne permet pas n'est jamais publié, de sorte qu'une étude ne peut pas sur-partager par accident.

Voyez-le de bout en bout

uv run python examples/publish_to_portal.py

L'exemple enregistre un solveur, confirme qu'il monte dans le paquet de solveurs du portail, exporte un sous-ensemble de benchmarks vers un paquet et un CSV, et exécute une campagne dont les résultats s'exportent dans le format de l'explorateur-de-résultats du portail -- tout le chemin de publication, lu directement depuis l'API publique installée et les paquets du portail commités que le site livre.