Publicar tu trabajo

DispatchAtlas auto-publica desde sus registros directamente a las secciones dedicadas y visibles del sitio web: un solver registrado aparece en el Recomendador de solvers, un subconjunto de benchmarks exportado se vuelve un paquete descargable, y un resultado de campaña exportado es renderizado por el Explorador de resultados. Cada paso usa la API pública instalada -- sin tooling solo-de-repositorio -- de modo que tus propios solvers, benchmarks, y resultados alcanzan las mismas superficies que los enviados. El ejecutable examples/publish_to_portal.py recorre todo el camino de extremo a extremo en menos de un segundo.

Publicar un solver

Un solver lleva metadatos de registro (un perfil). Regístralo en un SolverRegistry, y un perfil públicamente-catalogado entra al catálogo público que el portal renderiza:

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

El paquete de solvers derivado-del-registro que el sitio web sirve lleva cada solver catalogado, de modo que un solver público registrado alcanza el Recomendador de solvers sin paso extra.

Publicar un subconjunto de benchmarks

Proyecta cualquier catálogo en un paquete portátil y auto-descriptivo y una tabla CSV plana -- los artefactos exactos que el centro de descargas del portal sirve a un visitante:

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)  # un archivo descargable
csv_text = catalog_subset_to_csv(records)  # una tabla plana de las mismas filas

Ambos son los artefactos descargables que el centro de Descargas ofrece, y el catálogo continuo completo ya es navegable en el Catálogo de benchmarks.

build_continuum_catalog materializa una vista previa rápida de tres-recursos -- ideal para el filtrado del portal y un vistazo rápido. Para benchmarks de referencia a escala-de-investigación, intercambia build_continuum_full_catalog, que construye cada familia en su escala declarada -- un grupo de recursos y conteo de tareas mayor, donde la estructura de co-asignación, contención, y colocación genuinamente se manifiesta -- y fluye a través de la misma superficie de exportación catalog_metadata_for_sets y 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)  # escala-de-investigación

Publicar desde un paquete instalable

Las secciones anteriores registran un solver o un generador desde tu propio script. Para una extensión reutilizable —una que otro proyecto instala y recoge sin código de pegamento— DispatchAtlas lee los puntos de entrada de empaquetado, de modo que una distribución instalada aporta solvers y generadores de benchmarks sin tocar los registros internos. Declara un proveedor sin argumentos bajo el grupo de puntos de entrada correspondiente en el pyproject.toml de tu paquete:

[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"

Cada destino es un invocable que no toma argumentos y devuelve un iterable —de ProfiledSolver para el grupo de solvers, de BenchmarkGenerator para el grupo de generadores— con la misma forma que devuelven los proveedores incluidos. El descubrimiento nunca es automático, así que los catálogos incluidos siguen siendo deterministas; quien llama opta de forma explícita:

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)  # ids de los solvers de terceros registrados
 
generators = GeneratorRegistry()
discover_plugin_generators(generators)  # ids de los generadores de terceros registrados

Un solver descubierto fluye por la misma ruta register_instance que el anterior, así que un solver de complemento catalogado públicamente llega al Recomendador de solvers sin ningún paso adicional. El descubrimiento es fail-closed respecto a la evidencia: un solver de complemento que no declara ninguna referencia de cita, o un generador que afirma estar respaldado por citas sin citar ninguna fuente, se rechaza antes de entrar en un registro: una extensión de terceros porta el mismo invariante de respaldo por citas que el catálogo incluido.

Publicar resultados

Corre una campaña, luego expórtala a través de una política de divulgación al paquete de portal-results que el explorador de resultados del sitio renderiza:

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 escribe un portal-results.json con-hash-de-contenido filtrado al nivel de divulgación declarado -- el paquete exacto que el Explorador de resultados renderiza, de modo que la exportación es tus resultados publicados al portal. El filtro de divulgación es fail-closed: un resultado que el nivel no permite nunca se publica, de modo que un estudio no puede sobre-compartir por accidente.

Velo de extremo a extremo

uv run python examples/publish_to_portal.py

El ejemplo registra un solver, confirma que viaja en el paquete de solvers del portal, exporta un subconjunto de benchmarks a un paquete y un CSV, y corre una campaña cuyos resultados se exportan en el formato del explorador-de-resultados del portal -- todo el camino de publicación, leído directamente desde la API pública instalada y los paquetes del portal comprometidos que el sitio envía.