Publicar seu trabalho

O DispatchAtlas auto-publica de seus registros diretamente para as seções dedicadas e visíveis do site: um solver registrado aparece no Recomendador de solvers, um subconjunto de benchmarks exportado se torna um pacote baixável, e um resultado de campanha exportado é renderizado pelo Explorador de resultados. Cada passo usa a API pública instalada -- sem tooling apenas-de-repositório -- de modo que seus próprios solvers, benchmarks, e resultados alcançam as mesmas superfícies que os enviados. O executável examples/publish_to_portal.py percorre todo o caminho de ponta a ponta em menos de um segundo.

Publicar um solver

Um solver carrega metadados de registro (um perfil). Registre-o em um SolverRegistry, e um perfil publicamente-catalogado entra no catálogo público que o portal renderiza:

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

O pacote de solvers derivado-do-registro que o site serve carrega cada solver catalogado, de modo que um solver público registrado alcança o Recomendador de solvers sem passo extra.

Publicar um subconjunto de benchmarks

Projete qualquer catálogo em um pacote portátil e auto-descritivo e uma tabela CSV plana -- os artefatos exatos que o centro de download do portal serve a um 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)  # um arquivo baixável
csv_text = catalog_subset_to_csv(records)  # uma tabela plana das mesmas linhas

Ambos são os artefatos baixáveis que o centro de Downloads oferece, e o catálogo contínuo completo já é navegável no Catálogo de benchmarks.

build_continuum_catalog materializa uma prévia rápida de três-recursos -- ideal para a filtragem do portal e uma olhada rápida. Para benchmarks de referência em escala-de-pesquisa, troque por build_continuum_full_catalog, que constrói cada família em sua escala declarada -- um pool de recursos e contagem de tarefas maior, onde a estrutura de co-alocação, contenção, e colocação genuinamente se manifesta -- e flui através da mesma superfície de exportação catalog_metadata_for_sets e 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-pesquisa

Publicar a partir de um pacote instalável

As seções acima registram um solver ou um gerador de dentro do seu próprio script. Para uma extensão reutilizável —uma que outro projeto instala e capta sem código de cola— o DispatchAtlas lê os pontos de entrada de empacotamento, de modo que uma distribuição instalada contribui com solvers e geradores de benchmarks sem tocar nos registros internos. Declare um provedor sem argumentos sob o grupo de pontos de entrada correspondente no pyproject.toml do seu pacote:

[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 alvo é um chamável que não recebe argumentos e devolve um iterável —de ProfiledSolver para o grupo de solvers, de BenchmarkGenerator para o grupo de geradores— com a mesma forma que os provedores incluídos devolvem. A descoberta nunca é automática, então os catálogos incluídos permanecem determinísticos; quem chama opta explicitamente:

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 dos solvers de terceiros registrados
 
generators = GeneratorRegistry()
discover_plugin_generators(generators)  # ids dos geradores de terceiros registrados

Um solver descoberto flui pelo mesmo caminho register_instance que o acima, então um solver de plugin catalogado publicamente chega ao Recomendador de solvers sem nenhum passo extra. A descoberta é fail-closed quanto à evidência: um solver de plugin que não declara nenhuma referência de citação, ou um gerador que afirma ter respaldo de citação sem citar nenhuma fonte, é rejeitado antes de entrar em um registro — uma extensão de terceiros carrega o mesmo invariante de respaldo por citação que o catálogo incluído.

Publicar resultados

Rode uma campanha, depois exporte-a através de uma política de divulgação para o pacote de portal-results que o explorador de resultados do site 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 escreve um portal-results.json com-hash-de-conteúdo filtrado ao nível de divulgação declarado -- o pacote exato que o Explorador de resultados renderiza, de modo que a exportação são seus resultados publicados ao portal. O filtro de divulgação é fail-closed: um resultado que o nível não permite nunca é publicado, de modo que um estudo não pode super-compartilhar por acidente.

Veja de ponta a ponta

uv run python examples/publish_to_portal.py

O exemplo registra um solver, confirma que ele viaja no pacote de solvers do portal, exporta um subconjunto de benchmarks para um pacote e um CSV, e roda uma campanha cujos resultados se exportam no formato do explorador-de-resultados do portal -- todo o caminho de publicação, lido diretamente da API pública instalada e dos pacotes do portal comprometidos que o site envia.