Full Code of replicate/cog for AI

gitextract_1_nczbz8/

├── .all-contributorsrc
├── .git_archival.txt
├── .gitattributes
├── .github/
│   ├── CODEOWNERS
│   ├── dependabot.yml
│   └── workflows/
│       ├── README.md
│       ├── ci.yaml
│       ├── codeql.yml
│       ├── docs.yaml
│       ├── release-build.yaml
│       └── release-publish.yaml
├── .gitignore
├── .golangci.yaml
├── .goreleaser.yaml
├── .mockery.yml
├── .vscode/
│   ├── extensions.json
│   └── settings.json
├── AGENTS.md
├── CONTRIBUTING.md
├── DESIGN.md
├── LICENSE
├── Makefile
├── README.md
├── architecture/
│   ├── 00-overview.md
│   ├── 01-model-source.md
│   ├── 02-schema.md
│   ├── 05-build-system.md
│   ├── 06-cli.md
│   ├── ffi/
│   │   ├── 03-prediction-api.md
│   │   ├── 04-container-runtime.md
│   │   └── README.md
│   └── legacy/
│       ├── 03-prediction-api.md
│       ├── 04-container-runtime.md
│       └── README.md
├── cmd/
│   └── cog/
│       └── cog.go
├── crates/
│   ├── .gitignore
│   ├── Cargo.toml
│   ├── README.md
│   ├── coglet/
│   │   ├── Cargo.toml
│   │   ├── README.md
│   │   └── src/
│   │       ├── bridge/
│   │       │   ├── codec.rs
│   │       │   ├── mod.rs
│   │       │   ├── protocol.rs
│   │       │   ├── snapshots/
│   │       │   │   ├── coglet__bridge__protocol__tests__control_cancel_serializes.snap
│   │       │   │   ├── coglet__bridge__protocol__tests__control_cancelled_serializes.snap
│   │       │   │   ├── coglet__bridge__protocol__tests__control_failed_serializes.snap
│   │       │   │   ├── coglet__bridge__protocol__tests__control_healthcheck_result_healthy_serializes.snap
│   │       │   │   ├── coglet__bridge__protocol__tests__control_healthcheck_result_unhealthy_serializes.snap
│   │       │   │   ├── coglet__bridge__protocol__tests__control_healthcheck_serializes.snap
│   │       │   │   ├── coglet__bridge__protocol__tests__control_idle_serializes.snap
│   │       │   │   ├── coglet__bridge__protocol__tests__control_init_serializes.snap
│   │       │   │   ├── coglet__bridge__protocol__tests__control_ready_serializes.snap
│   │       │   │   ├── coglet__bridge__protocol__tests__control_ready_with_schema_serializes.snap
│   │       │   │   ├── coglet__bridge__protocol__tests__control_shutdown_serializes.snap
│   │       │   │   ├── coglet__bridge__protocol__tests__slot_cancelled_serializes.snap
│   │       │   │   ├── coglet__bridge__protocol__tests__slot_done_serializes.snap
│   │       │   │   ├── coglet__bridge__protocol__tests__slot_failed_serializes.snap
│   │       │   │   ├── coglet__bridge__protocol__tests__slot_log_serializes.snap
│   │       │   │   ├── coglet__bridge__protocol__tests__slot_metric_append_serializes.snap
│   │       │   │   ├── coglet__bridge__protocol__tests__slot_metric_complex_value_serializes.snap
│   │       │   │   ├── coglet__bridge__protocol__tests__slot_metric_delete_serializes.snap
│   │       │   │   ├── coglet__bridge__protocol__tests__slot_metric_increment_serializes.snap
│   │       │   │   ├── coglet__bridge__protocol__tests__slot_metric_replace_serializes.snap
│   │       │   │   ├── coglet__bridge__protocol__tests__slot_output_serializes.snap
│   │       │   │   ├── coglet__bridge__protocol__tests__slot_predict_file_input_serializes.snap
│   │       │   │   └── coglet__bridge__protocol__tests__slot_predict_serializes.snap
│   │       │   └── transport.rs
│   │       ├── fd_redirect.rs
│   │       ├── health.rs
│   │       ├── input_validation.rs
│   │       ├── lib.rs
│   │       ├── orchestrator.rs
│   │       ├── permit/
│   │       │   ├── mod.rs
│   │       │   ├── pool.rs
│   │       │   └── slot.rs
│   │       ├── prediction.rs
│   │       ├── predictor.rs
│   │       ├── service.rs
│   │       ├── setup_log_accumulator.rs
│   │       ├── snapshots/
│   │       │   ├── coglet__health__tests__health_all_variants.snap
│   │       │   ├── coglet__health__tests__health_response_all_variants.snap
│   │       │   ├── coglet__health__tests__setup_status_all_variants.snap
│   │       │   ├── coglet__predictor__tests__output_single.snap
│   │       │   ├── coglet__predictor__tests__output_stream.snap
│   │       │   ├── coglet__version__tests__version_full.snap
│   │       │   └── coglet__version__tests__version_minimal.snap
│   │       ├── transport/
│   │       │   ├── http/
│   │       │   │   ├── mod.rs
│   │       │   │   ├── routes.rs
│   │       │   │   └── server.rs
│   │       │   └── mod.rs
│   │       ├── version.rs
│   │       ├── webhook.rs
│   │       ├── worker.rs
│   │       └── worker_tracing_layer.rs
│   ├── coglet-python/
│   │   ├── Cargo.toml
│   │   ├── README.md
│   │   ├── build.rs
│   │   ├── coglet/
│   │   │   ├── __init__.py
│   │   │   ├── __init__.pyi
│   │   │   ├── _impl.pyi
│   │   │   ├── _sdk/
│   │   │   │   └── __init__.pyi
│   │   │   └── py.typed
│   │   ├── pyproject.toml
│   │   ├── src/
│   │   │   ├── audit.rs
│   │   │   ├── bin/
│   │   │   │   └── stub_gen.rs
│   │   │   ├── cancel.rs
│   │   │   ├── input.rs
│   │   │   ├── lib.rs
│   │   │   ├── log_writer.rs
│   │   │   ├── metric_scope.rs
│   │   │   ├── output.rs
│   │   │   ├── predictor.rs
│   │   │   └── worker_bridge.rs
│   │   └── tests/
│   │       └── test_coglet.py
│   └── deny.toml
├── docs/
│   ├── CNAME
│   ├── cli.md
│   ├── deploy.md
│   ├── environment.md
│   ├── getting-started-own-model.md
│   ├── getting-started.md
│   ├── http.md
│   ├── llms.txt
│   ├── notebooks.md
│   ├── private-package-registry.md
│   ├── python.md
│   ├── stylesheets/
│   │   └── extra.css
│   ├── training.md
│   ├── wsl2/
│   │   └── wsl2.md
│   └── yaml.md
├── go.mod
├── go.sum
├── integration-tests/
│   ├── .gitignore
│   ├── README.md
│   ├── concurrent/
│   │   └── concurrent_test.go
│   ├── harness/
│   │   ├── cmd_pty.go
│   │   ├── command.go
│   │   └── harness.go
│   ├── login/
│   │   └── login_test.go
│   ├── suite_test.go
│   └── tests/
│       ├── apt_packages.txtar
│       ├── async_generator_precollect.txtar
│       ├── async_predictor.txtar
│       ├── async_sleep.txtar
│       ├── bad_dockerignore.txtar
│       ├── bool_input_output.txtar
│       ├── build_base_image_sha.txtar
│       ├── build_cog_init.txtar
│       ├── build_cog_version_match.txtar
│       ├── build_gpu_labels.txtar
│       ├── build_image_option.txtar
│       ├── build_openapi_schema.txtar
│       ├── build_openapi_schema_complex.txtar
│       ├── build_pip_freeze.txtar
│       ├── build_python313_base_image.txtar
│       ├── build_torch_version_required.txtar
│       ├── ca_cert.txtar
│       ├── cancel_async_prediction.txtar
│       ├── cancel_repeated.txtar
│       ├── cancel_sync_prediction.txtar
│       ├── coglet_iterator_path_output.txtar
│       ├── coglet_iterator_upload_url.txtar
│       ├── coglet_large_file_upload_serial.txtar
│       ├── coglet_large_input.txtar
│       ├── coglet_large_output.txtar
│       ├── coglet_list_path_single_element.txtar
│       ├── coglet_list_path_upload_url.txtar
│       ├── coglet_metrics.txtar
│       ├── coglet_metrics_webhook.txtar
│       ├── coglet_single_path_output.txtar
│       ├── complex_output.txtar
│       ├── concatenate_iterator_output.txtar
│       ├── config_subdirectory.txtar
│       ├── debug_secrets.txtar
│       ├── dict_output.txtar
│       ├── emit_metric_deprecated.txtar
│       ├── env_vars.txtar
│       ├── experimental_feature_warning.txtar
│       ├── ffmpeg_package.txtar
│       ├── file_input.txtar
│       ├── file_list_input.txtar
│       ├── float_input_output.txtar
│       ├── function_predictor.txtar
│       ├── future_annotations.txtar
│       ├── glb_project.txtar
│       ├── granite_project.txtar
│       ├── healthcheck.txtar
│       ├── healthcheck_async.txtar
│       ├── healthcheck_async_exception.txtar
│       ├── healthcheck_async_timeout.txtar
│       ├── healthcheck_async_unhealthy.txtar
│       ├── healthcheck_during_prediction.txtar
│       ├── healthcheck_exception.txtar
│       ├── healthcheck_immediately_after_prediction.txtar
│       ├── healthcheck_repeated_calls.txtar
│       ├── healthcheck_timeout.txtar
│       ├── healthcheck_unhealthy.txtar
│       ├── int_input_output.txtar
│       ├── int_none_output.txtar
│       ├── int_predictor.txtar
│       ├── invalid_int_validation.txtar
│       ├── iterator_error_midstream.txtar
│       ├── iterator_string_output.txtar
│       ├── legacy_sdk_schema.txtar
│       ├── list_int_input_output.txtar
│       ├── list_string_output.txtar
│       ├── many_inputs.txtar
│       ├── multi_file_schema.txtar
│       ├── nested_output_types.txtar
│       ├── no_predictor.txtar
│       ├── non_base_predictor_class.txtar
│       ├── non_base_predictor_function.txtar
│       ├── oci_bundle_build.txtar
│       ├── oci_bundle_inspect.txtar
│       ├── oci_bundle_push.txtar
│       ├── optional_path_input.txtar
│       ├── path_input.txtar
│       ├── path_input_output.txtar
│       ├── path_list_input.txtar
│       ├── path_list_output.txtar
│       ├── path_output.txtar
│       ├── predict_existing_image.txtar
│       ├── predict_json_file.txtar
│       ├── predict_json_input.txtar
│       ├── predict_json_output_file.txtar
│       ├── predict_json_stdin.txtar
│       ├── predict_json_stdin_dash.txtar
│       ├── predict_many_inputs_image.txtar
│       ├── predict_output_file.txtar
│       ├── predict_output_string.txtar
│       ├── predict_sys_exit.txtar
│       ├── prediction_error_response.txtar
│       ├── pty_echo.txtar
│       ├── pty_interactive.txtar
│       ├── pydantic2.txtar
│       ├── pydantic2_output.txtar
│       ├── python313.txtar
│       ├── python37_deprecated.txtar
│       ├── python38_deprecated.txtar
│       ├── python39_deprecated.txtar
│       ├── run_basic.txtar
│       ├── run_stdin_cat.txtar
│       ├── run_stdin_unconsumed.txtar
│       ├── scope_context.txtar
│       ├── secrets.txtar
│       ├── sequential_state_leak.txtar
│       ├── setup_slow_serial.txtar
│       ├── setup_subprocess_double_fork.txtar
│       ├── setup_subprocess_double_fork_http.txtar
│       ├── setup_subprocess_multiprocessing.txtar
│       ├── setup_subprocess_simple.txtar
│       ├── setup_timeout_serial.txtar
│       ├── setup_worker_tracing_logs.txtar
│       ├── static_schema_fallback.txtar
│       ├── static_schema_gen.txtar
│       ├── string_list_input.txtar
│       ├── string_none_output.txtar
│       ├── string_predictor.txtar
│       ├── subdirectory_predictor.txtar
│       ├── tensorflow.txtar
│       ├── torch_270_cuda_126.txtar
│       ├── torch_271_cuda_128.txtar
│       ├── torch_baseimage_fallback.txtar
│       ├── torch_baseimage_no_cog_base.txtar
│       ├── torch_baseimage_precompile.txtar
│       ├── torch_cuda_baseimage.txtar
│       ├── train_basic.txtar
│       ├── train_deprecated.txtar
│       ├── training_setup.txtar
│       ├── union_type.txtar
│       ├── webhook_delivery_failure.txtar
│       ├── webhook_prediction_error.txtar
│       ├── weights_build.txtar
│       ├── weights_push_inspect.txtar
│       ├── wheel_coglet_missing.txtar
│       ├── wheel_resolution.txtar
│       └── zsh_package.txtar
├── mise.toml
├── mkdocs.yml
├── noxfile.py
├── pkg/
│   ├── cli/
│   │   ├── baseimage.go
│   │   ├── build.go
│   │   ├── debug.go
│   │   ├── init-templates/
│   │   │   └── base/
│   │   │       ├── .dockerignore
│   │   │       ├── .github/
│   │   │       │   └── workflows/
│   │   │       │       └── push.yaml
│   │   │       ├── cog.yaml
│   │   │       ├── predict.py
│   │   │       └── requirements.txt
│   │   ├── init.go
│   │   ├── init_test.go
│   │   ├── inspect.go
│   │   ├── login.go
│   │   ├── predict.go
│   │   ├── predict_test.go
│   │   ├── push.go
│   │   ├── root.go
│   │   ├── run.go
│   │   ├── serve.go
│   │   ├── train.go
│   │   ├── train_test.go
│   │   ├── weights.go
│   │   └── weights_inspect.go
│   ├── config/
│   │   ├── build_options.go
│   │   ├── compatibility.go
│   │   ├── compatibility_test.go
│   │   ├── config.go
│   │   ├── config_file.go
│   │   ├── config_test.go
│   │   ├── cuda_compatibility.json
│   │   ├── data/
│   │   │   └── config_schema_v1.0.json
│   │   ├── env.go
│   │   ├── env_variables_test.go
│   │   ├── errors.go
│   │   ├── image_name.go
│   │   ├── image_name_test.go
│   │   ├── load.go
│   │   ├── load_test.go
│   │   ├── parse.go
│   │   ├── tf_compatibility.json
│   │   ├── torch_compatibility.json
│   │   ├── validate.go
│   │   ├── validate_test.go
│   │   └── version.go
│   ├── docker/
│   │   ├── build_secrets.go
│   │   ├── buildkit.go
│   │   ├── command/
│   │   │   ├── command.go
│   │   │   ├── errors.go
│   │   │   ├── manifest.go
│   │   │   └── user_info.go
│   │   ├── credential_helper_input.go
│   │   ├── credentials.go
│   │   ├── credentials_test.go
│   │   ├── docker.go
│   │   ├── docker_client_test.go
│   │   ├── dockertest/
│   │   │   ├── command_mocks.go
│   │   │   ├── helper_client.go
│   │   │   ├── image.go
│   │   │   ├── mock_command.go
│   │   │   ├── ref.go
│   │   │   ├── ref_test.go
│   │   │   └── testdata/
│   │   │       └── create-image-fixtures.sh
│   │   ├── env.go
│   │   ├── errors.go
│   │   ├── host.go
│   │   ├── host_unix.go
│   │   ├── host_windows.go
│   │   ├── login.go
│   │   ├── options.go
│   │   ├── progress.go
│   │   ├── push.go
│   │   ├── run.go
│   │   ├── run_test.go
│   │   ├── standard_push.go
│   │   └── standard_push_test.go
│   ├── dockercontext/
│   │   ├── build_tempdir.go
│   │   ├── build_tempdir_test.go
│   │   └── directories.go
│   ├── dockerfile/
│   │   ├── base.go
│   │   ├── base_test.go
│   │   ├── cacert.go
│   │   ├── cacert_test.go
│   │   ├── env.go
│   │   ├── generator.go
│   │   ├── generator_factory.go
│   │   ├── generator_factory_test.go
│   │   ├── standard_generator.go
│   │   ├── standard_generator_test.go
│   │   └── version_check.go
│   ├── dockerignore/
│   │   ├── dockerignore.go
│   │   └── dockerignore_test.go
│   ├── env/
│   │   ├── env.go
│   │   └── env_test.go
│   ├── errors/
│   │   ├── common.go
│   │   └── errors.go
│   ├── global/
│   │   └── global.go
│   ├── http/
│   │   ├── client.go
│   │   ├── client_test.go
│   │   ├── transport.go
│   │   ├── transport_test.go
│   │   ├── user_agent.go
│   │   └── user_agent_test.go
│   ├── image/
│   │   ├── build.go
│   │   ├── build_test.go
│   │   ├── config.go
│   │   ├── openapi_schema.go
│   │   └── pip_freeze.go
│   ├── model/
│   │   ├── artifact.go
│   │   ├── artifact_image.go
│   │   ├── artifact_image_test.go
│   │   ├── artifact_test.go
│   │   ├── artifact_weight.go
│   │   ├── artifact_weight_test.go
│   │   ├── builder.go
│   │   ├── builder_test.go
│   │   ├── errors.go
│   │   ├── errors_test.go
│   │   ├── factory.go
│   │   ├── factory_test.go
│   │   ├── format.go
│   │   ├── format_test.go
│   │   ├── hash.go
│   │   ├── image_builder.go
│   │   ├── image_builder_test.go
│   │   ├── image_pusher.go
│   │   ├── image_pusher_test.go
│   │   ├── image_test.go
│   │   ├── index.go
│   │   ├── index_factory.go
│   │   ├── index_factory_test.go
│   │   ├── index_test.go
│   │   ├── model.go
│   │   ├── model_test.go
│   │   ├── options.go
│   │   ├── options_test.go
│   │   ├── push_helpers.go
│   │   ├── pusher.go
│   │   ├── pusher_test.go
│   │   ├── ref.go
│   │   ├── ref_test.go
│   │   ├── ref_types.go
│   │   ├── ref_types_test.go
│   │   ├── resolver.go
│   │   ├── resolver_test.go
│   │   ├── source.go
│   │   ├── source_test.go
│   │   ├── weight_builder.go
│   │   ├── weight_builder_test.go
│   │   ├── weight_pusher.go
│   │   ├── weight_pusher_test.go
│   │   ├── weights.go
│   │   ├── weights_lock.go
│   │   ├── weights_lock_test.go
│   │   └── weights_test.go
│   ├── path/
│   │   ├── path.go
│   │   └── path_test.go
│   ├── predict/
│   │   ├── api.go
│   │   ├── input.go
│   │   └── predictor.go
│   ├── provider/
│   │   ├── generic/
│   │   │   ├── generic.go
│   │   │   └── generic_test.go
│   │   ├── provider.go
│   │   ├── registry.go
│   │   ├── registry_test.go
│   │   ├── replicate/
│   │   │   ├── replicate.go
│   │   │   └── replicate_test.go
│   │   └── setup/
│   │       ├── setup.go
│   │       └── setup_test.go
│   ├── registry/
│   │   ├── client.go
│   │   ├── client_test.go
│   │   ├── config.go
│   │   ├── config_test.go
│   │   ├── manifest_result.go
│   │   ├── push_test.go
│   │   ├── registry_client.go
│   │   └── registrytest/
│   │       └── mock_client.go
│   ├── registry_testhelpers/
│   │   ├── registry_container.go
│   │   └── testdata/
│   │       └── docker/
│   │           └── registry/
│   │               └── v2/
│   │                   ├── blobs/
│   │                   │   └── sha256/
│   │                   │       ├── 1c/
│   │                   │       │   └── 1c4eef651f65e2f7daee7ee785882ac164b02b78fb74503052a26dc061c90474/
│   │                   │       │       └── data
│   │                   │       ├── 6e/
│   │                   │       │   └── 6e771e15690e2fabf2332d3a3b744495411d6e0b00b2aea64419b58b0066cf81/
│   │                   │       │       └── data
│   │                   │       ├── 75/
│   │                   │       │   └── 757d680068d77be46fd1ea20fb21db16f150468c5e7079a08a2e4705aec096ac/
│   │                   │       │       └── data
│   │                   │       ├── 8d/
│   │                   │       │   └── 8d591b0b7dea080ea3be9e12ae563eebf9869168ffced1cb25b2470a3d9fe15e/
│   │                   │       │       └── data
│   │                   │       ├── 9a/
│   │                   │       │   └── 9a0ff41dccad7a96f324a4655a715c623ed3511c7336361ffa9dadcecbdb99e5/
│   │                   │       │       └── data
│   │                   │       ├── ad/
│   │                   │       │   └── aded1e1a5b3705116fa0a92ba074a5e0b0031647d9c315983ccba2ee5428ec8b/
│   │                   │       │       └── data
│   │                   │       └── f1/
│   │                   │           └── f18232174bc91741fdf3da96d85011092101a032a93a388b79e99e69c2d5c870/
│   │                   │               └── data
│   │                   └── repositories/
│   │                       └── alpine/
│   │                           ├── _layers/
│   │                           │   └── sha256/
│   │                           │       ├── 6e771e15690e2fabf2332d3a3b744495411d6e0b00b2aea64419b58b0066cf81/
│   │                           │       │   └── link
│   │                           │       ├── 8d591b0b7dea080ea3be9e12ae563eebf9869168ffced1cb25b2470a3d9fe15e/
│   │                           │       │   └── link
│   │                           │       ├── aded1e1a5b3705116fa0a92ba074a5e0b0031647d9c315983ccba2ee5428ec8b/
│   │                           │       │   └── link
│   │                           │       └── f18232174bc91741fdf3da96d85011092101a032a93a388b79e99e69c2d5c870/
│   │                           │           └── link
│   │                           └── _manifests/
│   │                               ├── revisions/
│   │                               │   └── sha256/
│   │                               │       ├── 1c4eef651f65e2f7daee7ee785882ac164b02b78fb74503052a26dc061c90474/
│   │                               │       │   └── link
│   │                               │       ├── 757d680068d77be46fd1ea20fb21db16f150468c5e7079a08a2e4705aec096ac/
│   │                               │       │   └── link
│   │                               │       └── 9a0ff41dccad7a96f324a4655a715c623ed3511c7336361ffa9dadcecbdb99e5/
│   │                               │           └── link
│   │                               └── tags/
│   │                                   └── latest/
│   │                                       ├── current/
│   │                                       │   └── link
│   │                                       └── index/
│   │                                           └── sha256/
│   │                                               └── 9a0ff41dccad7a96f324a4655a715c623ed3511c7336361ffa9dadcecbdb99e5/
│   │                                                   └── link
│   ├── requirements/
│   │   ├── requirements.go
│   │   └── requirements_test.go
│   ├── schema/
│   │   ├── errors.go
│   │   ├── generator.go
│   │   ├── generator_test.go
│   │   ├── openapi.go
│   │   ├── openapi_test.go
│   │   ├── python/
│   │   │   ├── parser.go
│   │   │   ├── parser_fuzz_test.go
│   │   │   └── parser_test.go
│   │   ├── schema_type.go
│   │   ├── schema_type_fuzz_test.go
│   │   └── types.go
│   ├── update/
│   │   ├── state.go
│   │   └── update.go
│   ├── util/
│   │   ├── console/
│   │   │   ├── console.go
│   │   │   ├── formatting.go
│   │   │   ├── global.go
│   │   │   ├── interactive.go
│   │   │   ├── levels.go
│   │   │   └── term.go
│   │   ├── env.go
│   │   ├── errors.go
│   │   ├── files/
│   │   │   ├── files.go
│   │   │   └── files_test.go
│   │   ├── hash.go
│   │   ├── hash_test.go
│   │   ├── mime/
│   │   │   ├── mime.go
│   │   │   └── mime_test.go
│   │   ├── net.go
│   │   ├── overwrite_yaml.go
│   │   ├── overwrite_yaml_test.go
│   │   ├── platform.go
│   │   ├── ringbuffer.go
│   │   ├── shell/
│   │   │   ├── net.go
│   │   │   └── pipes.go
│   │   └── version/
│   │       ├── version.go
│   │       └── version_test.go
│   ├── web/
│   │   ├── client.go
│   │   └── client_test.go
│   ├── weights/
│   │   ├── manifest.go
│   │   ├── weights.go
│   │   └── weights_test.go
│   └── wheels/
│       ├── wheels.go
│       └── wheels_test.go
├── pyproject.toml
├── python/
│   ├── cog/
│   │   ├── .gitignore
│   │   ├── __init__.py
│   │   ├── _adt.py
│   │   ├── _inspector.py
│   │   ├── _schemas.py
│   │   ├── coder.py
│   │   ├── command/
│   │   │   ├── __init__.py
│   │   │   └── openapi_schema.py
│   │   ├── config.py
│   │   ├── errors.py
│   │   ├── input.py
│   │   ├── mode.py
│   │   ├── model.py
│   │   ├── predictor.py
│   │   ├── server/
│   │   │   ├── __init__.py
│   │   │   └── http.py
│   │   ├── suppress_output.py
│   │   └── types.py
│   └── tests/
│       ├── __init__.py
│       ├── test_emit_metric.py
│       ├── test_experimental_feature_warning.py
│       ├── test_input.py
│       ├── test_model.py
│       ├── test_predictor.py
│       └── test_types.py
├── script/
│   └── generate-compat
├── test-helpers/
│   └── https-server/
│       ├── go.mod
│       └── main.go
├── test-integration/
│   └── test_integration/
│       └── fixtures/
│           └── hello-image/
│               ├── cog.yaml
│               └── predict.py
└── tools/
    ├── compatgen/
    │   ├── internal/
    │   │   ├── cuda.go
    │   │   ├── tensorflow.go
    │   │   ├── torch.go
    │   │   ├── torch_package.go
    │   │   ├── torch_test.go
    │   │   ├── torch_test.html
    │   │   └── util.go
    │   └── main.go
    ├── gendocs/
    │   └── main.go
    ├── install.sh
    ├── test-harness/
    │   ├── .gitignore
    │   ├── README.md
    │   ├── harness/
    │   │   ├── __init__.py
    │   │   ├── __main__.py
    │   │   ├── cli.py
    │   │   ├── cog_resolver.py
    │   │   ├── patcher.py
    │   │   ├── report.py
    │   │   ├── runner.py
    │   │   └── validators.py
    │   ├── manifest.yaml
    │   ├── pyproject.toml
    │   └── results/
    │       └── .gitkeep
    ├── test-registry-util/
    │   ├── README.md
    │   └── main.go
    └── weights-gen/
        ├── README.md
        └── main.go

SYMBOL INDEX (3199 symbols across 290 files)

FILE: cmd/cog/cog.go
  function main (line 8) | func main() {

FILE: crates/coglet-python/build.rs
  function main (line 7) | fn main() {
  function semver_to_pep440 (line 73) | fn semver_to_pep440(version: &str) -> String {
  function test_stable_version (line 121) | fn test_stable_version() {
  function test_alpha (line 127) | fn test_alpha() {
  function test_beta (line 134) | fn test_beta() {
  function test_rc (line 140) | fn test_rc() {
  function test_dev (line 146) | fn test_dev() {

FILE: crates/coglet-python/coglet/_impl.pyi
  class BuildInfo (line 18) | class BuildInfo:
    method version (line 23) | def version(self) -> builtins.str: ...
    method git_sha (line 25) | def git_sha(self) -> builtins.str: ...
    method build_time (line 27) | def build_time(self) -> builtins.str: ...
    method rustc_version (line 29) | def rustc_version(self) -> builtins.str: ...
    method __repr__ (line 30) | def __repr__(self) -> builtins.str: ...
  class CancelationException (line 32) | class CancelationException(builtins.BaseException):
  class Server (line 44) | class Server:
    method active (line 54) | def active(self) -> builtins.bool:
    method serve (line 58) | def serve(self, predictor_ref: typing.Optional[builtins.str] = None, h...
    method _run_worker (line 62) | def _run_worker(self) -> None:
    method __repr__ (line 69) | def __repr__(self) -> builtins.str: ...

FILE: crates/coglet-python/coglet/_sdk/__init__.pyi
  class MetricRecorder (line 14) | class MetricRecorder:
    method record (line 24) | def record(
    method delete (line 41) | def delete(self, key: builtins.str) -> None:
    method __setitem__ (line 45) | def __setitem__(self, key: builtins.str, value: typing.Any) -> None:
    method __delitem__ (line 49) | def __delitem__(self, key: builtins.str) -> None:
    method __repr__ (line 53) | def __repr__(self) -> builtins.str: ...
  class Scope (line 56) | class Scope:
    method metrics (line 64) | def metrics(self) -> MetricRecorder:
    method context (line 69) | def context(self) -> dict[builtins.str, builtins.str]:
    method record_metric (line 75) | def record_metric(
    method __repr__ (line 86) | def __repr__(self) -> builtins.str: ...
  class _SlotLogWriter (line 89) | class _SlotLogWriter:
    method closed (line 105) | def closed(self) -> builtins.bool:
    method encoding (line 110) | def encoding(self) -> typing.Optional[builtins.str]:
    method newlines (line 115) | def newlines(self) -> typing.Optional[builtins.str]:
    method buffer (line 120) | def buffer(self) -> typing.Any:
    method write (line 124) | def write(self, data: builtins.str) -> builtins.int:
    method emit_data (line 137) | def emit_data(self, data: builtins.str) -> None:
    method flush (line 141) | def flush(self) -> None:
    method readable (line 147) | def readable(self) -> builtins.bool:
    method writable (line 151) | def writable(self) -> builtins.bool:
    method seekable (line 155) | def seekable(self) -> builtins.bool:
    method isatty (line 159) | def isatty(self) -> builtins.bool:
    method fileno (line 163) | def fileno(self) -> builtins.int:
    method close (line 167) | def close(self) -> None:
    method __enter__ (line 171) | def __enter__(self) -> _SlotLogWriter:
    method __exit__ (line 175) | def __exit__(
  class _TeeWriter (line 186) | class _TeeWriter:
    method inner (line 194) | def inner(self) -> typing.Any:
    method user_stream (line 199) | def user_stream(self) -> typing.Any:
    method name (line 204) | def name(self) -> builtins.str:
    method closed (line 209) | def closed(self) -> builtins.bool:
    method encoding (line 214) | def encoding(self) -> typing.Optional[builtins.str]: ...
    method newlines (line 216) | def newlines(self) -> typing.Optional[builtins.str]: ...
    method __new__ (line 217) | def __new__(
    method write (line 220) | def write(self, data: builtins.str) -> builtins.int:
    method flush (line 224) | def flush(self) -> None:
    method readable (line 228) | def readable(self) -> builtins.bool: ...
    method writable (line 229) | def writable(self) -> builtins.bool: ...
    method seekable (line 230) | def seekable(self) -> builtins.bool: ...
    method isatty (line 231) | def isatty(self) -> builtins.bool: ...
    method fileno (line 232) | def fileno(self) -> builtins.int: ...
    method close (line 233) | def close(self) -> None: ...
    method __enter__ (line 234) | def __enter__(self) -> _TeeWriter: ...
    method __exit__ (line 235) | def __exit__(
  function current_scope (line 242) | def current_scope() -> Scope:

FILE: crates/coglet-python/src/audit.rs
  function install_audit_hook (line 41) | pub fn install_audit_hook(py: Python<'_>) -> PyResult<()> {
  function _coglet_audit_hook (line 70) | fn _coglet_audit_hook(py: Python<'_>, event: &str, args: &Bound<'_, PyAn...
  function handle_stream_replacement (line 108) | fn handle_stream_replacement(py: Python<'_>, name: &str, value: &Bound<'...
  function is_slot_log_writer (line 162) | pub(crate) fn is_slot_log_writer(py: Python<'_>, value: &Bound<'_, PyAny...
  function is_tee_writer (line 178) | pub(crate) fn is_tee_writer(value: &Bound<'_, PyAny>) -> bool {
  function get_inner_writer (line 191) | pub(crate) fn get_inner_writer(py: Python<'_>, tee: &Bound<'_, PyAny>) -...
  type _TeeWriter (line 215) | pub struct _TeeWriter {
    method new (line 234) | fn new(inner: Py<PyAny>, user_stream: Py<PyAny>, name: String) -> Self {
    method write (line 244) | fn write(&self, py: Python<'_>, data: &str) -> PyResult<usize> {
    method flush (line 261) | fn flush(&self, py: Python<'_>) -> PyResult<()> {
    method readable (line 267) | fn readable(&self) -> bool {
    method writable (line 271) | fn writable(&self) -> bool {
    method seekable (line 275) | fn seekable(&self) -> bool {
    method isatty (line 279) | fn isatty(&self, py: Python<'_>) -> PyResult<bool> {
    method fileno (line 284) | fn fileno(&self, py: Python<'_>) -> PyResult<i32> {
    method close (line 289) | fn close(&mut self) {
    method __enter__ (line 293) | fn __enter__(slf: PyRef<'_, Self>) -> PyRef<'_, Self> {
    method __exit__ (line 297) | fn __exit__(
    method encoding (line 307) | fn encoding(&self, py: Python<'_>) -> PyResult<Option<String>> {
    method newlines (line 315) | fn newlines(&self) -> Option<String> {

FILE: crates/coglet-python/src/bin/stub_gen.rs
  constant PUBLIC_REEXPORTS (line 17) | const PUBLIC_REEXPORTS: &[&str] = &["__build__", "__version__", "server"...
  constant PRIVATE_REEXPORTS (line 24) | const PRIVATE_REEXPORTS: &[&str] = &["_sdk"];
  function main (line 26) | fn main() -> Result<()> {

FILE: crates/coglet-python/src/cancel.rs
  function cancel_sync_thread (line 41) | pub fn cancel_sync_thread(py_thread_id: std::ffi::c_long) {
  function current_py_thread_id (line 82) | pub fn current_py_thread_id() -> std::ffi::c_long {

FILE: crates/coglet-python/src/input.rs
  type PyObject (line 13) | type PyObject = Py<PyAny>;
  type PreparedInput (line 20) | pub struct PreparedInput {
    method new (line 29) | pub fn new(dict: Py<PyDict>, cleanup_paths: Vec<PyObject>) -> Self {
    method dict (line 37) | pub fn dict<'py>(&self, py: Python<'py>) -> Bound<'py, PyDict> {
  method drop (line 43) | fn drop(&mut self) {
  function prepare_input (line 76) | pub fn prepare_input(
  function detect_file_fields (line 91) | fn detect_file_fields(py: Python<'_>, func: &Bound<'_, PyAny>) -> PyResu...
  function coerce_url_strings (line 186) | fn coerce_url_strings(
  function download_url_paths_into_dict (line 244) | fn download_url_paths_into_dict(
  function file_fields_for (line 377) | fn file_fields_for(py_func_src: &str) -> HashSet<String> {
  function detect_direct_file (line 399) | fn detect_direct_file() {
  function detect_list_file (line 407) | fn detect_list_file() {
  function detect_optional_file (line 414) | fn detect_optional_file() {
  function detect_file_union_none (line 426) | fn detect_file_union_none() {
  function detect_optional_list_file (line 438) | fn detect_optional_list_file() {
  function non_file_types_not_detected (line 450) | fn non_file_types_not_detected() {

FILE: crates/coglet-python/src/lib.rs
  type BuildInfo (line 40) | pub struct BuildInfo {
    method __repr__ (line 56) | fn __repr__(&self) -> String {
    method new (line 69) | fn new() -> Self {
    method sha_display (line 80) | fn sha_display(&self) -> String {
  function set_active (line 89) | fn set_active() {
  function init_tracing (line 95) | fn init_tracing(
  function detect_version (line 152) | fn detect_version(py: Python<'_>, build: &BuildInfo) -> VersionInfo {
  function read_max_concurrency (line 175) | fn read_max_concurrency() -> usize {
  function read_setup_timeout (line 182) | fn read_setup_timeout() -> Option<std::time::Duration> {
  type CogletServer (line 215) | pub struct CogletServer {}
    method active (line 222) | fn active(&self) -> bool {
    method serve (line 229) | fn serve(
    method run_worker (line 257) | fn run_worker(&self, py: Python<'_>) -> PyResult<()> {
    method __repr__ (line 282) | fn __repr__(&self) -> &'static str {
  function serve_impl (line 288) | fn serve_impl(
  function serve_subprocess (line 366) | fn serve_subprocess(
  function run_worker_with_init (line 479) | async fn run_worker_with_init() -> Result<(), String> {
  function coglet (line 542) | fn coglet(py: Python<'_>, m: &Bound<'_, PyModule>) -> PyResult<()> {

FILE: crates/coglet-python/src/log_writer.rs
  function get_sync_prediction_id_slot (line 47) | fn get_sync_prediction_id_slot() -> &'static Mutex<Option<String>> {
  function get_registry (line 56) | fn get_registry() -> &'static Mutex<HashMap<String, Arc<SlotSender>>> {
  function get_control_channel_sender_slot (line 60) | fn get_control_channel_sender_slot() -> &'static Mutex<Option<Arc<Contro...
  type ControlChannelLogSender (line 70) | pub struct ControlChannelLogSender {
    method new (line 76) | pub fn new(tx: Sender<ControlResponse>) -> Self {
    method try_send_log (line 84) | pub fn try_send_log(&self, source: LogSource, data: &str) {
  function register_control_channel_sender (line 111) | pub fn register_control_channel_sender(sender: Arc<ControlChannelLogSend...
  function unregister_control_channel_sender (line 121) | pub fn unregister_control_channel_sender() {
  function get_control_channel_sender (line 129) | fn get_control_channel_sender() -> Option<Arc<ControlChannelLogSender>> {
  function get_prediction_contextvar (line 140) | pub fn get_prediction_contextvar(py: Python<'_>) -> PyResult<&'static Py...
  function register_prediction (line 166) | pub fn register_prediction(prediction_id: String, sender: Arc<SlotSender...
  function unregister_prediction (line 176) | pub fn unregister_prediction(prediction_id: &str) {
  function get_prediction_sender (line 192) | fn get_prediction_sender(prediction_id: &str) -> Option<Arc<SlotSender>> {
  function set_current_prediction (line 201) | pub fn set_current_prediction(py: Python<'_>, prediction_id: &str) -> Py...
  function set_sync_prediction_id (line 210) | pub fn set_sync_prediction_id(prediction_id: Option<&str>) {
  function get_current_prediction_id (line 219) | fn get_current_prediction_id(py: Python<'_>) -> PyResult<Option<String>> {
  type SlotLogWriter (line 267) | pub struct SlotLogWriter {
    method write (line 292) | fn write(&self, py: Python<'_>, data: &str) -> PyResult<usize> {
    method emit_data (line 326) | fn emit_data(&self, py: Python<'_>, data: &str) -> PyResult<()> {
    method flush (line 369) | fn flush(&self, py: Python<'_>) -> PyResult<()> {
    method readable (line 385) | fn readable(&self) -> bool {
    method writable (line 390) | fn writable(&self) -> bool {
    method seekable (line 395) | fn seekable(&self) -> bool {
    method isatty (line 400) | fn isatty(&self, py: Python<'_>) -> PyResult<bool> {
    method fileno (line 407) | fn fileno(&self, py: Python<'_>) -> PyResult<i32> {
    method close (line 414) | fn close(&mut self) {
    method __enter__ (line 419) | fn __enter__(slf: PyRef<'_, Self>) -> PyRef<'_, Self> {
    method __exit__ (line 424) | fn __exit__(
    method encoding (line 435) | fn encoding(&self, py: Python<'_>) -> PyResult<Option<String>> {
    method newlines (line 444) | fn newlines(&self) -> Option<String> {
    method buffer (line 450) | fn buffer(&self, py: Python<'_>) -> PyResult<Py<PyAny>> {
    method new_stdout (line 461) | pub fn new_stdout(original: Py<PyAny>) -> Self {
    method new_stderr (line 471) | pub fn new_stderr(original: Py<PyAny>) -> Self {
    method write_outside_prediction (line 484) | fn write_outside_prediction(&self, _py: Python<'_>, data: &str) -> PyR...
  function install_slot_log_writers (line 511) | pub fn install_slot_log_writers(py: Python<'_>) -> PyResult<bool> {
  type PredictionLogGuard (line 541) | pub struct PredictionLogGuard {
    method enter (line 551) | pub fn enter(py: Python<'_>, prediction_id: String, sender: Arc<SlotSe...
    method prediction_id (line 567) | pub fn prediction_id(&self) -> &str {
  method drop (line 573) | fn drop(&mut self) {
  function registry_operations (line 595) | fn registry_operations() {
  function slot_sender_sends_log (line 610) | fn slot_sender_sends_log() {
  function slot_sender_ignores_empty (line 627) | fn slot_sender_ignores_empty() {
  function slot_sender_detects_closed_channel (line 638) | fn slot_sender_detects_closed_channel() {

FILE: crates/coglet-python/src/metric_scope.rs
  type MetricValueType (line 29) | enum MetricValueType {
    method from_py (line 40) | fn from_py(obj: &Bound<'_, PyAny>) -> PyResult<Self> {
    method as_str (line 63) | fn as_str(&self) -> &'static str {
  type MetricRecorder (line 88) | pub struct MetricRecorder {
    method new (line 100) | pub fn new(sender: Arc<SlotSender>) -> Self {
    method noop (line 109) | pub fn noop() -> Self {
    method record (line 129) | fn record(
    method delete (line 147) | fn delete(&self, key: &str) -> PyResult<()> {
    method __setitem__ (line 157) | fn __setitem__(&self, py: Python<'_>, key: &str, value: &Bound<'_, PyA...
    method __delitem__ (line 171) | fn __delitem__(&self, key: &str) -> PyResult<()> {
    method __repr__ (line 175) | fn __repr__(&self) -> String {
  type RecorderInner (line 92) | struct RecorderInner {
  type Scope (line 195) | pub struct Scope {
    method new (line 202) | pub fn new(
    method noop (line 218) | pub fn noop(py: Python<'_>) -> PyResult<Self> {
    method metrics (line 233) | fn metrics(&self, py: Python<'_>) -> Py<MetricRecorder> {
    method context (line 241) | fn context(&self, py: Python<'_>) -> Py<PyDict> {
    method record_metric (line 249) | fn record_metric(
    method __repr__ (line 261) | fn __repr__(&self, py: Python<'_>) -> String {
  function parse_mode (line 271) | fn parse_mode(mode: Option<&str>) -> PyResult<MetricMode> {
  function record_impl (line 283) | fn record_impl(
  function delete_impl (line 324) | fn delete_impl(inner: &mut RecorderInner, key: &str) -> PyResult<()> {
  function get_sync_scope_slot (line 348) | fn get_sync_scope_slot() -> &'static Mutex<Option<Py<Scope>>> {
  function get_scope_contextvar (line 352) | fn get_scope_contextvar(py: Python<'_>) -> PyResult<&'static Py<PyAny>> {
  function set_current_scope (line 371) | pub fn set_current_scope(py: Python<'_>, scope: &Py<Scope>) -> PyResult<...
  function set_sync_scope (line 378) | pub fn set_sync_scope(py: Python<'_>, scope: Option<&Py<Scope>>) {
  function clear_sync_scope (line 386) | pub fn clear_sync_scope() {
  function py_current_scope (line 399) | pub fn py_current_scope(py: Python<'_>) -> PyResult<Py<Scope>> {
  type ScopeGuard (line 437) | pub struct ScopeGuard {
    method enter (line 445) | pub fn enter(
  method drop (line 460) | fn drop(&mut self) {
  function py_to_json (line 484) | fn py_to_json(obj: &Bound<'_, PyAny>) -> PyResult<serde_json::Value> {

FILE: crates/coglet-python/src/output.rs
  function process_output (line 22) | pub fn process_output<'py>(
  function process_output_item (line 31) | pub fn process_output_item<'py>(
  function make_encodeable (line 43) | fn make_encodeable<'py>(py: Python<'py>, obj: &Bound<'py, PyAny>) -> PyR...
  function encode_files (line 145) | fn encode_files<'py>(py: Python<'py>, obj: &Bound<'py, PyAny>) -> PyResu...
  function file_to_base64 (line 196) | fn file_to_base64<'py>(py: Python<'py>, fh: &Bound<'py, PyAny>) -> PyRes...
  function is_generator (line 239) | fn is_generator<'py>(py: Python<'py>, obj: &Bound<'py, PyAny>) -> PyResu...
  function encodeable (line 252) | fn encodeable(py_expr: &str) -> String {
  function processed (line 274) | fn processed(py_expr: &str) -> String {
  function encodeable_string (line 296) | fn encodeable_string() {
  function encodeable_int (line 301) | fn encodeable_int() {
  function encodeable_float (line 306) | fn encodeable_float() {
  function encodeable_bool (line 311) | fn encodeable_bool() {
  function encodeable_none (line 316) | fn encodeable_none() {
  function encodeable_list (line 323) | fn encodeable_list() {
  function encodeable_dict (line 328) | fn encodeable_dict() {
  function encodeable_tuple_to_list (line 336) | fn encodeable_tuple_to_list() {
  function encodeable_set_to_list (line 341) | fn encodeable_set_to_list() {
  function encodeable_frozenset_to_list (line 347) | fn encodeable_frozenset_to_list() {
  function encodeable_nested_dict (line 352) | fn encodeable_nested_dict() {
  function encodeable_enum (line 362) | fn encodeable_enum() {
  function encodeable_int_enum (line 370) | fn encodeable_int_enum() {
  function encodeable_datetime (line 382) | fn encodeable_datetime() {
  function encodeable_dataclass (line 391) | fn encodeable_dataclass() {
  function encodeable_nested_dataclass (line 406) | fn encodeable_nested_dataclass() {
  function encodeable_generator (line 423) | fn encodeable_generator() {
  function encodeable_enum_in_list (line 430) | fn encodeable_enum_in_list() {
  function encode_pathlike_to_base64 (line 446) | fn encode_pathlike_to_base64() {
  function encode_iobase_to_base64 (line 467) | fn encode_iobase_to_base64() {
  function encode_iobase_seeks_to_start (line 484) | fn encode_iobase_seeks_to_start() {
  function encode_file_in_dict (line 499) | fn encode_file_in_dict() {
  function encode_file_in_list (line 514) | fn encode_file_in_list() {
  function encode_string_passthrough (line 527) | fn encode_string_passthrough() {
  function encode_mime_type_guessing (line 533) | fn encode_mime_type_guessing() {
  function process_output_primitives_passthrough (line 550) | fn process_output_primitives_passthrough() {
  function process_output_dataclass_with_file (line 557) | fn process_output_dataclass_with_file() {

FILE: crates/coglet-python/src/predictor.rs
  function get_collect_async_gen (line 30) | fn get_collect_async_gen(py: Python<'_>) -> Result<Py<PyAny>, Prediction...
  function get_ctx_wrapper (line 56) | fn get_ctx_wrapper(py: Python<'_>) -> Result<Py<PyAny>, PredictionError> {
  function is_cancelation_exception (line 79) | fn is_cancelation_exception(py: Python<'_>, err: &PyErr) -> bool {
  function format_validation_error (line 99) | fn format_validation_error(py: Python<'_>, err: &PyErr) -> String {
  function send_output_item (line 108) | fn send_output_item(
  type PyObject (line 194) | type PyObject = Py<PyAny>;
  type PredictKind (line 198) | pub enum PredictKind {
  type TrainKind (line 209) | pub enum TrainKind {
  type PredictorKind (line 220) | pub enum PredictorKind {
  type PythonPredictor (line 235) | pub struct PythonPredictor {
    method load (line 248) | pub fn load(py: Python<'_>, predictor_ref: &str) -> PyResult<Self> {
    method unwrap_field_info_defaults (line 337) | fn unwrap_field_info_defaults(
    method detect_async (line 406) | fn detect_async(
    method is_async (line 436) | pub fn is_async(&self) -> bool {
    method has_train (line 448) | pub fn has_train(&self) -> bool {
    method is_train_async (line 456) | pub fn is_train_async(&self) -> bool {
    method setup (line 470) | pub fn setup(&self, py: Python<'_>) -> PyResult<()> {
    method predict_func (line 498) | pub fn predict_func<'py>(&self, py: Python<'py>) -> PyResult<Bound<'py...
    method train_func (line 507) | pub fn train_func<'py>(&self, py: Python<'py>) -> PyResult<Bound<'py, ...
    method predict_raw (line 518) | pub fn predict_raw(&self, py: Python<'_>, input: &Bound<'_, PyDict>) -...
    method train_raw (line 536) | pub fn train_raw(&self, py: Python<'_>, input: &Bound<'_, PyDict>) -> ...
    method call_method_raw (line 548) | fn call_method_raw(
    method predict_worker (line 577) | pub fn predict_worker(
    method train_worker (line 650) | pub fn train_worker(
    method process_generator_output (line 722) | fn process_generator_output(
    method process_single_output (line 752) | fn process_single_output(
    method predict_async_worker (line 858) | pub fn predict_async_worker(
    method process_async_result (line 949) | pub fn process_async_result(
    method train_async_worker (line 995) | pub fn train_async_worker(
    constant HEALTHCHECK_TIMEOUT (line 1070) | const HEALTHCHECK_TIMEOUT: f64 = 5.0;
    method has_healthcheck (line 1073) | pub fn has_healthcheck(&self, py: Python<'_>) -> bool {
    method is_healthcheck_async (line 1084) | pub fn is_healthcheck_async(&self, py: Python<'_>) -> bool {
    method healthcheck_sync (line 1110) | pub fn healthcheck_sync(&self, py: Python<'_>) -> coglet_core::orchest...
    method healthcheck_async (line 1172) | pub fn healthcheck_async(

FILE: crates/coglet-python/src/worker_bridge.rs
  type HandlerMode (line 16) | pub enum HandlerMode {
  type SdkImplementation (line 28) | pub enum SdkImplementation {
    method fmt (line 36) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  type SlotState (line 46) | pub enum SlotState {
    method is_cancelled (line 65) | pub fn is_cancelled(&self) -> bool {
    method mark_cancelled (line 73) | pub fn mark_cancelled(&mut self) {
  type PythonPredictHandler (line 92) | pub struct PythonPredictHandler {
    method new (line 108) | pub fn new(predictor_ref: String) -> Result<Self, SetupError> {
    method new_train (line 125) | pub fn new_train(predictor_ref: String) -> Result<Self, SetupError> {
    method init_async_loop (line 138) | fn init_async_loop() -> Result<(Py<PyAny>, JoinHandle<()>), SetupError> {
    method is_cancelled (line 183) | fn is_cancelled(&self, slot: SlotId) -> bool {
    method take_cancelled (line 189) | fn take_cancelled(&self, slot: SlotId) -> bool {
    method start_sync_prediction (line 204) | fn start_sync_prediction(&self, slot: SlotId, py_thread_id: std::ffi::...
    method start_async_prediction (line 216) | fn start_async_prediction(&self, slot: SlotId, future: Py<PyAny>) {
    method finish_prediction (line 228) | fn finish_prediction(&self, slot: SlotId) {
    method cancel_async_future (line 235) | fn cancel_async_future(&self, slot: SlotId) -> bool {
    method get_async_loop (line 265) | fn get_async_loop(&self) -> Option<Py<PyAny>> {
  method setup (line 278) | async fn setup(&self) -> Result<(), SetupError> {
  method predict (line 307) | async fn predict(
  method cancel (line 575) | fn cancel(&self, slot: SlotId) {
  method healthcheck (line 607) | async fn healthcheck(&self) -> coglet_core::orchestrator::HealthcheckRes...
  method drop (line 652) | fn drop(&mut self) {
  function output_to_json (line 692) | fn output_to_json(output: coglet_core::PredictionOutput) -> serde_json::...

FILE: crates/coglet-python/tests/test_coglet.py
  class TestModuleStructure (line 21) | class TestModuleStructure:
    method test_version_is_pep440 (line 24) | def test_version_is_pep440(self) -> None:
    method test_version_is_str (line 32) | def test_version_is_str(self) -> None:
    method test_build_info_exists (line 35) | def test_build_info_exists(self) -> None:
    method test_build_info_fields_are_strings (line 42) | def test_build_info_fields_are_strings(self) -> None:
    method test_build_info_version_matches_module_version (line 49) | def test_build_info_version_matches_module_version(self) -> None:
    method test_build_info_repr (line 52) | def test_build_info_repr(self) -> None:
    method test_build_info_frozen (line 58) | def test_build_info_frozen(self) -> None:
    method test_server_exists (line 62) | def test_server_exists(self) -> None:
    method test_server_active_is_false (line 65) | def test_server_active_is_false(self) -> None:
    method test_server_active_is_property (line 69) | def test_server_active_is_property(self) -> None:
    method test_server_frozen (line 73) | def test_server_frozen(self) -> None:
    method test_server_active_not_settable (line 77) | def test_server_active_not_settable(self) -> None:
    method test_server_repr (line 81) | def test_server_repr(self) -> None:
    method test_sdk_submodule_exists (line 84) | def test_sdk_submodule_exists(self) -> None:
    method test_sdk_has_slot_log_writer (line 87) | def test_sdk_has_slot_log_writer(self) -> None:
    method test_sdk_has_tee_writer (line 90) | def test_sdk_has_tee_writer(self) -> None:
    method test_all_excludes_internals (line 93) | def test_all_excludes_internals(self) -> None:
  function sync_predictor (line 104) | def sync_predictor(tmp_path: Path) -> Path:
  function generator_predictor (line 128) | def generator_predictor(tmp_path: Path) -> Path:
  function async_predictor (line 154) | def async_predictor(tmp_path: Path) -> Path:
  function async_generator_predictor (line 181) | def async_generator_predictor(tmp_path: Path) -> Path:
  class CogletServer (line 208) | class CogletServer:
    method __init__ (line 211) | def __init__(self, predictor_path: Path, port: int = 0):
    method __enter__ (line 220) | def __enter__(self):
    method __exit__ (line 247) | def __exit__(self, exc_type, exc_val, exc_tb):
    method _read_stderr (line 252) | def _read_stderr(self):
    method _discover_port (line 261) | def _discover_port(self, timeout: float = 5.0):
    method _wait_for_ready (line 285) | def _wait_for_ready(self, timeout: float = 10.0):
    method base_url (line 309) | def base_url(self) -> str:
    method health_check (line 312) | def health_check(self) -> dict:
    method predict (line 317) | def predict(self, input_data: dict) -> dict:
  class TestHealthCheck (line 325) | class TestHealthCheck:
    method test_returns_ready_status (line 328) | def test_returns_ready_status(self, sync_predictor: Path):
    method test_returns_version_info (line 333) | def test_returns_version_info(self, sync_predictor: Path):
  class TestSyncPredictor (line 342) | class TestSyncPredictor:
    method test_basic_prediction (line 345) | def test_basic_prediction(self, sync_predictor: Path):
    method test_default_input (line 351) | def test_default_input(self, sync_predictor: Path):
    method test_includes_predict_time (line 357) | def test_includes_predict_time(self, sync_predictor: Path):
  class TestGeneratorPredictor (line 365) | class TestGeneratorPredictor:
    method test_returns_array_output (line 368) | def test_returns_array_output(self, generator_predictor: Path):
    method test_custom_count (line 374) | def test_custom_count(self, generator_predictor: Path):
  class TestAsyncPredictor (line 380) | class TestAsyncPredictor:
    method test_basic_prediction (line 383) | def test_basic_prediction(self, async_predictor: Path):
    method test_sequential_requests (line 389) | def test_sequential_requests(self, async_predictor: Path):
  class TestAsyncGeneratorPredictor (line 402) | class TestAsyncGeneratorPredictor:
    method test_returns_array_output (line 405) | def test_returns_array_output(self, async_generator_predictor: Path):
  function slow_sync_predictor (line 417) | def slow_sync_predictor(tmp_path: Path) -> Path:
  function blocking_sleep_predictor (line 445) | def blocking_sleep_predictor(tmp_path: Path) -> Path:
  function slow_async_predictor (line 471) | def slow_async_predictor(tmp_path: Path) -> Path:
  function _wait_for_health_status (line 495) | def _wait_for_health_status(
  class TestCancellation (line 515) | class TestCancellation:
    method test_cancel_endpoint_returns_404_for_unknown_id (line 518) | def test_cancel_endpoint_returns_404_for_unknown_id(self, sync_predict...
    method test_prediction_response_includes_id (line 526) | def test_prediction_response_includes_id(self, sync_predictor: Path):
    method test_cancel_running_sync_prediction (line 533) | def test_cancel_running_sync_prediction(self, slow_sync_predictor: Path):
    method test_cancel_running_async_prediction (line 557) | def test_cancel_running_async_prediction(self, slow_async_predictor: P...
    method test_repeated_cancel_is_idempotent (line 591) | def test_repeated_cancel_is_idempotent(
    method test_cancel_sync_prediction_connection_drop (line 631) | def test_cancel_sync_prediction_connection_drop(self, slow_sync_predic...

FILE: crates/coglet/src/bridge/codec.rs
  type JsonCodec (line 16) | pub struct JsonCodec<T> {
  method default (line 22) | fn default() -> Self {
  function new (line 28) | pub fn new() -> Self {
  type Item (line 39) | type Item = T;
  type Error (line 40) | type Error = io::Error;
  method decode (line 42) | fn decode(&mut self, src: &mut BytesMut) -> Result<Option<Self::Item>, S...
  type Error (line 55) | type Error = io::Error;
  function encode (line 57) | fn encode(&mut self, item: T, dst: &mut BytesMut) -> Result<(), Self::Er...
  function codec_roundtrip_control_request (line 88) | fn codec_roundtrip_control_request() {
  function codec_roundtrip_control_response (line 101) | fn codec_roundtrip_control_response() {
  function codec_roundtrip_slot_request (line 117) | fn codec_roundtrip_slot_request() {
  function codec_roundtrip_slot_response (line 158) | fn codec_roundtrip_slot_response() {

FILE: crates/coglet/src/bridge/protocol.rs
  type SlotId (line 18) | pub struct SlotId(uuid::Uuid);
    method new (line 21) | pub fn new() -> Self {
    method as_uuid (line 25) | pub fn as_uuid(&self) -> &uuid::Uuid {
    method parse (line 29) | pub fn parse(s: &str) -> Result<Self, uuid::Error> {
    method fmt (line 42) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  method default (line 36) | fn default() -> Self {
  constant MAX_INLINE_IPC_SIZE (line 51) | pub const MAX_INLINE_IPC_SIZE: usize = 1024 * 1024 * 6;
  constant MAX_WORKER_LOG_SIZE (line 53) | const MAX_WORKER_LOG_SIZE: usize = 1024 * 1024 * 4;
  constant WORKER_LOG_TRUNCATE_NOTICE (line 54) | const WORKER_LOG_TRUNCATE_NOTICE: &str = "[**** LOG LINE TRUNCATED AT 4 ...
  function truncate_worker_log (line 58) | pub fn truncate_worker_log(mut log_message: String) -> String {
  type ControlRequest (line 71) | pub enum ControlRequest {
  type ControlResponse (line 96) | pub enum ControlResponse {
  type HealthcheckStatus (line 160) | pub enum HealthcheckStatus {
  type SlotOutcome (line 169) | pub enum SlotOutcome {
    method idle (line 175) | pub fn idle(slot: SlotId) -> Self {
    method poisoned (line 179) | pub fn poisoned(slot: SlotId, error: impl Into<String>) -> Self {
    method slot_id (line 186) | pub fn slot_id(&self) -> SlotId {
    method is_poisoned (line 193) | pub fn is_poisoned(&self) -> bool {
    method into_control_response (line 197) | pub fn into_control_response(self) -> ControlResponse {
  type SlotRequest (line 208) | pub enum SlotRequest {
    method prediction_id (line 230) | pub fn prediction_id(&self) -> &str {
    method rehydrate_input (line 240) | pub fn rehydrate_input(
  type FileOutputKind (line 278) | pub enum FileOutputKind {
  type MetricMode (line 288) | pub enum MetricMode {
  type SlotResponse (line 300) | pub enum SlotResponse {
  type LogSource (line 359) | pub enum LogSource {
  function test_slot_id (line 370) | fn test_slot_id() -> SlotId {
  function control_init_serializes (line 375) | fn control_init_serializes() {
  function control_cancel_serializes (line 390) | fn control_cancel_serializes() {
  function control_shutdown_serializes (line 398) | fn control_shutdown_serializes() {
  function control_healthcheck_serializes (line 404) | fn control_healthcheck_serializes() {
  function control_healthcheck_result_healthy_serializes (line 412) | fn control_healthcheck_result_healthy_serializes() {
  function control_healthcheck_result_unhealthy_serializes (line 422) | fn control_healthcheck_result_unhealthy_serializes() {
  function control_ready_serializes (line 432) | fn control_ready_serializes() {
  function control_ready_with_schema_serializes (line 441) | fn control_ready_with_schema_serializes() {
  function control_idle_serializes (line 453) | fn control_idle_serializes() {
  function control_cancelled_serializes (line 461) | fn control_cancelled_serializes() {
  function control_failed_serializes (line 469) | fn control_failed_serializes() {
  function slot_predict_serializes (line 478) | fn slot_predict_serializes() {
  function slot_predict_file_input_serializes (line 490) | fn slot_predict_file_input_serializes() {
  function slot_log_serializes (line 502) | fn slot_log_serializes() {
  function slot_output_serializes (line 511) | fn slot_output_serializes() {
  function slot_done_serializes (line 519) | fn slot_done_serializes() {
  function slot_failed_serializes (line 530) | fn slot_failed_serializes() {
  function slot_cancelled_serializes (line 539) | fn slot_cancelled_serializes() {
  function slot_metric_replace_serializes (line 547) | fn slot_metric_replace_serializes() {
  function slot_metric_increment_serializes (line 557) | fn slot_metric_increment_serializes() {
  function slot_metric_append_serializes (line 567) | fn slot_metric_append_serializes() {
  function slot_metric_delete_serializes (line 577) | fn slot_metric_delete_serializes() {
  function slot_metric_complex_value_serializes (line 587) | fn slot_metric_complex_value_serializes() {
  function rehydrate_input_inline (line 597) | fn rehydrate_input_inline() {
  function rehydrate_input_from_file (line 612) | fn rehydrate_input_from_file() {
  function rehydrate_input_neither_errors (line 633) | fn rehydrate_input_neither_errors() {
  function rehydrate_input_corrupt_file_errors (line 646) | fn rehydrate_input_corrupt_file_errors() {
  function truncate_worker_log_truncates_long_messages (line 663) | fn truncate_worker_log_truncates_long_messages() {
  function truncate_worker_log_does_not_truncate_short_messages (line 676) | fn truncate_worker_log_does_not_truncate_short_messages() {

FILE: crates/coglet/src/bridge/transport.rs
  type ChildTransportInfo (line 15) | pub enum ChildTransportInfo {
  type NamedSocketTransport (line 30) | pub struct NamedSocketTransport {
    method create (line 39) | pub async fn create(num_slots: usize) -> io::Result<(Self, ChildTransp...
    method accept_connections (line 80) | pub async fn accept_connections(&mut self, num_slots: usize) -> io::Re...
    method connect (line 94) | pub async fn connect(dir: PathBuf, num_slots: usize) -> io::Result<Sel...
    method slot_socket (line 115) | pub fn slot_socket(&mut self, slot: usize) -> Option<&mut UnixStream> {
    method drain_sockets (line 120) | pub fn drain_sockets(&mut self) -> Vec<UnixStream> {
    method dir (line 124) | pub fn dir(&self) -> &PathBuf {
    method num_slots (line 128) | pub fn num_slots(&self) -> usize {
    method cleanup (line 132) | pub fn cleanup(&mut self) -> io::Result<()> {
  method drop (line 142) | fn drop(&mut self) {
  type AbstractSocketTransport (line 153) | pub struct AbstractSocketTransport {
    method create (line 163) | pub async fn create(num_slots: usize) -> io::Result<(Self, ChildTransp...
    method accept_connections (line 197) | pub async fn accept_connections(&mut self, num_slots: usize) -> io::Re...
    method connect (line 211) | pub async fn connect(prefix: String, num_slots: usize) -> io::Result<S...
    method slot_socket (line 239) | pub fn slot_socket(&mut self, slot: usize) -> Option<&mut UnixStream> {
    method drain_sockets (line 243) | pub fn drain_sockets(&mut self) -> Vec<UnixStream> {
    method num_slots (line 247) | pub fn num_slots(&self) -> usize {
  type SlotTransport (line 252) | pub enum SlotTransport {
    method slot_socket (line 259) | pub fn slot_socket(&mut self, slot: usize) -> Option<&mut UnixStream> {
    method drain_sockets (line 267) | pub fn drain_sockets(&mut self) -> Vec<UnixStream> {
    method num_slots (line 275) | pub fn num_slots(&self) -> usize {
    method accept_connections (line 283) | pub async fn accept_connections(&mut self, num_slots: usize) -> io::Re...
  function create_transport (line 293) | pub async fn create_transport(num_slots: usize) -> io::Result<(SlotTrans...
  function connect_transport (line 307) | pub async fn connect_transport(info: ChildTransportInfo) -> io::Result<S...
  function child_transport_info_roundtrips (line 326) | fn child_transport_info_roundtrips() {
  function abstract_socket_info_roundtrips (line 346) | fn abstract_socket_info_roundtrips() {

FILE: crates/coglet/src/fd_redirect.rs
  constant CONTROL_STDIN_FD (line 40) | const CONTROL_STDIN_FD: i32 = 99;
  constant CONTROL_STDOUT_FD (line 42) | const CONTROL_STDOUT_FD: i32 = 100;
  constant WORKER_STDERR_FD (line 44) | const WORKER_STDERR_FD: i32 = 101;
  type ControlChannelFds (line 47) | pub struct ControlChannelFds {
  function redirect_fds_for_subprocess_isolation (line 57) | pub fn redirect_fds_for_subprocess_isolation(
  type ControlChannelFds (line 231) | pub struct ControlChannelFds {
  function redirect_fds_for_subprocess_isolation (line 237) | pub fn redirect_fds_for_subprocess_isolation(

FILE: crates/coglet/src/health.rs
  type Health (line 8) | pub enum Health {
  type HealthResponse (line 28) | pub enum HealthResponse {
    method from (line 40) | fn from(health: Health) -> Self {
  type SetupStatus (line 55) | pub enum SetupStatus {
  type SetupResult (line 63) | pub struct SetupResult {
    method starting (line 79) | pub fn starting() -> Self {
    method succeeded (line 89) | pub fn succeeded(mut self, logs: String) -> Self {
    method failed (line 97) | pub fn failed(mut self, logs: String) -> Self {
  function health_default_is_unknown (line 110) | fn health_default_is_unknown() {
  function health_serializes_screaming_snake_case (line 115) | fn health_serializes_screaming_snake_case() {
  function health_response_serializes_screaming_snake_case (line 130) | fn health_response_serializes_screaming_snake_case() {
  function health_deserializes_screaming_snake_case (line 146) | fn health_deserializes_screaming_snake_case() {
  function setup_status_serializes_lowercase (line 158) | fn setup_status_serializes_lowercase() {
  function setup_status_deserializes_lowercase (line 170) | fn setup_status_deserializes_lowercase() {

FILE: crates/coglet/src/input_validation.rs
  type ValidationError (line 13) | pub struct ValidationError {
  type InputValidator (line 23) | pub struct InputValidator {
    method from_openapi_schema (line 38) | pub fn from_openapi_schema(schema: &Value) -> Option<Self> {
    method from_openapi_schema_key (line 46) | pub fn from_openapi_schema_key(schema: &Value, key: &str) -> Option<Se...
    method required_count (line 90) | pub fn required_count(&self) -> usize {
    method validate (line 98) | pub fn validate(&self, input: &Value) -> Result<(), Vec<ValidationErro...
  function inline_refs (line 183) | fn inline_refs(value: &mut Value, all_schemas: Option<&Value>) {
  function resolve_ref (line 210) | fn resolve_ref(ref_str: &str, all_schemas: Option<&Value>) -> Option<Val...
  function make_schema (line 220) | fn make_schema(input_schema: Value) -> Value {
  function validates_required_fields (line 231) | fn validates_required_fields() {
  function rejects_additional_properties (line 253) | fn rejects_additional_properties() {
  function missing_and_extra_fields (line 274) | fn missing_and_extra_fields() {
  function validates_types (line 297) | fn validates_types() {
  function no_schema_returns_none (line 317) | fn no_schema_returns_none() {
  function resolves_ref_for_choices (line 323) | fn resolves_ref_for_choices() {
  function optional_fields_work (line 356) | fn optional_fields_work() {

FILE: crates/coglet/src/orchestrator.rs
  function upload_file (line 38) | async fn upload_file(
  function ensure_trailing_slash (line 77) | fn ensure_trailing_slash(s: &str) -> String {
  function try_lock_prediction (line 88) | fn try_lock_prediction(
  function wrap_outputs (line 112) | fn wrap_outputs(
  function emit_worker_log (line 133) | fn emit_worker_log(target: &str, level: &str, msg: &str) {
  type HealthcheckResult (line 208) | pub struct HealthcheckResult {
    method healthy (line 214) | pub fn healthy() -> Self {
    method unhealthy (line 221) | pub fn unhealthy(error: impl Into<String>) -> Self {
    method is_healthy (line 228) | pub fn is_healthy(&self) -> bool {
  type Orchestrator (line 239) | pub trait Orchestrator: Send + Sync {
    method register_prediction (line 241) | async fn register_prediction(
    method cancel_by_prediction_id (line 252) | async fn cancel_by_prediction_id(&self, prediction_id: &str) -> Result...
    method healthcheck (line 255) | async fn healthcheck(&self) -> Result<HealthcheckResult, OrchestratorE...
    method shutdown (line 258) | async fn shutdown(&self) -> Result<(), OrchestratorError>;
    method register_prediction (line 372) | async fn register_prediction(
    method cancel_by_prediction_id (line 384) | async fn cancel_by_prediction_id(&self, prediction_id: &str) -> Result...
    method healthcheck (line 391) | async fn healthcheck(&self) -> Result<HealthcheckResult, OrchestratorE...
    method shutdown (line 424) | async fn shutdown(&self) -> Result<(), OrchestratorError> {
  type WorkerSpawnConfig (line 262) | pub struct WorkerSpawnConfig {
  type SpawnError (line 267) | pub enum SpawnError {
  type WorkerSpawner (line 275) | pub trait WorkerSpawner: Send + Sync {
    method spawn (line 276) | fn spawn(&self, config: &WorkerSpawnConfig) -> Result<Child, SpawnError>;
    method spawn (line 283) | fn spawn(&self, _config: &WorkerSpawnConfig) -> Result<Child, SpawnErr...
  type SimpleSpawner (line 280) | pub struct SimpleSpawner;
  type OrchestratorConfig (line 294) | pub struct OrchestratorConfig {
    method new (line 306) | pub fn new(predictor_ref: impl Into<String>) -> Self {
    method with_upload_url (line 318) | pub fn with_upload_url(mut self, upload_url: Option<String>) -> Self {
    method with_num_slots (line 323) | pub fn with_num_slots(mut self, n: usize) -> Self {
    method with_train (line 328) | pub fn with_train(mut self, is_train: bool) -> Self {
    method with_async (line 333) | pub fn with_async(mut self, is_async: bool) -> Self {
    method with_setup_timeout (line 338) | pub fn with_setup_timeout(mut self, timeout: Option<Duration>) -> Self {
    method with_spawner (line 343) | pub fn with_spawner(mut self, spawner: Arc<dyn WorkerSpawner>) -> Self {
  type OrchestratorReady (line 349) | pub struct OrchestratorReady {
  type OrchestratorHandle (line 356) | pub struct OrchestratorHandle {
    method cancel (line 434) | pub async fn cancel(&self, slot_id: SlotId) -> Result<(), Orchestrator...
    method slot_ids (line 442) | pub fn slot_ids(&self) -> &[SlotId] {
    method wait (line 446) | pub async fn wait(&mut self) -> Result<(), OrchestratorError> {
  type OrchestratorError (line 455) | pub enum OrchestratorError {
  function spawn_worker (line 468) | pub async fn spawn_worker(
  function run_event_loop (line 692) | async fn run_event_loop(
  function wrap_outputs_schema_array_empty (line 1241) | fn wrap_outputs_schema_array_empty() {
  function wrap_outputs_schema_array_single_item (line 1249) | fn wrap_outputs_schema_array_single_item() {
  function wrap_outputs_schema_array_multiple_items (line 1260) | fn wrap_outputs_schema_array_multiple_items() {
  function wrap_outputs_schema_array_overrides_is_stream_false (line 1274) | fn wrap_outputs_schema_array_overrides_is_stream_false() {
  function wrap_outputs_predictor_stream_empty (line 1284) | fn wrap_outputs_predictor_stream_empty() {
  function wrap_outputs_predictor_stream_single_item (line 1292) | fn wrap_outputs_predictor_stream_single_item() {
  function wrap_outputs_predictor_stream_multiple_items (line 1300) | fn wrap_outputs_predictor_stream_multiple_items() {
  function wrap_outputs_scalar_empty (line 1311) | fn wrap_outputs_scalar_empty() {
  function wrap_outputs_scalar_single (line 1319) | fn wrap_outputs_scalar_single() {
  function wrap_outputs_scalar_multiple_falls_back_to_stream (line 1330) | fn wrap_outputs_scalar_multiple_falls_back_to_stream() {
  function done_is_stream_false_omitted_from_json (line 1342) | fn done_is_stream_false_omitted_from_json() {
  function done_is_stream_true_present_in_json (line 1357) | fn done_is_stream_true_present_in_json() {
  function done_without_is_stream_deserializes_as_false (line 1369) | fn done_without_is_stream_deserializes_as_false() {

FILE: crates/coglet/src/permit/pool.rs
  type PermitInner (line 18) | pub(crate) struct PermitInner {
  type PoolConnection (line 25) | struct PoolConnection {
  method clone (line 31) | fn clone(&self) -> Self {
  type PermitInUse (line 40) | pub struct PermitInUse {
    method new (line 49) | pub(crate) fn new(
    method slot_id (line 68) | pub fn slot_id(&self) -> SlotId {
    method into_idle (line 74) | pub fn into_idle(mut self) -> PermitIdle {
    method into_poisoned (line 88) | pub fn into_poisoned(mut self) -> PermitPoisoned {
    method send (line 96) | pub async fn send(&mut self, request: SlotRequest) -> Result<(), Permi...
  method drop (line 106) | fn drop(&mut self) {
  type PermitIdle (line 115) | pub struct PermitIdle {
    method slot_id (line 124) | pub fn slot_id(&self) -> SlotId {
  method drop (line 130) | fn drop(&mut self) {
  type PermitPoisoned (line 153) | pub struct PermitPoisoned {
    method slot_id (line 159) | pub fn slot_id(&self) -> SlotId {
  method drop (line 165) | fn drop(&mut self) {
  type AnyPermit (line 171) | pub enum AnyPermit {
    method slot_id (line 178) | pub fn slot_id(&self) -> SlotId {
    method is_idle (line 186) | pub fn is_idle(&self) -> bool {
    method is_poisoned (line 190) | pub fn is_poisoned(&self) -> bool {
    method is_in_use (line 194) | pub fn is_in_use(&self) -> bool {
  type InactiveSlotIdleToken (line 201) | pub struct InactiveSlotIdleToken {
    method new (line 206) | pub fn new(slot_id: SlotId) -> Self {
    method slot_id (line 210) | pub fn slot_id(&self) -> SlotId {
    method activate (line 214) | pub fn activate(self) -> SlotIdleToken {
  type SlotIdleToken (line 231) | pub struct SlotIdleToken {
    constant ALERT_THRESHOLD (line 238) | const ALERT_THRESHOLD: std::time::Duration = std::time::Duration::from...
    method slot_id (line 240) | pub fn slot_id(&self) -> SlotId {
    method consume (line 244) | pub fn consume(self) {
  method drop (line 254) | fn drop(&mut self) {
  type PermitError (line 260) | pub enum PermitError {
  type PermitPool (line 271) | pub struct PermitPool {
    method new (line 281) | pub fn new(num_slots: usize) -> Self {
    method add_permit (line 293) | pub fn add_permit(
    method poison (line 324) | pub fn poison(&self, slot_id: SlotId) {
    method is_poisoned (line 339) | pub fn is_poisoned(&self, slot_id: SlotId) -> bool {
    method try_acquire (line 350) | pub fn try_acquire(&self) -> Option<PermitInUse> {
    method acquire (line 370) | pub async fn acquire(&self) -> Option<PermitInUse> {
    method num_slots (line 390) | pub fn num_slots(&self) -> usize {
    method available (line 394) | pub fn available(&self) -> usize {
  function make_socket_pair (line 404) | async fn make_socket_pair() -> (OwnedWriteHalf, tokio::net::unix::OwnedR...
  function pool_add_and_acquire (line 412) | async fn pool_add_and_acquire() {
  function permit_returns_to_pool_when_idle (line 435) | async fn permit_returns_to_pool_when_idle() {
  function permit_orphaned_when_poisoned (line 453) | async fn permit_orphaned_when_poisoned() {
  function pool_poison_idle_slot (line 471) | async fn pool_poison_idle_slot() {
  function pool_poison_in_use_slot_prevents_return (line 498) | async fn pool_poison_in_use_slot_prevents_return() {
  function pool_poison_is_idempotent (line 520) | async fn pool_poison_is_idempotent() {

FILE: crates/coglet/src/permit/slot.rs
  type SlotError (line 17) | pub enum SlotError {
  type UnregisteredPredictionSlot (line 26) | pub struct UnregisteredPredictionSlot {
    method new (line 32) | pub fn new(
    method into_parts (line 43) | pub fn into_parts(self) -> (tokio::sync::oneshot::Sender<SlotIdleToken...
    method prediction (line 47) | pub fn prediction(&self) -> Arc<Mutex<Prediction>> {
  type PredictionSlot (line 55) | pub struct PredictionSlot {
    method new (line 63) | pub fn new(
    method prediction (line 77) | pub fn prediction(&self) -> Arc<Mutex<Prediction>> {
    method permit_mut (line 81) | pub fn permit_mut(&mut self) -> Option<&mut PermitInUse> {
    method slot_id (line 88) | pub fn slot_id(&self) -> SlotId {
    method into_idle (line 97) | pub async fn into_idle(mut self) -> Result<(), SlotError> {
    method is_idle (line 138) | pub fn is_idle(&self) -> bool {
    method id (line 142) | pub fn id(&self) -> String {
  method drop (line 151) | fn drop(&mut self) {
  function slot_creation (line 175) | async fn slot_creation() {
  function slot_mark_idle_returns_permit (line 193) | async fn slot_mark_idle_returns_permit() {
  function slot_not_idle_orphans_permit (line 217) | async fn slot_not_idle_orphans_permit() {
  function slot_idle_channel_closed_does_not_return_permit (line 237) | async fn slot_idle_channel_closed_does_not_return_permit() {

FILE: crates/coglet/src/prediction.rs
  type PredictionStatus (line 14) | pub enum PredictionStatus {
    method is_terminal (line 23) | pub fn is_terminal(&self) -> bool {
    method as_str (line 27) | pub fn as_str(&self) -> &'static str {
  type PredictionOutput (line 41) | pub enum PredictionOutput {
    method is_stream (line 47) | pub fn is_stream(&self) -> bool {
    method into_values (line 51) | pub fn into_values(self) -> Vec<serde_json::Value> {
    method final_value (line 59) | pub fn final_value(&self) -> &serde_json::Value {
  type Prediction (line 68) | pub struct Prediction {
    method new (line 84) | pub fn new(id: String, webhook: Option<WebhookSender>) -> Self {
    method id (line 100) | pub fn id(&self) -> &str {
    method cancel_token (line 104) | pub fn cancel_token(&self) -> CancellationToken {
    method is_canceled (line 108) | pub fn is_canceled(&self) -> bool {
    method status (line 112) | pub fn status(&self) -> PredictionStatus {
    method is_terminal (line 116) | pub fn is_terminal(&self) -> bool {
    method set_processing (line 120) | pub fn set_processing(&mut self) {
    method set_succeeded (line 125) | pub fn set_succeeded(&mut self, output: PredictionOutput) {
    method set_failed (line 141) | pub fn set_failed(&mut self, error: String) {
    method set_canceled (line 151) | pub fn set_canceled(&mut self) {
    method elapsed (line 160) | pub fn elapsed(&self) -> std::time::Duration {
    method append_log (line 164) | pub fn append_log(&mut self, data: &str) {
    method logs (line 169) | pub fn logs(&self) -> &str {
    method set_metric (line 180) | pub fn set_metric(&mut self, name: String, value: serde_json::Value, m...
    method set_metric_dotpath (line 227) | fn set_metric_dotpath(&mut self, parts: &[&str], value: serde_json::Va...
    method metrics (line 293) | pub fn metrics(&self) -> &HashMap<String, serde_json::Value> {
    method append_output (line 297) | pub fn append_output(&mut self, output: serde_json::Value) {
    method outputs (line 302) | pub fn outputs(&self) -> &[serde_json::Value] {
    method take_outputs (line 306) | pub fn take_outputs(&mut self) -> Vec<serde_json::Value> {
    method output (line 310) | pub fn output(&self) -> Option<&PredictionOutput> {
    method error (line 314) | pub fn error(&self) -> Option<&str> {
    method wait (line 318) | pub async fn wait(&self) {
    method completion (line 325) | pub fn completion(&self) -> Arc<Notify> {
    method take_webhook (line 330) | pub fn take_webhook(&mut self) -> Option<WebhookSender> {
    method fire_webhook (line 338) | fn fire_webhook(&self, event: WebhookEventType) {
    method fire_terminal_webhook (line 349) | fn fire_terminal_webhook(&mut self) {
    method build_state_snapshot (line 365) | pub fn build_state_snapshot(&self) -> serde_json::Value {
    method build_webhook_payload (line 401) | fn build_webhook_payload(&self) -> serde_json::Value {
    method build_terminal_response (line 405) | pub fn build_terminal_response(&self) -> serde_json::Value {
  function status_is_terminal (line 415) | fn status_is_terminal() {
  function new_starts_in_starting_status (line 424) | fn new_starts_in_starting_status() {
  function set_succeeded (line 431) | fn set_succeeded() {
  function set_failed (line 438) | fn set_failed() {
  function set_canceled (line 445) | fn set_canceled() {
  function cancel_token_works (line 452) | fn cancel_token_works() {
  function elapsed_time_increases (line 462) | fn elapsed_time_increases() {
  function append_log (line 471) | fn append_log() {
  function append_output (line 479) | fn append_output() {
  function wait_returns_immediately_if_terminal (line 487) | async fn wait_returns_immediately_if_terminal() {
  function prediction_output_single (line 496) | fn prediction_output_single() {
  function prediction_output_stream (line 503) | fn prediction_output_stream() {
  function metric_replace_sets_value (line 513) | fn metric_replace_sets_value() {
  function metric_replace_overwrites (line 520) | fn metric_replace_overwrites() {
  function metric_replace_null_deletes (line 528) | fn metric_replace_null_deletes() {
  function metric_increment_integers (line 536) | fn metric_increment_integers() {
  function metric_increment_floats (line 544) | fn metric_increment_floats() {
  function metric_increment_creates_from_zero (line 560) | fn metric_increment_creates_from_zero() {
  function metric_append_creates_array (line 567) | fn metric_append_creates_array() {
  function metric_append_to_non_array_wraps (line 583) | fn metric_append_to_non_array_wraps() {
  function metric_dotpath_creates_nested (line 591) | fn metric_dotpath_creates_nested() {
  function metric_dotpath_deep (line 605) | fn metric_dotpath_deep() {
  function metric_dotpath_multiple_leaves (line 612) | fn metric_dotpath_multiple_leaves() {
  function metric_dotpath_delete_leaf (line 631) | fn metric_dotpath_delete_leaf() {
  function metric_dotpath_increment (line 648) | fn metric_dotpath_increment() {
  function metric_complex_values (line 664) | fn metric_complex_values() {
  function terminal_snapshot_merges_metrics_with_predict_time (line 684) | fn terminal_snapshot_merges_metrics_with_predict_time() {
  function terminal_snapshot_predict_time_overrides_user (line 698) | fn terminal_snapshot_predict_time_overrides_user() {
  function terminal_state_guard_set_failed_after_succeeded (line 715) | fn terminal_state_guard_set_failed_after_succeeded() {
  function terminal_state_guard_set_succeeded_after_failed (line 725) | fn terminal_state_guard_set_succeeded_after_failed() {
  function terminal_state_guard_set_canceled_after_succeeded (line 734) | fn terminal_state_guard_set_canceled_after_succeeded() {

FILE: crates/coglet/src/predictor.rs
  type PredictionResult (line 10) | pub struct PredictionResult {
  type PredictionMetrics (line 20) | pub struct PredictionMetrics {
  type PredictionGuard (line 25) | pub struct PredictionGuard {
    method new (line 32) | pub fn new() -> Self {
    method cancel_token (line 40) | pub fn cancel_token(&self) -> CancellationToken {
    method is_cancelled (line 44) | pub fn is_cancelled(&self) -> bool {
    method cancel (line 48) | pub fn cancel(&self) {
    method finish (line 52) | pub fn finish(mut self) -> PredictionMetrics {
  method default (line 59) | fn default() -> Self {
  type PredictionError (line 65) | pub enum PredictionError {
  function prediction_output_single_is_not_stream (line 87) | fn prediction_output_single_is_not_stream() {
  function prediction_output_stream_is_stream (line 93) | fn prediction_output_stream_is_stream() {
  function prediction_output_serializes_untagged (line 99) | fn prediction_output_serializes_untagged() {
  function prediction_guard_tracks_time (line 108) | fn prediction_guard_tracks_time() {
  function prediction_error_display (line 120) | fn prediction_error_display() {

FILE: crates/coglet/src/service.rs
  function try_lock_prediction (line 29) | fn try_lock_prediction(
  type CreatePredictionError (line 46) | pub enum CreatePredictionError {
  type HealthSnapshot (line 55) | pub struct HealthSnapshot {
    method is_ready (line 64) | pub fn is_ready(&self) -> bool {
    method is_busy (line 69) | pub fn is_busy(&self) -> bool {
  type PredictionEntry (line 78) | struct PredictionEntry {
  type PredictionHandle (line 85) | pub struct PredictionHandle {
    method id (line 91) | pub fn id(&self) -> &str {
    method cancel_token (line 95) | pub fn cancel_token(&self) -> CancellationToken {
    method sync_guard (line 104) | pub fn sync_guard(&self, service: Arc<PredictionService>) -> SyncPredi...
  type SyncPredictionGuard (line 115) | pub struct SyncPredictionGuard {
    method new (line 121) | pub fn new(prediction_id: String, service: Arc<PredictionService>) -> ...
    method disarm (line 128) | pub fn disarm(&mut self) {
  method drop (line 134) | fn drop(&mut self) {
  type OrchestratorState (line 144) | pub struct OrchestratorState {
  method clone (line 150) | fn clone(&self) -> Self {
  type PredictionService (line 162) | pub struct PredictionService {
    method new_no_pool (line 186) | pub fn new_no_pool() -> Self {
    method set_orchestrator (line 203) | pub async fn set_orchestrator(
    method has_orchestrator (line 211) | pub async fn has_orchestrator(&self) -> bool {
    method shutdown (line 219) | pub async fn shutdown(&self) {
    method with_health (line 231) | pub fn with_health(mut self, health: Health) -> Self {
    method with_version (line 238) | pub fn with_version(mut self, version: VersionInfo) -> Self {
    method version (line 244) | pub fn version(&self) -> &VersionInfo {
    method supports_training (line 249) | pub async fn supports_training(&self) -> bool {
    method pool (line 254) | pub async fn pool(&self) -> Option<Arc<PermitPool>> {
    method health (line 262) | pub async fn health(&self) -> HealthSnapshot {
    method set_health (line 291) | pub async fn set_health(&self, health: Health) {
    method set_setup_result (line 301) | pub async fn set_setup_result(&self, result: SetupResult) {
    method set_schema (line 312) | pub async fn set_schema(&self, schema: serde_json::Value) {
    method schema (line 336) | pub async fn schema(&self) -> Option<serde_json::Value> {
    method validate_input (line 344) | pub async fn validate_input(
    method validate_train_input (line 359) | pub async fn validate_train_input(
    method healthcheck (line 375) | pub async fn healthcheck(
    method submit_prediction (line 397) | pub async fn submit_prediction(
    method prediction_exists (line 438) | pub fn prediction_exists(&self, id: &str) -> bool {
    method get_prediction_response (line 446) | pub fn get_prediction_response(&self, id: &str) -> Option<serde_json::...
    method predict (line 457) | pub async fn predict(
    method cancel (line 590) | pub fn cancel(&self, id: &str) -> bool {
    method remove_prediction (line 620) | pub fn remove_prediction(&self, id: &str) {
    method trigger_shutdown (line 624) | pub fn trigger_shutdown(&self) {
    method shutdown_rx (line 628) | pub fn shutdown_rx(&self) -> watch::Receiver<bool> {
  function build_slot_request (line 640) | fn build_slot_request(
  type MockOrchestrator (line 684) | struct MockOrchestrator {
    method new (line 691) | fn new() -> Self {
    method register_count (line 699) | fn register_count(&self) -> usize {
    method with_idle_ack (line 703) | fn with_idle_ack(mut self) -> Self {
  method register_prediction (line 711) | async fn register_prediction(
  method cancel_by_prediction_id (line 729) | async fn cancel_by_prediction_id(
  method healthcheck (line 736) | async fn healthcheck(
  method shutdown (line 742) | async fn shutdown(&self) -> Result<(), crate::orchestrator::Orchestrator...
  function create_test_pool (line 747) | async fn create_test_pool(num_slots: usize) -> Arc<PermitPool> {
  function create_test_pool_with_slots (line 771) | async fn create_test_pool_with_slots(num_slots: usize) -> (Arc<PermitPoo...
  function create_broken_test_pool (line 797) | async fn create_broken_test_pool() -> (Arc<PermitPool>, SlotId) {
  function service_new_no_pool_works (line 814) | async fn service_new_no_pool_works() {
  function service_no_pool_initially (line 825) | async fn service_no_pool_initially() {
  function shutdown_signal_works (line 833) | async fn shutdown_signal_works() {
  function submit_fails_when_not_ready (line 846) | async fn submit_fails_when_not_ready() {
  function cannot_set_ready_without_orchestrator (line 856) | async fn cannot_set_ready_without_orchestrator() {
  function set_orchestrator_enables_ready_health (line 869) | async fn set_orchestrator_enables_ready_health() {
  function submit_prediction_succeeds_when_ready (line 886) | async fn submit_prediction_succeeds_when_ready() {
  function submit_returns_at_capacity_when_no_slots (line 904) | async fn submit_returns_at_capacity_when_no_slots() {
  function predict_calls_orchestrator_register (line 926) | async fn predict_calls_orchestrator_register() {
  function health_shows_busy_when_all_slots_used (line 958) | async fn health_shows_busy_when_all_slots_used() {
  function predict_idle_channel_closed_poison_slot_async (line 982) | async fn predict_idle_channel_closed_poison_slot_async() {
  function predict_idle_ack_returns_capacity_async (line 1022) | async fn predict_idle_ack_returns_capacity_async() {
  function predict_send_failure_poison_slot (line 1061) | async fn predict_send_failure_poison_slot() {
  function cancel_prediction_works (line 1091) | async fn cancel_prediction_works() {
  function cancel_nonexistent_returns_false (line 1111) | async fn cancel_nonexistent_returns_false() {
  function sync_guard_cancels_on_drop (line 1117) | async fn sync_guard_cancels_on_drop() {
  function sync_guard_disarm_prevents_cancel (line 1141) | async fn sync_guard_disarm_prevents_cancel() {
  function remove_prediction_cleans_up (line 1165) | async fn remove_prediction_cleans_up() {
  function build_slot_request_small_input_inline (line 1184) | fn build_slot_request_small_input_inline() {
  function build_slot_request_large_input_spills (line 1213) | fn build_slot_request_large_input_spills() {
  function build_slot_request_roundtrip (line 1249) | fn build_slot_request_roundtrip() {

FILE: crates/coglet/src/setup_log_accumulator.rs
  type SetupLogAccumulator (line 16) | pub struct SetupLogAccumulator {
    method new (line 21) | pub fn new(tx: mpsc::UnboundedSender<String>) -> Self {
    method on_event (line 30) | fn on_event(&self, event: &tracing::Event<'_>, _ctx: Context<'_, S>) {
  type MessageVisitor (line 47) | struct MessageVisitor {
    method record_debug (line 52) | fn record_debug(&mut self, field: &tracing::field::Field, value: &dyn ...
    method record_str (line 61) | fn record_str(&mut self, field: &tracing::field::Field, value: &str) {
  function drain_accumulated_logs (line 68) | pub fn drain_accumulated_logs(rx: &mut mpsc::UnboundedReceiver<String>) ...

FILE: crates/coglet/src/transport/http/routes.rs
  type HealthCheckResponse (line 23) | pub struct HealthCheckResponse {
    method from_snapshot (line 33) | pub fn from_snapshot(snapshot: HealthSnapshot, user_healthcheck_error:...
  type PredictionRequest (line 53) | pub struct PredictionRequest {
  function default_empty_input (line 68) | fn default_empty_input() -> serde_json::Value {
  function deserialize_input (line 72) | fn deserialize_input<'de, D>(deserializer: D) -> Result<serde_json::Valu...
  function default_webhook_events_filter (line 84) | fn default_webhook_events_filter() -> Vec<WebhookEventType> {
  function generate_prediction_id (line 93) | fn generate_prediction_id() -> String {
  function root (line 109) | async fn root(State(service): State<Arc<PredictionService>>) -> Json<ser...
  function health_check (line 139) | async fn health_check(State(service): State<Arc<PredictionService>>) -> ...
  function write_readiness_file (line 182) | fn write_readiness_file() {
  function should_respond_async (line 204) | fn should_respond_async(headers: &HeaderMap) -> bool {
  function extract_trace_context (line 212) | fn extract_trace_context(headers: &HeaderMap) -> TraceContext {
  function create_prediction (line 225) | async fn create_prediction(
  function create_prediction_idempotent (line 254) | async fn create_prediction_idempotent(
  function build_webhook_sender (line 304) | fn build_webhook_sender(
  function create_prediction_with_id (line 329) | async fn create_prediction_with_id(
  function cancel_prediction (line 528) | async fn cancel_prediction(
  function shutdown (line 541) | async fn shutdown(State(service): State<Arc<PredictionService>>) -> impl...
  function openapi_schema (line 547) | async fn openapi_schema(State(service): State<Arc<PredictionService>>) -...
  function create_training (line 562) | async fn create_training(
  function create_training_idempotent (line 591) | async fn create_training_idempotent(
  function cancel_training (line 641) | async fn cancel_training(
  constant MAX_HTTP_BODY_SIZE (line 653) | const MAX_HTTP_BODY_SIZE: usize = 100 * 1024 * 1024;
  function routes (line 655) | pub fn routes(service: Arc<PredictionService>) -> Router {
  function response_json (line 679) | async fn response_json(response: axum::response::Response) -> serde_json...
  function health_check_returns_status_and_version (line 686) | async fn health_check_returns_status_and_version() {
  function health_check_unknown_when_no_predictor (line 703) | async fn health_check_unknown_when_no_predictor() {
  function predictions_returns_503_when_not_ready (line 717) | async fn predictions_returns_503_when_not_ready() {
  function openapi_returns_503_when_schema_not_available (line 744) | async fn openapi_returns_503_when_schema_not_available() {
  function openapi_returns_schema_when_available (line 760) | async fn openapi_returns_schema_when_available() {
  type MockOrchestrator (line 792) | struct MockOrchestrator {
    method new (line 798) | fn new() -> Self {
    method never_complete (line 806) | fn never_complete() -> Self {
  method register_prediction (line 816) | async fn register_prediction(
  method cancel_by_prediction_id (line 829) | async fn cancel_by_prediction_id(
  method healthcheck (line 836) | async fn healthcheck(
  method shutdown (line 843) | async fn shutdown(&self) -> Result<(), crate::orchestrator::Orchestrator...
  function create_test_pool (line 848) | async fn create_test_pool(num_slots: usize) -> Arc<PermitPool> {
  function create_ready_service (line 872) | async fn create_ready_service() -> Arc<PredictionService> {
  function health_check_ready_with_orchestrator (line 882) | async fn health_check_ready_with_orchestrator() {
  function prediction_sync_success (line 897) | async fn prediction_sync_success() {
  function prediction_async_returns_accepted (line 919) | async fn prediction_async_returns_accepted() {
  function prediction_with_custom_id (line 940) | async fn prediction_with_custom_id() {
  function prediction_idempotent_put (line 961) | async fn prediction_idempotent_put() {
  function prediction_idempotent_id_mismatch (line 982) | async fn prediction_idempotent_id_mismatch() {
  function prediction_at_capacity (line 1007) | async fn prediction_at_capacity() {
  function health_check_busy_when_at_capacity (line 1049) | async fn health_check_busy_when_at_capacity() {
  function training_routes_work (line 1084) | async fn training_routes_work() {
  function training_idempotent_put (line 1104) | async fn training_idempotent_put() {
  function training_idempotent_id_mismatch (line 1125) | async fn training_idempotent_id_mismatch() {
  function shutdown_triggers_service_shutdown (line 1150) | async fn shutdown_triggers_service_shutdown() {
  function root_returns_discovery_document (line 1168) | async fn root_returns_discovery_document() {
  function root_includes_training_urls_when_schema_has_training (line 1206) | async fn root_includes_training_urls_when_schema_has_training() {
  function root_cog_version_prefers_python_sdk (line 1247) | async fn root_cog_version_prefers_python_sdk() {

FILE: crates/coglet/src/transport/http/server.rs
  type ServerConfig (line 15) | pub struct ServerConfig {
  method default (line 24) | fn default() -> Self {
  function serve (line 34) | pub async fn serve(config: ServerConfig, service: Arc<PredictionService>...
  function shutdown_signal (line 66) | async fn shutdown_signal(await_explicit_shutdown: bool, mut shutdown_rx:...
  function server_config_default (line 118) | fn server_config_default() {

FILE: crates/coglet/src/version.rs
  constant COGLET_VERSION (line 4) | pub const COGLET_VERSION: &str = env!("CARGO_PKG_VERSION");
  type VersionInfo (line 8) | pub struct VersionInfo {
    method new (line 39) | pub fn new() -> Self {
    method with_git_sha (line 44) | pub fn with_git_sha(mut self, sha: String) -> Self {
    method with_build_time (line 50) | pub fn with_build_time(mut self, time: String) -> Self {
    method with_python_sdk (line 56) | pub fn with_python_sdk(mut self, version: String) -> Self {
    method with_python (line 62) | pub fn with_python(mut self, version: String) -> Self {
  method default (line 26) | fn default() -> Self {
  function version_info_has_coglet_version (line 73) | fn version_info_has_coglet_version() {
  function version_info_builder_pattern (line 81) | fn version_info_builder_pattern() {
  function version_info_serializes_minimal (line 95) | fn version_info_serializes_minimal() {
  function version_info_serializes_full (line 108) | fn version_info_serializes_full() {

FILE: crates/coglet/src/webhook.rs
  type WebhookEventType (line 28) | pub enum WebhookEventType {
    method is_terminal (line 37) | pub fn is_terminal(&self) -> bool {
    method all (line 41) | pub fn all() -> HashSet<WebhookEventType> {
  type WebhookSenderError (line 50) | pub enum WebhookSenderError {
  type WebhookConfig (line 56) | pub struct WebhookConfig {
  method default (line 65) | fn default() -> Self {
  type TraceContext (line 84) | pub struct TraceContext {
  type WebhookSender (line 89) | pub struct WebhookSender {
    method new (line 98) | pub fn new(url: String, config: WebhookConfig) -> Result<Self, Webhook...
    method with_trace_context (line 102) | pub fn with_trace_context(
    method url (line 135) | pub fn url(&self) -> &str {
    method should_send (line 139) | fn should_send(&self, event: WebhookEventType) -> bool {
    method update_last_sent (line 162) | fn update_last_sent(&self) {
    method build_request (line 168) | fn build_request(&self, payload: &serde_json::Value) -> reqwest::Reque...
    method send (line 182) | pub fn send(&self, event: WebhookEventType, payload: &serde_json::Valu...
    method send_terminal (line 198) | pub async fn send_terminal(&self, event: WebhookEventType, payload: &s...
    method send_terminal_sync (line 268) | pub fn send_terminal_sync(&self, payload: &serde_json::Value) {
  function config_defaults (line 381) | fn config_defaults() {
  function event_is_terminal (line 390) | fn event_is_terminal() {
  function test_config (line 397) | fn test_config() -> WebhookConfig {
  function send_terminal_posts_json (line 407) | async fn send_terminal_posts_json() {
  function send_terminal_retries_on_500 (line 429) | async fn send_terminal_retries_on_500() {
  function send_terminal_no_retry_on_400 (line 458) | async fn send_terminal_no_retry_on_400() {
  function send_terminal_respects_filter (line 480) | async fn send_terminal_respects_filter() {
  function send_non_terminal_fires_and_forgets (line 506) | async fn send_non_terminal_fires_and_forgets() {
  function send_non_terminal_logs_throttled (line 528) | async fn send_non_terminal_logs_throttled() {
  function send_output_not_throttled (line 559) | async fn send_output_not_throttled() {
  function send_terminal_sync_posts_json (line 590) | async fn send_terminal_sync_posts_json() {
  function send_terminal_sync_retries_on_500 (line 607) | async fn send_terminal_sync_retries_on_500() {

FILE: crates/coglet/src/worker.rs
  function increment_dropped_log_count (line 35) | pub fn increment_dropped_log_count() {
  function report_dropped_logs (line 41) | fn report_dropped_logs(tx: &mpsc::Sender<ControlResponse>, interval_mill...
  type FatalContext (line 55) | struct FatalContext {
  function init_fatal_context (line 61) | fn init_fatal_context(tx: mpsc::Sender<ControlResponse>) {
  function install_panic_hook (line 71) | fn install_panic_hook() {
  function init_worker_tracing (line 103) | fn init_worker_tracing(tx: mpsc::Sender<ControlResponse>) {
  type SlotWriter (line 142) | type SlotWriter =
  type SlotSender (line 150) | pub struct SlotSender {
    method new (line 157) | pub fn new(tx: mpsc::UnboundedSender<SlotResponse>, output_dir: PathBu...
    method next_output_path (line 166) | fn next_output_path(&self, extension: &str) -> PathBuf {
    method send_log (line 171) | pub fn send_log(&self, source: LogSource, data: &str) -> io::Result<()> {
    method write_file_output (line 190) | pub fn write_file_output(
    method send_file_output (line 205) | pub fn send_file_output(&self, path: PathBuf, mime_type: Option<String...
    method send_metric (line 221) | pub fn send_metric(
    method send_output (line 234) | pub fn send_output(&self, output: serde_json::Value) -> io::Result<()> {
  function build_output_message (line 243) | fn build_output_message(
  type SetupError (line 272) | pub enum SetupError {
    method load (line 287) | pub fn load(message: impl Into<String>) -> Self {
    method setup (line 293) | pub fn setup(message: impl Into<String>) -> Self {
    method internal (line 299) | pub fn internal(message: impl Into<String>) -> Self {
  type PredictHandler (line 308) | pub trait PredictHandler: Send + Sync + 'static {
    method setup (line 310) | async fn setup(&self) -> Result<(), SetupError>;
    method predict (line 313) | async fn predict(
    method cancel (line 323) | fn cancel(&self, slot: SlotId);
    method healthcheck (line 326) | async fn healthcheck(&self) -> HealthcheckResult {
  constant BUNDLED_SCHEMA_PATH (line 333) | const BUNDLED_SCHEMA_PATH: &str = ".cog/openapi_schema.json";
  function load_bundled_schema (line 340) | fn load_bundled_schema() -> Option<serde_json::Value> {
  type PredictionOutcome (line 370) | pub enum PredictionOutcome {
  type PredictResult (line 385) | pub struct PredictResult {
    method success (line 390) | pub fn success(output: serde_json::Value, predict_time: f64, is_stream...
    method failed (line 400) | pub fn failed(error: String, predict_time: f64) -> Self {
    method cancelled (line 409) | pub fn cancelled(predict_time: f64) -> Self {
  type SetupLogHook (line 420) | pub type SetupLogHook =
  type WorkerConfig (line 423) | pub struct WorkerConfig {
  method default (line 430) | fn default() -> Self {
  type SlotCompletion (line 438) | struct SlotCompletion {
    method idle (line 443) | fn idle(slot: SlotId) -> Self {
    method poisoned (line 449) | fn poisoned(slot: SlotId, error: impl Into<String>) -> Self {
  function run_worker (line 460) | pub async fn run_worker<H: PredictHandler>(
  function slot_reader_task (line 786) | async fn slot_reader_task(
  function run_prediction (line 810) | async fn run_prediction<H: PredictHandler>(
  function predict_result_success (line 919) | fn predict_result_success() {
  function predict_result_success_stream (line 925) | fn predict_result_success_stream() {
  function predict_result_failed (line 937) | fn predict_result_failed() {
  function predict_result_cancelled (line 946) | fn predict_result_cancelled() {
  function worker_config_default (line 952) | fn worker_config_default() {

FILE: crates/coglet/src/worker_tracing_layer.rs
  type WorkerTracingLayer (line 15) | pub struct WorkerTracingLayer {
    method new (line 21) | pub fn new(tx: mpsc::Sender<ControlResponse>) -> Self {
    method level_to_string (line 33) | fn level_to_string(level: &Level) -> &'static str {
    method on_event (line 48) | fn on_event(&self, event: &tracing::Event<'_>, _ctx: Context<'_, S>) {
  type MessageVisitor (line 93) | struct MessageVisitor {
    method record_debug (line 98) | fn record_debug(&mut self, field: &tracing::field::Field, value: &dyn ...
    method record_str (line 107) | fn record_str(&mut self, field: &tracing::field::Field, value: &str) {

FILE: integration-tests/concurrent/concurrent_test.go
  function TestConcurrentPredictions (line 36) | func TestConcurrentPredictions(t *testing.T) {
  type predictionResult (line 142) | type predictionResult struct
  function makePrediction (line 148) | func makePrediction(serverURL string, idx int) predictionResult {
  function waitForServerReady (line 175) | func waitForServerReady(serverURL string, timeout time.Duration) bool {
  function waitForServerStatus (line 212) | func waitForServerStatus(serverURL string, targetStatus string, timeout ...
  function allocatePort (line 247) | func allocatePort() (int, error) {
  constant cogYAML (line 258) | cogYAML = `build:
  constant predictPy (line 265) | predictPy = `import asyncio
  function TestConcurrentAboveLimit (line 277) | func TestConcurrentAboveLimit(t *testing.T) {
  constant aboveLimitCogYAML (line 373) | aboveLimitCogYAML = `build:
  function TestSIGTERMDuringSetup (line 381) | func TestSIGTERMDuringSetup(t *testing.T) {

FILE: integration-tests/harness/cmd_pty.go
  type PtyRunCommand (line 17) | type PtyRunCommand struct
    method Name (line 21) | func (c *PtyRunCommand) Name() string { return "pty-run" }
    method Run (line 37) | func (c *PtyRunCommand) Run(ts *testscript.TestScript, neg bool, args ...

FILE: integration-tests/harness/command.go
  type Command (line 6) | type Command interface
  type CommandFunc (line 17) | type CommandFunc struct
    method Name (line 22) | func (c CommandFunc) Name() string { return c.name }
    method Run (line 23) | func (c CommandFunc) Run(ts *testscript.TestScript, neg bool, args []s...
  function NewCommand (line 28) | func NewCommand(name string, fn func(ts *testscript.TestScript, neg bool...

FILE: integration-tests/harness/harness.go
  type serverInfo (line 43) | type serverInfo struct
  type registryInfo (line 49) | type registryInfo struct
  type mockUploadRecord (line 56) | type mockUploadRecord struct
  type mockUploadServer (line 64) | type mockUploadServer struct
  type webhookResult (line 72) | type webhookResult struct
  type webhookServer (line 83) | type webhookServer struct
  type Harness (line 91) | type Harness struct
    method Commands (line 240) | func (h *Harness) Commands() map[string]func(ts *testscript.TestScript...
    method cmdCog (line 278) | func (h *Harness) cmdCog(ts *testscript.TestScript, neg bool, args []s...
    method Setup (line 307) | func (h *Harness) Setup(env *testscript.Env) error {
    method cmdCogServe (line 395) | func (h *Harness) cmdCogServe(ts *testscript.TestScript, neg bool, arg...
    method cmdCurl (line 483) | func (h *Harness) cmdCurl(ts *testscript.TestScript, neg bool, args []...
    method StopServer (line 616) | func (h *Harness) StopServer(ts *testscript.TestScript) {
    method stopServerByWorkDir (line 622) | func (h *Harness) stopServerByWorkDir(workDir string) {
    method cmdWaitFor (line 729) | func (h *Harness) cmdWaitFor(ts *testscript.TestScript, neg bool, args...
    method cmdDockerRun (line 819) | func (h *Harness) cmdDockerRun(ts *testscript.TestScript, neg bool, ar...
    method cmdRegistryStart (line 866) | func (h *Harness) cmdRegistryStart(ts *testscript.TestScript, neg bool...
    method stopRegistryByWorkDir (line 905) | func (h *Harness) stopRegistryByWorkDir(workDir string) {
    method cmdRegistrySeed (line 930) | func (h *Harness) cmdRegistrySeed(ts *testscript.TestScript, neg bool,...
    method cmdRegistryInspect (line 978) | func (h *Harness) cmdRegistryInspect(ts *testscript.TestScript, neg bo...
    method cmdDockerPush (line 1013) | func (h *Harness) cmdDockerPush(ts *testscript.TestScript, neg bool, a...
    method cmdMockWeights (line 1093) | func (h *Harness) cmdMockWeights(ts *testscript.TestScript, neg bool, ...
    method cmdUploadServerStart (line 1244) | func (h *Harness) cmdUploadServerStart(ts *testscript.TestScript, neg ...
    method cmdUploadServerCount (line 1307) | func (h *Harness) cmdUploadServerCount(ts *testscript.TestScript, neg ...
    method stopUploadServerByWorkDir (line 1343) | func (h *Harness) stopUploadServerByWorkDir(workDir string) {
    method cmdWebhookServerStart (line 1367) | func (h *Harness) cmdWebhookServerStart(ts *testscript.TestScript, neg...
    method cmdWebhookServerWait (line 1465) | func (h *Harness) cmdWebhookServerWait(ts *testscript.TestScript, neg ...
    method stopWebhookServerByWorkDir (line 1502) | func (h *Harness) stopWebhookServerByWorkDir(workDir string) {
  function New (line 112) | func New() (*Harness, error) {
  function ResolveCogBinary (line 136) | func ResolveCogBinary() (string, error) {
  function buildCogBinary (line 156) | func buildCogBinary() (string, error) {
  function findRepoRoot (line 203) | func findRepoRoot() (string, error) {
  function runCommand (line 231) | func runCommand(dir string, name string, args ...string) error {
  function generateUniqueImageName (line 364) | func generateUniqueImageName() string {
  function removeDockerImage (line 375) | func removeDockerImage(imageName string) {
  function allocatePort (line 658) | func allocatePort() (int, error) {
  type healthCheckResponse (line 668) | type healthCheckResponse struct
  function waitForServer (line 675) | func waitForServer(serverURL string, timeout time.Duration) bool {
  function isAbsoluteImageRef (line 967) | func isAbsoluteImageRef(ref string) bool {
  type mockWeightsLock (line 1066) | type mockWeightsLock struct
  type mockWeightFile (line 1074) | type mockWeightFile struct
  function parseSize (line 1200) | func parseSize(s string) (int64, error) {

FILE: integration-tests/login/login_test.go
  function TestLoginGenericRegistryPTY (line 38) | func TestLoginGenericRegistryPTY(t *testing.T) {
  function TestLoginProviderRouting (line 232) | func TestLoginProviderRouting(t *testing.T) {
  function TestLoginEnvironmentVariable (line 335) | func TestLoginEnvironmentVariable(t *testing.T) {
  function TestLoginHelp (line 434) | func TestLoginHelp(t *testing.T) {
  function TestLoginSuggestFor (line 467) | func TestLoginSuggestFor(t *testing.T) {

FILE: integration-tests/suite_test.go
  function TestMain (line 24) | func TestMain(m *testing.M) {
  function TestIntegration (line 37) | func TestIntegration(t *testing.T) {
  function condition (line 68) | func condition(cond string) (bool, error) {

FILE: noxfile.py
  function _find_compatible_wheel (line 23) | def _find_compatible_wheel(pattern: str) -> str | None:
  function _install_coglet (line 57) | def _install_coglet(session: nox.Session) -> None:
  function _install_package (line 68) | def _install_package(session: nox.Session) -> None:
  function tests (line 82) | def tests(session: nox.Session) -> None:
  function typecheck (line 97) | def typecheck(session: nox.Session) -> None:
  function coglet_tests (line 105) | def coglet_tests(session: nox.Session) -> None:

FILE: pkg/cli/baseimage.go
  function NewBaseImageRootCommand (line 29) | func NewBaseImageRootCommand() (*cobra.Command, error) {
  function newBaseImageGenerateMatrix (line 57) | func newBaseImageGenerateMatrix() *cobra.Command {
  function newBaseImageDockerfileCommand (line 128) | func newBaseImageDockerfileCommand() *cobra.Command {
  function newBaseImageBuildCommand (line 155) | func newBaseImageBuildCommand() *cobra.Command {
  function addBaseImageFlags (line 204) | func addBaseImageFlags(cmd *cobra.Command) {
  function baseImageGeneratorFromFlags (line 211) | func baseImageGeneratorFromFlags(ctx context.Context) (*dockerfile.BaseI...

FILE: pkg/cli/build.go
  constant useCogBaseImageFlagKey (line 31) | useCogBaseImageFlagKey = "use-cog-base-image"
  function newBuildCommand (line 33) | func newBuildCommand() *cobra.Command {
  function buildCommand (line 73) | func buildCommand(cmd *cobra.Command, args []string) error {
  function addBuildProgressOutputFlag (line 109) | func addBuildProgressOutputFlag(cmd *cobra.Command) {
  function addSecretsFlag (line 120) | func addSecretsFlag(cmd *cobra.Command) {
  function addNoCacheFlag (line 124) | func addNoCacheFlag(cmd *cobra.Command) {
  function addSeparateWeightsFlag (line 128) | func addSeparateWeightsFlag(cmd *cobra.Command) {
  function addSchemaFlag (line 132) | func addSchemaFlag(cmd *cobra.Command) {
  function addUseCudaBaseImageFlag (line 136) | func addUseCudaBaseImageFlag(cmd *cobra.Command) {
  function addDockerfileFlag (line 140) | func addDockerfileFlag(cmd *cobra.Command) {
  function addUseCogBaseImageFlag (line 149) | func addUseCogBaseImageFlag(cmd *cobra.Command) {
  function addBuildTimestampFlag (line 153) | func addBuildTimestampFlag(cmd *cobra.Command) {
  function addStripFlag (line 158) | func addStripFlag(cmd *cobra.Command) {
  function addPrecompileFlag (line 164) | func addPrecompileFlag(cmd *cobra.Command) {
  function addConfigFlag (line 170) | func addConfigFlag(cmd *cobra.Command) {
  function checkMutuallyExclusiveFlags (line 174) | func checkMutuallyExclusiveFlags(cmd *cobra.Command, args []string) error {
  function DetermineUseCogBaseImage (line 188) | func DetermineUseCogBaseImage(cmd *cobra.Command) *bool {
  function buildOptionsFromFlags (line 199) | func buildOptionsFromFlags(cmd *cobra.Command, imageName string, annotat...

FILE: pkg/cli/debug.go
  function newDebugCommand (line 19) | func newDebugCommand() *cobra.Command {
  function cmdDockerfile (line 38) | func cmdDockerfile(cmd *cobra.Command, args []string) error {

FILE: pkg/cli/init-templates/base/predict.py
  class Predictor (line 7) | class Predictor(BasePredictor):
    method setup (line 8) | def setup(self) -> None:
    method predict (line 12) | def predict(

FILE: pkg/cli/init.go
  function newInitCommand (line 21) | func newInitCommand() *cobra.Command {
  function initCommand (line 39) | func initCommand(cmd *cobra.Command, args []string) error {
  function processTemplateDirectory (line 77) | func processTemplateDirectory(fs embed.FS, templateDir, subDir, cwd stri...
  function processTemplateFile (line 103) | func processTemplateFile(fs embed.FS, templateDir, filename, cwd string)...
  function downloadAgentsFile (line 154) | func downloadAgentsFile() ([]byte, error) {

FILE: pkg/cli/init_test.go
  function TestInit (line 11) | func TestInit(t *testing.T) {
  function TestInitSkipExisting (line 25) | func TestInitSkipExisting(t *testing.T) {

FILE: pkg/cli/inspect.go
  type InspectOutput (line 18) | type InspectOutput struct
  type InspectIndex (line 27) | type InspectIndex struct
  type InspectManifest (line 35) | type InspectManifest struct
  type InspectLayer (line 48) | type InspectLayer struct
  function newInspectCommand (line 54) | func newInspectCommand() *cobra.Command {
  function inspectCommand (line 80) | func inspectCommand(cmd *cobra.Command, args []string, localOnly, remote...
  function buildInspectOutput (line 129) | func buildInspectOutput(ctx context.Context, reference string, m *model....
  function buildManifestEntry (line 186) | func buildManifestEntry(im model.IndexManifest) InspectManifest {
  function fetchLayers (line 213) | func fetchLayers(ctx context.Context, reference, digest string, reg regi...
  type rawStep (line 243) | type rawStep struct
  function streamRaw (line 249) | func streamRaw(ctx context.Context, reference string, m *model.Model, re...
  function printInspectText (line 322) | func printInspectText(out *InspectOutput) {
  function printManifestText (line 362) | func printManifestText(m InspectManifest, indent string) {

FILE: pkg/cli/login.go
  function newLoginCommand (line 12) | func newLoginCommand() *cobra.Command {
  function login (line 33) | func login(cmd *cobra.Command, args []string) error {

FILE: pkg/cli/predict.go
  constant StdinPath (line 35) | StdinPath = "-"
  function newPredictCommand (line 46) | func newPredictCommand() *cobra.Command {
  function readStdin (line 96) | func readStdin() (string, error) {
  function parseJSONInput (line 105) | func parseJSONInput(jsonInput string) (map[string]any, error) {
  function transformPathsToBase64URLs (line 146) | func transformPathsToBase64URLs(inputs map[string]any) (map[string]any, ...
  function cmdPredict (line 179) | func cmdPredict(cmd *cobra.Command, args []string) error {
  function isURI (line 316) | func isURI(ref *openapi3.Schema) bool {
  function predictJSONInputs (line 320) | func predictJSONInputs(predictor predict.Predictor, jsonInput string, ou...
  function predictIndividualInputs (line 350) | func predictIndividualInputs(predictor predict.Predictor, inputFlags []s...
  function runPrediction (line 364) | func runPrediction(predictor predict.Predictor, inputs predict.Inputs, o...
  function ensureOutputWriteable (line 532) | func ensureOutputWriteable(outputPath string, fallbackPath string) (stri...
  function prettyJSONMarshal (line 577) | func prettyJSONMarshal(v any) ([]byte, error) {
  function processFileOutputs (line 589) | func processFileOutputs(output any, schema *openapi3.Schema, destination...
  function parseInputFlags (line 628) | func parseInputFlags(inputs []string, schema *openapi3.T, isTrain ...boo...
  function addSetupTimeoutFlag (line 654) | func addSetupTimeoutFlag(cmd *cobra.Command) {

FILE: pkg/cli/predict_test.go
  function TestExtractOutputSchemaFromMalformedSchema (line 10) | func TestExtractOutputSchemaFromMalformedSchema(t *testing.T) {
  function safeExtractOutputSchema (line 111) | func safeExtractOutputSchema(schema *openapi3.T, url string) *openapi3.S...
  function TestExtractOutputSchemaFromValidSchema (line 137) | func TestExtractOutputSchemaFromValidSchema(t *testing.T) {

FILE: pkg/cli/push.go
  function newPushCommand (line 18) | func newPushCommand() *cobra.Command {
  function push (line 52) | func push(cmd *cobra.Command, args []string) error {

FILE: pkg/cli/root.go
  function NewRootCommand (line 14) | func NewRootCommand() (*cobra.Command, error) {
  function setPersistentFlags (line 62) | func setPersistentFlags(cmd *cobra.Command) {

FILE: pkg/cli/run.go
  function addGpusFlag (line 22) | func addGpusFlag(cmd *cobra.Command) {
  function newRunCommand (line 26) | func newRunCommand() *cobra.Command {
  function run (line 69) | func run(cmd *cobra.Command, args []string) error {

FILE: pkg/cli/serve.go
  function newServeCommand (line 22) | func newServeCommand() *cobra.Command {
  function serveBuildOptions (line 62) | func serveBuildOptions(cmd *cobra.Command) model.BuildOptions {
  function cmdServe (line 72) | func cmdServe(cmd *cobra.Command, arg []string) error {

FILE: pkg/cli/train.go
  function newTrainCommand (line 26) | func newTrainCommand() *cobra.Command {
  function cmdTrain (line 56) | func cmdTrain(cmd *cobra.Command, args []string) error {

FILE: pkg/cli/train_test.go
  function TestTrainCommandIsDeprecated (line 9) | func TestTrainCommandIsDeprecated(t *testing.T) {

FILE: pkg/cli/weights.go
  function newWeightsCommand (line 19) | func newWeightsCommand() *cobra.Command {
  function newWeightsBuildCommand (line 33) | func newWeightsBuildCommand() *cobra.Command {
  function weightsBuildCommand (line 47) | func weightsBuildCommand(cmd *cobra.Command, args []string) error {
  function formatSize (line 95) | func formatSize(bytes int64) string {
  function newWeightsPushCommand (line 114) | func newWeightsPushCommand() *cobra.Command {
  function weightsPushCommand (line 131) | func weightsPushCommand(cmd *cobra.Command, args []string) error {

FILE: pkg/cli/weights_inspect.go
  type localWeight (line 18) | type localWeight struct
  type WeightsInspectOutput (line 25) | type WeightsInspectOutput struct
  type WeightInspectEntry (line 31) | type WeightInspectEntry struct
  type WeightLocalState (line 39) | type WeightLocalState struct
  type WeightRemoteLayer (line 47) | type WeightRemoteLayer struct
  type WeightRemoteState (line 54) | type WeightRemoteState struct
  function newWeightsInspectCommand (line 64) | func newWeightsInspectCommand() *cobra.Command {
  function weightsInspectCommand (line 82) | func weightsInspectCommand(cmd *cobra.Command, args []string, jsonOutput...
  function resolveWeightsByTag (line 204) | func resolveWeightsByTag(ctx context.Context, repo string, localWeights ...
  function printWeightsInspectText (line 260) | func printWeightsInspectText(out *WeightsInspectOutput) {
  function fileExists (line 303) | func fileExists(path string) bool {

FILE: pkg/config/build_options.go
  type BuildOptions (line 7) | type BuildOptions struct
  function DefaultBuildOptions (line 19) | func DefaultBuildOptions() BuildOptions {

FILE: pkg/config/compatibility.go
  type TFCompatibility (line 26) | type TFCompatibility struct
    method UnmarshalJSON (line 35) | func (compat *TFCompatibility) UnmarshalJSON(data []byte) error {
  type TorchCompatibility (line 55) | type TorchCompatibility struct
    method TorchVersion (line 65) | func (c *TorchCompatibility) TorchVersion() string {
    method TorchvisionVersion (line 69) | func (c *TorchCompatibility) TorchvisionVersion() string {
  type CUDABaseImage (line 73) | type CUDABaseImage struct
    method ImageTag (line 81) | func (i *CUDABaseImage) ImageTag() string {
  function init (line 97) | func init() {
  function cudaVersionFromTorchPlusVersion (line 122) | func cudaVersionFromTorchPlusVersion(ver string) (string, string) {
  function cudasFromTorch (line 154) | func cudasFromTorch(ver string) ([]string, error) {
  function cudaFromTF (line 186) | func cudaFromTF(ver string) (cuda string, cuDNN string, err error) {
  function compatibleCuDNNsForCUDA (line 195) | func compatibleCuDNNsForCUDA(cuda string) []string {
  function defaultCUDA (line 205) | func defaultCUDA() string {
  function latestCUDAFrom (line 210) | func latestCUDAFrom(cudas []string) string {
  function latestCuDNNForCUDA (line 229) | func latestCuDNNForCUDA(cuda string) (string, error) {
  function versionGreater (line 246) | func versionGreater(a string, b string) (bool, error) {
  function cudaBaseImageFor (line 259) | func cudaBaseImageFor(cuda string, cuDNN string) (string, error) {
  function tfGPUPackage (line 280) | func tfGPUPackage(ver string, cuda string) (name string, cpuVersion stri...
  function torchCPUPackage (line 291) | func torchCPUPackage(ver, goos, goarch string) (name, cpuVersion, findLi...
  function torchGPUPackage (line 302) | func torchGPUPackage(ver string, cuda string) (name, cpuVersion, findLin...
  function torchvisionCPUPackage (line 339) | func torchvisionCPUPackage(ver, goos, goarch string) (name, cpuVersion, ...
  function torchvisionGPUPackage (line 349) | func torchvisionGPUPackage(ver, cuda string) (name, cpuVersion, findLink...
  function torchStripCPUSuffixForM1 (line 389) | func torchStripCPUSuffixForM1(version string, goos string, goarch string...

FILE: pkg/config/compatibility_test.go
  function TestLatestCuDNNForCUDA (line 9) | func TestLatestCuDNNForCUDA(t *testing.T) {
  function TestCudasFromTorchWithCUVersionModifier (line 15) | func TestCudasFromTorchWithCUVersionModifier(t *testing.T) {

FILE: pkg/config/config.go
  constant MinimumMajorPythonVersion (line 31) | MinimumMajorPythonVersion               int    = 3
  constant MinimumMinorPythonVersion (line 32) | MinimumMinorPythonVersion               int    = 10
  constant MinimumMinorPythonVersionForConcurrency (line 33) | MinimumMinorPythonVersionForConcurrency int    = 11
  constant MinimumMajorCudaVersion (line 34) | MinimumMajorCudaVersion                 int    = 11
  constant DefaultPythonVersion (line 35) | DefaultPythonVersion                    string = "3.13"
  type RunItem (line 38) | type RunItem struct
    method UnmarshalYAML (line 97) | func (r *RunItem) UnmarshalYAML(unmarshal func(any) error) error {
    method UnmarshalJSON (line 135) | func (r *RunItem) UnmarshalJSON(data []byte) error {
  type Build (line 47) | type Build struct
  type Concurrency (line 65) | type Concurrency struct
  type WeightSource (line 70) | type WeightSource struct
  type Config (line 76) | type Config struct
    method CUDABaseImageTag (line 171) | func (c *Config) CUDABaseImageTag() (string, error) {
    method TorchVersion (line 175) | func (c *Config) TorchVersion() (string, bool) {
    method TorchvisionVersion (line 179) | func (c *Config) TorchvisionVersion() (string, bool) {
    method TorchaudioVersion (line 183) | func (c *Config) TorchaudioVersion() (string, bool) {
    method TensorFlowVersion (line 187) | func (c *Config) TensorFlowVersion() (string, bool) {
    method cudasFromTorch (line 191) | func (c *Config) cudasFromTorch() (torchVersion string, torchCUDAs []s...
    method cudaFromTF (line 202) | func (c *Config) cudaFromTF() (tfVersion string, tfCUDA string, tfCuDN...
    method pythonPackageVersion (line 213) | func (c *Config) pythonPackageVersion(name string) (version string, ok...
    method Complete (line 248) | func (c *Config) Complete(projectDir string) error {
    method PythonRequirementsForArch (line 286) | func (c *Config) PythonRequirementsForArch(goos string, goarch string,...
    method pythonPackageForArch (line 352) | func (c *Config) pythonPackageForArch(pkg, goos, goarch string) (actua...
    method validateAndCompleteCUDA (line 428) | func (c *Config) validateAndCompleteCUDA() error {
    method RequirementsFile (line 525) | func (c *Config) RequirementsFile(projectDir string) string {
    method ParsedEnvironment (line 529) | func (c *Config) ParsedEnvironment() map[string]string {
    method loadEnvironment (line 533) | func (c *Config) loadEnvironment() error {
  function defaultConfig (line 88) | func defaultConfig() *Config {
  function splitPythonVersion (line 227) | func splitPythonVersion(version string) (major int, minor int, err error) {
  function validateCudaVersion (line 411) | func validateCudaVersion(cudaVersion string) error {

FILE: pkg/config/config_file.go
  type configFile (line 14) | type configFile struct
  type buildFile (line 25) | type buildFile struct
    method GetGPU (line 162) | func (b *buildFile) GetGPU() bool {
  type runItemFile (line 41) | type runItemFile struct
    method UnmarshalYAML (line 67) | func (r *runItemFile) UnmarshalYAML(unmarshal func(any) error) error {
    method UnmarshalJSON (line 115) | func (r *runItemFile) UnmarshalJSON(data []byte) error {
  type mountFile (line 47) | type mountFile struct
  type weightFile (line 54) | type weightFile struct
  type concurrencyFile (line 61) | type concurrencyFile struct

FILE: pkg/config/config_test.go
  function TestValidateCudaVersion (line 15) | func TestValidateCudaVersion(t *testing.T) {
  function assertMinorVersion (line 65) | func assertMinorVersion(t *testing.T, expected, actual string) {
  function TestPythonPackagesAndRequirementsCantBeUsedTogether (line 83) | func TestPythonPackagesAndRequirementsCantBeUsedTogether(t *testing.T) {
  function TestPythonRequirementsResolvesPythonPackagesAndCudaVersions (line 98) | func TestPythonRequirementsResolvesPythonPackagesAndCudaVersions(t *test...
  function TestPythonRequirementsResolvesPythonPackagesAndCudaVersionsWithExtraIndexURL (line 128) | func TestPythonRequirementsResolvesPythonPackagesAndCudaVersionsWithExtr...
  function TestPythonRequirementsWorksWithLinesCogCannotParse (line 158) | func TestPythonRequirementsWorksWithLinesCogCannotParse(t *testing.T) {
  function TestValidateAndCompleteCUDAForAllTF (line 191) | func TestValidateAndCompleteCUDAForAllTF(t *testing.T) {
  function TestValidateAndCompleteCUDAForAllTorch (line 210) | func TestValidateAndCompleteCUDAForAllTorch(t *testing.T) {
  function TestValidateAndCompleteCUDAForSelectedTorch (line 234) | func TestValidateAndCompleteCUDAForSelectedTorch(t *testing.T) {
  function TestUnsupportedTorch (line 260) | func TestUnsupportedTorch(t *testing.T) {
  function TestUnsupportedTensorflow (line 296) | func TestUnsupportedTensorflow(t *testing.T) {
  function TestPythonPackagesForArchTorchGPU (line 333) | func TestPythonPackagesForArchTorchGPU(t *testing.T) {
  function TestPythonPackagesForArchTorchCPU (line 362) | func TestPythonPackagesForArchTorchCPU(t *testing.T) {
  function TestPythonPackagesForArchTensorflowGPU (line 389) | func TestPythonPackagesForArchTensorflowGPU(t *testing.T) {
  function TestPythonPackagesBothTorchAndTensorflow (line 419) | func TestPythonPackagesBothTorchAndTensorflow(t *testing.T) {
  function TestCUDABaseImageTag (line 444) | func TestCUDABaseImageTag(t *testing.T) {
  function TestBuildRunItemStringYAML (line 463) | func TestBuildRunItemStringYAML(t *testing.T) {
  function TestBuildRunItemStringJSON (line 483) | func TestBuildRunItemStringJSON(t *testing.T) {
  function TestBuildRunItemDictYAML (line 505) | func TestBuildRunItemDictYAML(t *testing.T) {
  function TestBuildRunItemDictJSON (line 533) | func TestBuildRunItemDictJSON(t *testing.T) {
  function TestTorchWithExistingExtraIndexURL (line 568) | func TestTorchWithExistingExtraIndexURL(t *testing.T) {
  function TestBlankBuild (line 590) | func TestBlankBuild(t *testing.T) {
  function TestPythonRequirementsForArchWithAddedPackage (line 610) | func TestPythonRequirementsForArchWithAddedPackage(t *testing.T) {
  function TestParseTests (line 634) | func TestParseTests(t *testing.T) {
  function TestConfigMarshal (line 649) | func TestConfigMarshal(t *testing.T) {
  function TestAbsolutePathInPythonRequirements (line 660) | func TestAbsolutePathInPythonRequirements(t *testing.T) {
  function TestWeightsWithNameYAML (line 679) | func TestWeightsWithNameYAML(t *testing.T) {
  function TestWeightsWithoutNameYAML (line 706) | func TestWeightsWithoutNameYAML(t *testing.T) {
  function TestWeightsWithNameJSON (line 725) | func TestWeightsWithNameJSON(t *testing.T) {
  function TestSDKVersionConfig (line 759) | func TestSDKVersionConfig(t *testing.T) {
  function TestSDKVersionConfigEmpty (line 771) | func TestSDKVersionConfigEmpty(t *testing.T) {
  function TestSDKVersionConfigPreRelease (line 782) | func TestSDKVersionConfigPreRelease(t *testing.T) {
  function TestSDKVersionConfigBelowMinimumExplodesInGenerator (line 794) | func TestSDKVersionConfigBelowMinimumExplodesInGenerator(t *testing.T) {

FILE: pkg/config/env.go
  function validateEnvName (line 40) | func validateEnvName(name string) error {
  function parseAndValidateEnvironment (line 60) | func parseAndValidateEnvironment(input []string) (map[string]string, err...

FILE: pkg/config/env_variables_test.go
  function TestEnvironmentConfig (line 11) | func TestEnvironmentConfig(t *testing.T) {

FILE: pkg/config/errors.go
  type ConfigError (line 10) | type ConfigError interface
  type ParseError (line 16) | type ParseError struct
    method Error (line 21) | func (e *ParseError) Error() string {
    method Unwrap (line 25) | func (e *ParseError) Unwrap() error {
    method ConfigError (line 29) | func (e *ParseError) ConfigError() {}
  type SchemaError (line 33) | type SchemaError struct
    method Error (line 38) | func (e *SchemaError) Error() string {
    method ConfigError (line 42) | func (e *SchemaError) ConfigError() {}
  type ValidationError (line 46) | type ValidationError struct
    method Error (line 52) | func (e *ValidationError) Error() string {
    method ConfigError (line 59) | func (e *ValidationError) ConfigError() {}
  type DeprecationWarning (line 63) | type DeprecationWarning struct
    method Error (line 69) | func (w *DeprecationWarning) Error() string {
    method ConfigError (line 76) | func (w *DeprecationWarning) ConfigError() {}
  type CompatibilityError (line 79) | type CompatibilityError struct
    method Error (line 87) | func (e *CompatibilityError) Error() string {
    method ConfigError (line 92) | func (e *CompatibilityError) ConfigError() {}
  type ValidationResult (line 95) | type ValidationResult struct
    method HasErrors (line 101) | func (r *ValidationResult) HasErrors() bool {
    method HasWarnings (line 106) | func (r *ValidationResult) HasWarnings() bool {
    method Err (line 111) | func (r *ValidationResult) Err() error {
    method AddError (line 119) | func (r *ValidationResult) AddError(err error) {
    method AddWarning (line 124) | func (r *ValidationResult) AddWarning(w DeprecationWarning) {
  function NewValidationResult (line 129) | func NewValidationResult() *ValidationResult {

FILE: pkg/config/image_name.go
  function DockerImageName (line 10) | func DockerImageName(projectDir string) string {

FILE: pkg/config/image_name_test.go
  function TestDockerImageName (line 9) | func TestDockerImageName(t *testing.T) {

FILE: pkg/config/load.go
  constant maxSearchDepth (line 13) | maxSearchDepth = 100
  type LoadResult (line 16) | type LoadResult struct
  function Load (line 26) | func Load(r io.Reader, projectDir string) (*LoadResult, error) {
  function GetProjectDir (line 64) | func GetProjectDir(configFilename string) (string, error) {
  function findConfigPathInDirectory (line 77) | func findConfigPathInDirectory(dir string, configFilename string) (confi...
  function findProjectRootDir (line 91) | func findProjectRootDir(startDir string, configFilename string) (string,...

FILE: pkg/config/load_test.go
  constant testConfig (line 11) | testConfig = `
  function TestFindProjectRootDirShouldFindParentDir (line 21) | func TestFindProjectRootDirShouldFindParentDir(t *testing.T) {
  function TestFindProjectRootDirShouldReturnErrIfNoConfig (line 36) | func TestFindProjectRootDirShouldReturnErrIfNoConfig(t *testing.T) {

FILE: pkg/config/parse.go
  function parse (line 17) | func parse(r io.Reader) (*configFile, error) {
  function parseFile (line 29) | func parseFile(filename string) (*configFile, error) {
  function parseBytes (line 62) | func parseBytes(contents []byte) (*configFile, error) {
  function FromYAML (line 86) | func FromYAML(contents []byte) (*Config, error) {
  function configFileToConfig (line 99) | func configFileToConfig(cfg *configFile) (*Config, error) {

FILE: pkg/config/validate.go
  type ValidateOption (line 23) | type ValidateOption
  type validateOptions (line 25) | type validateOptions struct
  function WithProjectDir (line 32) | func WithProjectDir(dir string) ValidateOption {
  function WithRequirementsFS (line 39) | func WithRequirementsFS(fsys fs.FS) ValidateOption {
  function WithStrictDeprecations (line 46) | func WithStrictDeprecations() ValidateOption {
  function ValidateConfigFile (line 55) | func ValidateConfigFile(cfg *configFile, opts ...ValidateOption) *Valida...
  function validateSchema (line 90) | func validateSchema(cfg *configFile) error {
  function validatePredict (line 109) | func validatePredict(cfg *configFile, result *ValidationResult) {
  function validateTrain (line 125) | func validateTrain(cfg *configFile, result *ValidationResult) {
  function validateBuild (line 141) | func validateBuild(cfg *configFile, opts *validateOptions, result *Valid...
  function validatePythonVersion (line 189) | func validatePythonVersion(version string) error {
  function validateCUDAVersion (line 230) | func validateCUDAVersion(cudaVersion string) error {
  function validateRequirementsFile (line 261) | func validateRequirementsFile(reqPath string, opts *validateOptions) err...
  function validateGPUConfig (line 292) | func validateGPUConfig(cfg *configFile, opts *validateOptions, result *V...
  function loadRequirementsForValidation (line 327) | func loadRequirementsForValidation(reqPath string, opts *validateOptions...
  function parseRequirementsContent (line 349) | func parseRequirementsContent(content string) []string {
  function validateFrameworkCompatibility (line 363) | func validateFrameworkCompatibility(cfg *configFile, reqs []string, resu...
  function findPackageVersion (line 396) | func findPackageVersion(reqs []string, name string) string {
  function validateEnvironment (line 410) | func validateEnvironment(cfg *configFile, result *ValidationResult) {
  function validateConcurrency (line 425) | func validateConcurrency(cfg *configFile, result *ValidationResult) {
  function checkDeprecatedFields (line 458) | func checkDeprecatedFields(cfg *configFile, result *ValidationResult) {
  function getMostSpecificSchemaError (line 481) | func getMostSpecificSchemaError(errors []gojsonschema.ResultError) *Sche...
  function getSchemaErrorDescription (line 513) | func getSchemaErrorDescription(err gojsonschema.ResultError, allErrors [...
  function humanReadableSchemaType (line 528) | func humanReadableSchemaType(definition string) string {
  function schemaErrorSpecificity (line 549) | func schemaErrorSpecificity(err gojsonschema.ResultError) int {

FILE: pkg/config/validate_test.go
  function TestValidateConfigFile (line 9) | func TestValidateConfigFile(t *testing.T) {
  function TestValidateConfigFileSuccess (line 25) | func TestValidateConfigFileSuccess(t *testing.T) {
  function TestValidateConfigFilePythonVersionNumerical (line 44) | func TestValidateConfigFilePythonVersionNumerical(t *testing.T) {
  function TestValidateConfigFileNullListsAllowed (line 63) | func TestValidateConfigFileNullListsAllowed(t *testing.T) {
  function TestValidateConfigFilePredictFormat (line 78) | func TestValidateConfigFilePredictFormat(t *testing.T) {
  function TestValidateConfigFileConcurrencyType (line 97) | func TestValidateConfigFileConcurrencyType(t *testing.T) {
  function TestValidateConfigFileDeprecatedPythonPackages (line 117) | func TestValidateConfigFileDeprecatedPythonPackages(t *testing.T) {
  function TestValidateConfigFileDeprecatedPreInstall (line 133) | func TestValidateConfigFileDeprecatedPreInstall(t *testing.T) {
  function TestValidateConfigFileMissingPythonVersion (line 149) | func TestValidateConfigFileMissingPythonVersion(t *testing.T) {
  function TestValidateConfigFileMissingPythonVersionEmptyBuild (line 161) | func TestValidateConfigFileMissingPythonVersionEmptyBuild(t *testing.T) {
  function TestValidateConfigFileNilBuildSkipsPythonVersionCheck (line 171) | func TestValidateConfigFileNilBuildSkipsPythonVersionCheck(t *testing.T) {
  function ptr (line 180) | func ptr[T any](v T) *T { return &v }

FILE: pkg/config/version.go
  type ArgumentType (line 4) | type ArgumentType
  constant ArgumentTypeString (line 7) | ArgumentTypeString ArgumentType = "str"
  constant ArgumentTypeInt (line 8) | ArgumentTypeInt    ArgumentType = "int"
  constant ArgumentTypeFloat (line 9) | ArgumentTypeFloat  ArgumentType = "float"
  constant ArgumentTypeBool (line 10) | ArgumentTypeBool   ArgumentType = "bool"
  constant ArgumentTypePath (line 11) | ArgumentTypePath   ArgumentType = "Path"
  type RunArgument (line 15) | type RunArgument struct

FILE: pkg/docker/build_secrets.go
  function ParseSecretsFromHost (line 14) | func ParseSecretsFromHost(workingDir string, secrets []string) (secrets....
  function parseSecretFromHost (line 28) | func parseSecretFromHost(workingDir, secret string) (*secretsprovider.So...

FILE: pkg/docker/buildkit.go
  function prepareDockerfileDir (line 25) | func prepareDockerfileDir(buildDir string, dockerfileContents string) (s...
  function solveOptFromImageOptions (line 34) | func solveOptFromImageOptions(buildDir string, opts command.ImageBuildOp...
  function newDisplay (line 155) | func newDisplay(statusCh chan *buildkitclient.SolveStatus, displayMode s...
  function newBuildkitAuthProvider (line 177) | func newBuildkitAuthProvider(registryHosts ...string) session.Attachable {
  type buildkitAuthProvider (line 187) | type buildkitAuthProvider struct
    method Register (line 191) | func (ap *buildkitAuthProvider) Register(server *grpc.Server) {
    method Credentials (line 195) | func (ap *buildkitAuthProvider) Credentials(ctx context.Context, req *...
    method FetchToken (line 209) | func (ap *buildkitAuthProvider) FetchToken(ctx context.Context, req *a...
    method GetTokenAuthority (line 213) | func (ap *buildkitAuthProvider) GetTokenAuthority(ctx context.Context,...
    method VerifyTokenAuthority (line 217) | func (ap *buildkitAuthProvider) VerifyTokenAuthority(ctx context.Conte...

FILE: pkg/docker/command/command.go
  type Command (line 11) | type Command interface
  type ImageBuildOptions (line 35) | type ImageBuildOptions struct
  type RunOptions (line 54) | type RunOptions struct
  type Port (line 69) | type Port struct
  type Volume (line 74) | type Volume struct

FILE: pkg/docker/command/errors.go
  type NotFoundError (line 9) | type NotFoundError struct
    method Error (line 16) | func (e *NotFoundError) Error() string {
    method Is (line 24) | func (e *NotFoundError) Is(target error) bool {
  function IsNotFoundError (line 29) | func IsNotFoundError(err error) bool {

FILE: pkg/docker/command/manifest.go
  type Config (line 5) | type Config struct
  type Manifest (line 10) | type Manifest struct
  constant R8CogVersionEnvVarName (line 15) | R8CogVersionEnvVarName    = "R8_COG_VERSION"
  constant R8TorchVersionEnvVarName (line 16) | R8TorchVersionEnvVarName  = "R8_TORCH_VERSION"
  constant R8CudaVersionEnvVarName (line 17) | R8CudaVersionEnvVarName   = "R8_CUDA_VERSION"
  constant R8CudnnVersionEnvVarName (line 18) | R8CudnnVersionEnvVarName  = "R8_CUDNN_VERSION"
  constant R8PythonVersionEnvVarName (line 19) | R8PythonVersionEnvVarName = "R8_PYTHON_VERSION"

FILE: pkg/docker/command/user_info.go
  type UserInfo (line 3) | type UserInfo struct

FILE: pkg/docker/credential_helper_input.go
  type CredentialHelperInput (line 3) | type CredentialHelperInput struct

FILE: pkg/docker/credentials.go
  function loadUserInformation (line 22) | func loadUserInformation(ctx context.Context, registryHost string) (*com...
  function loadAuthFromConfig (line 45) | func loadAuthFromConfig(conf *configfile.ConfigFile, registryHost string...
  function loadRegistryAuths (line 49) | func loadRegistryAuths(ctx context.Context, registryHosts ...string) (ma...
  function tryLoadAuthForHost (line 78) | func tryLoadAuthForHost(ctx context.Context, conf *configfile.ConfigFile...
  function loadAuthFromCredentialsStore (line 106) | func loadAuthFromCredentialsStore(ctx context.Context, credsStore string...
  function dockerCredentialBinary (line 149) | func dockerCredentialBinary(credsStore string) string {

FILE: pkg/docker/credentials_test.go
  function TestLoadRegistryAuths_Fallback (line 16) | func TestLoadRegistryAuths_Fallback(t *testing.T) {
  function TestTryLoadAuthForHost (line 133) | func TestTryLoadAuthForHost(t *testing.T) {

FILE: pkg/docker/docker.go
  function ptrVal (line 36) | func ptrVal[T any](v T) *T { return &v }
  function NewClient (line 38) | func NewClient(ctx context.Context, opts ...Option) (*apiClient, error) {
  type apiClient (line 88) | type apiClient struct
    method Pull (line 93) | func (c *apiClient) Pull(ctx context.Context, imageRef string, force b...
    method ContainerStop (line 132) | func (c *apiClient) ContainerStop(ctx context.Context, containerID str...
    method ContainerInspect (line 147) | func (c *apiClient) ContainerInspect(ctx context.Context, containerID ...
    method ContainerLogs (line 160) | func (c *apiClient) ContainerLogs(ctx context.Context, containerID str...
    method Push (line 197) | func (c *apiClient) Push(ctx context.Context, imageRef string) error {
    method ImageSave (line 258) | func (c *apiClient) ImageSave(ctx context.Context, imageRef string) (i...
    method LoadUserInformation (line 264) | func (c *apiClient) LoadUserInformation(ctx context.Context, registryH...
    method Inspect (line 270) | func (c *apiClient) Inspect(ctx context.Context, ref string) (*image.I...
    method RemoveImage (line 288) | func (c *apiClient) RemoveImage(ctx context.Context, ref string) error {
    method ImageExists (line 302) | func (c *apiClient) ImageExists(ctx context.Context, ref string) (bool...
    method ImageBuild (line 315) | func (c *apiClient) ImageBuild(ctx context.Context, options command.Im...
    method containerRun (line 380) | func (c *apiClient) containerRun(ctx context.Context, options command....
    method Run (line 581) | func (c *apiClient) Run(ctx context.Context, options command.RunOption...
    method ContainerStart (line 595) | func (c *apiClient) ContainerStart(ctx context.Context, options comman...
  function parseGPURequest (line 604) | func parseGPURequest(opts command.RunOptions) (container.DeviceRequest, ...
  function shouldAttachStdin (line 639) | func shouldAttachStdin(stdin io.Reader) (attach bool, tty bool) {

FILE: pkg/docker/docker_client_test.go
  function TestDockerClient (line 22) | func TestDockerClient(t *testing.T) {
  function assertImageExists (line 400) | func assertImageExists(t *testing.T, dockerClient command.Command, image...
  function assertNoImageExists (line 408) | func assertNoImageExists(t *testing.T, dockerClient command.Command, ima...
  function assertNotFoundError (line 416) | func assertNotFoundError(t *testing.T, err error, ref string, object str...

FILE: pkg/docker/dockertest/command_mocks.go
  function NewMockCommand2 (line 19) | func NewMockCommand2(t interface {
  type MockCommand2 (line 32) | type MockCommand2 struct
    method EXPECT (line 40) | func (_m *MockCommand2) EXPECT() *MockCommand2_Expecter {
    method ContainerInspect (line 45) | func (_mock *MockCommand2) ContainerInspect(ctx context.Context, id st...
    method ContainerLogs (line 113) | func (_mock *MockCommand2) ContainerLogs(ctx context.Context, containe...
    method ContainerStart (line 176) | func (_mock *MockCommand2) ContainerStart(ctx context.Context, options...
    method ContainerStop (line 242) | func (_mock *MockCommand2) ContainerStop(ctx context.Context, containe...
    method ImageBuild (line 299) | func (_mock *MockCommand2) ImageBuild(ctx context.Context, options com...
    method ImageSave (line 365) | func (_mock *MockCommand2) ImageSave(ctx context.Context, imageRef str...
    method ImageExists (line 433) | func (_mock *MockCommand2) ImageExists(ctx context.Context, ref string...
    method Inspect (line 499) | func (_mock *MockCommand2) Inspect(ctx context.Context, ref string) (*...
    method LoadUserInformation (line 567) | func (_mock *MockCommand2) LoadUserInformation(ctx context.Context, re...
    method Pull (line 635) | func (_mock *MockCommand2) Pull(ctx context.Context, ref string, force...
    method Push (line 709) | func (_mock *MockCommand2) Push(ctx context.Context, ref string) error {
    method RemoveImage (line 766) | func (_mock *MockCommand2) RemoveImage(ctx context.Context, ref string...
    method Run (line 823) | func (_mock *MockCommand2) Run(ctx context.Context, options command.Ru...
  type MockCommand2_Expecter (line 36) | type MockCommand2_Expecter struct
    method ContainerInspect (line 80) | func (_e *MockCommand2_Expecter) ContainerInspect(ctx interface{}, id ...
    method ContainerLogs (line 138) | func (_e *MockCommand2_Expecter) ContainerLogs(ctx interface{}, contai...
    method ContainerStart (line 209) | func (_e *MockCommand2_Expecter) ContainerStart(ctx interface{}, optio...
    method ContainerStop (line 266) | func (_e *MockCommand2_Expecter) ContainerStop(ctx interface{}, contai...
    method ImageBuild (line 332) | func (_e *MockCommand2_Expecter) ImageBuild(ctx interface{}, options i...
    method ImageSave (line 400) | func (_e *MockCommand2_Expecter) ImageSave(ctx interface{}, imageRef i...
    method ImageExists (line 466) | func (_e *MockCommand2_Expecter) ImageExists(ctx interface{}, ref inte...
    method Inspect (line 534) | func (_e *MockCommand2_Expecter) Inspect(ctx interface{}, ref interfac...
    method LoadUserInformation (line 602) | func (_e *MockCommand2_Expecter) LoadUserInformation(ctx interface{}, ...
    method Pull (line 671) | func (_e *MockCommand2_Expecter) Pull(ctx interface{}, ref interface{}...
    method Push (line 733) | func (_e *MockCommand2_Expecter) Push(ctx interface{}, ref interface{}...
    method RemoveImage (line 790) | func (_e *MockCommand2_Expecter) RemoveImage(ctx interface{}, ref inte...
    method Run (line 847) | func (_e *MockCommand2_Expecter) Run(ctx interface{}, options interfac...
  type MockCommand2_ContainerInspect_Call (line 73) | type MockCommand2_ContainerInspect_Call struct
    method Run (line 84) | func (_c *MockCommand2_ContainerInspect_Call) Run(run func(ctx context...
    method Return (line 102) | func (_c *MockCommand2_ContainerInspect_Call) Return(inspectResponse *...
    method RunAndReturn (line 107) | func (_c *MockCommand2_ContainerInspect_Call) RunAndReturn(run func(ct...
  type MockCommand2_ContainerLogs_Call (line 130) | type MockCommand2_ContainerLogs_Call struct
    method Run (line 142) | func (_c *MockCommand2_ContainerLogs_Call) Run(run func(ctx context.Co...
    method Return (line 165) | func (_c *MockCommand2_ContainerLogs_Call) Return(err error) *MockComm...
    method RunAndReturn (line 170) | func (_c *MockCommand2_ContainerLogs_Call) RunAndReturn(run func(ctx c...
  type MockCommand2_ContainerStart_Call (line 202) | type MockCommand2_ContainerStart_Call struct
    method Run (line 213) | func (_c *MockCommand2_ContainerStart_Call) Run(run func(ctx context.C...
    method Return (line 231) | func (_c *MockCommand2_ContainerStart_Call) Return(s string, err error...
    method RunAndReturn (line 236) | func (_c *MockCommand2_ContainerStart_Call) RunAndReturn(run func(ctx ...
  type MockCommand2_ContainerStop_Call (line 259) | type MockCommand2_ContainerStop_Call struct
    method Run (line 270) | func (_c *MockCommand2_ContainerStop_Call) Run(run func(ctx context.Co...
    method Return (line 288) | func (_c *MockCommand2_ContainerStop_Call) Return(err error) *MockComm...
    method RunAndReturn (line 293) | func (_c *MockCommand2_ContainerStop_Call) RunAndReturn(run func(ctx c...
  type MockCommand2_ImageBuild_Call (line 325) | type MockCommand2_ImageBuild_Call struct
    method Run (line 336) | func (_c *MockCommand2_ImageBuild_Call) Run(run func(ctx context.Conte...
    method Return (line 354) | func (_c *MockCommand2_ImageBuild_Call) Return(imageID string, err err...
    method RunAndReturn (line 359) | func (_c *MockCommand2_ImageBuild_Call) RunAndReturn(run func(ctx cont...
  type MockCommand2_ImageSave_Call (line 393) | type MockCommand2_ImageSave_Call struct
    method Run (line 404) | func (_c *MockCommand2_ImageSave_Call) Run(run func(ctx context.Contex...
    method Return (line 422) | func (_c *MockCommand2_ImageSave_Call) Return(rc io.ReadCloser, err er...
    method RunAndReturn (line 427) | func (_c *MockCommand2_ImageSave_Call) RunAndReturn(run func(ctx conte...
  type MockCommand2_ImageExists_Call (line 459) | type MockCommand2_ImageExists_Call struct
    method Run (line 470) | func (_c *MockCommand2_ImageExists_Call) Run(run func(ctx context.Cont...
    method Return (line 488) | func (_c *MockCommand2_ImageExists_Call) Return(b bool, err error) *Mo...
    method RunAndReturn (line 493) | func (_c *MockCommand2_ImageExists_Call) RunAndReturn(run func(ctx con...
  type MockCommand2_Inspect_Call (line 527) | type MockCommand2_Inspect_Call struct
    method Run (line 538) | func (_c *MockCommand2_Inspect_Call) Run(run func(ctx context.Context,...
    method Return (line 556) | func (_c *MockCommand2_Inspect_Call) Return(inspectResponse *image.Ins...
    method RunAndReturn (line 561) | func (_c *MockCommand2_Inspect_Call) RunAndReturn(run func(ctx context...
  type MockCommand2_LoadUserInformation_Call (line 595) | type MockCommand2_LoadUserInformation_Call struct
    method Run (line 606) | func (_c *MockCommand2_LoadUserInformation_Call) Run(run func(ctx cont...
    method Return (line 624) | func (_c *MockCommand2_LoadUserInformation_Call) Return(userInfo *comm...
    method RunAndReturn (line 629) | func (_c *MockCommand2_LoadUserInformation_Call) RunAndReturn(run func...
  type MockCommand2_Pull_Call (line 663) | type MockCommand2_Pull_Call struct
    method Run (line 675) | func (_c *MockCommand2_Pull_Call) Run(run func(ctx context.Context, re...
    method Return (line 698) | func (_c *MockCommand2_Pull_Call) Return(inspectResponse *image.Inspec...
    method RunAndReturn (line 703) | func (_c *MockCommand2_Pull_Call) RunAndReturn(run func(ctx context.Co...
  type MockCommand2_Push_Call (line 726) | type MockCommand2_Push_Call struct
    method Run (line 737) | func (_c *MockCommand2_Push_Call) Run(run func(ctx context.Context, re...
    method Return (line 755) | func (_c *MockCommand2_Push_Call) Return(err error) *MockCommand2_Push...
    method RunAndReturn (line 760) | func (_c *MockCommand2_Push_Call) RunAndReturn(run func(ctx context.Co...
  type MockCommand2_RemoveImage_Call (line 783) | type MockCommand2_RemoveImage_Call struct
    method Run (line 794) | func (_c *MockCommand2_RemoveImage_Call) Run(run func(ctx context.Cont...
    method Return (line 812) | func (_c *MockCommand2_RemoveImage_Call) Return(err error) *MockComman...
    method RunAndReturn (line 817) | func (_c *MockCommand2_RemoveImage_Call) RunAndReturn(run func(ctx con...
  type MockCommand2_Run_Call (line 840) | type MockCommand2_Run_Call struct
    method Run (line 851) | func (_c *MockCommand2_Run_Call) Run(run func(ctx context.Context, opt...
    method Return (line 869) | func (_c *MockCommand2_Run_Call) Return(err error) *MockCommand2_Run_C...
    method RunAndReturn (line 874) | func (_c *MockCommand2_Run_Call) RunAndReturn(run func(ctx context.Con...

FILE: pkg/docker/dockertest/helper_client.go
  function NewHelperClient (line 25) | func NewHelperClient(t testing.TB) *HelperClient {
  type HelperClient (line 67) | type HelperClient struct
    method Close (line 74) | func (c *HelperClient) Close() error {
    method PullImage (line 78) | func (c *HelperClient) PullImage(t testing.TB, ref string) error {
    method MustPullImage (line 103) | func (c *HelperClient) MustPullImage(t testing.TB, ref string) {
    method PushImage (line 108) | func (c *HelperClient) PushImage(t testing.TB, ref string) error {
    method MustPushImage (line 134) | func (c *HelperClient) MustPushImage(t testing.TB, ref string) {
    method RunContainer (line 139) | func (c *HelperClient) RunContainer(t testing.TB, imageName string) st...
    method StopContainer (line 180) | func (c *HelperClient) StopContainer(t testing.TB, containerID string) {
    method InspectImage (line 190) | func (c *HelperClient) InspectImage(t testing.TB, imageRef string) *im...
    method ImageExists (line 199) | func (c *HelperClient) ImageExists(t testing.TB, imageRef string) bool {
    method DeleteImage (line 206) | func (c *HelperClient) DeleteImage(t testing.TB, imageRef string) error {
    method MustDeleteImage (line 216) | func (c *HelperClient) MustDeleteImage(t testing.TB, imageRef string) {
    method CleanupImage (line 226) | func (c *HelperClient) CleanupImage(t testing.TB, imageRef string) {
    method CleanupImages (line 240) | func (c *HelperClient) CleanupImages(t testing.TB) {
    method InspectContainer (line 269) | func (c *HelperClient) InspectContainer(t testing.TB, containerID stri...
    method ImageFixture (line 278) | func (c *HelperClient) ImageFixture(t testing.TB, name string, tag str...
    method loadImageFixture (line 292) | func (c *HelperClient) loadImageFixture(t testing.TB, name string) *im...
  type imageFixture (line 341) | type imageFixture struct

FILE: pkg/docker/dockertest/image.go
  function ImageRef (line 13) | func ImageRef(t *testing.T, label string) string {
  function ImageRefWithRegistry (line 21) | func ImageRefWithRegistry(t *testing.T, registryAddr string, label strin...

FILE: pkg/docker/dockertest/mock_command.go
  type MockCommand (line 21) | type MockCommand struct
    method Pull (line 27) | func (c *MockCommand) Pull(ctx context.Context, image string, force bo...
    method Push (line 31) | func (c *MockCommand) Push(ctx context.Context, image string) error {
    method LoadUserInformation (line 35) | func (c *MockCommand) LoadUserInformation(ctx context.Context, registr...
    method CreateTarFile (line 43) | func (c *MockCommand) CreateTarFile(ctx context.Context, image string,...
    method CreateAptTarFile (line 53) | func (c *MockCommand) CreateAptTarFile(ctx context.Context, tmpDir str...
    method Inspect (line 63) | func (c *MockCommand) Inspect(ctx context.Context, ref string) (*image...
    method ImageExists (line 85) | func (c *MockCommand) ImageExists(ctx context.Context, ref string) (bo...
    method ContainerLogs (line 89) | func (c *MockCommand) ContainerLogs(ctx context.Context, containerID s...
    method ContainerInspect (line 93) | func (c *MockCommand) ContainerInspect(ctx context.Context, id string)...
    method ContainerStop (line 97) | func (c *MockCommand) ContainerStop(ctx context.Context, containerID s...
    method RemoveImage (line 101) | func (c *MockCommand) RemoveImage(ctx context.Context, ref string) err...
    method ImageBuild (line 105) | func (c *MockCommand) ImageBuild(ctx context.Context, options command....
    method Run (line 109) | func (c *MockCommand) Run(ctx context.Context, options command.RunOpti...
    method ContainerStart (line 113) | func (c *MockCommand) ContainerStart(ctx context.Context, options comm...
    method ImageSave (line 117) | func (c *MockCommand) ImageSave(ctx context.Context, imageRef string) ...
  function NewMockCommand (line 23) | func NewMockCommand() *MockCommand {

FILE: pkg/docker/dockertest/ref.go
  type Ref (line 11) | type Ref struct
    method WithTag (line 35) | func (r Ref) WithTag(tagName string) Ref {
    method WithDigest (line 40) | func (r Ref) WithDigest(digest string) Ref {
    method WithRegistry (line 45) | func (r Ref) WithRegistry(registry string) Ref {
    method WithoutRegistry (line 64) | func (r Ref) WithoutRegistry() Ref {
    method String (line 80) | func (r Ref) String() string {
  function NewRef (line 16) | func NewRef(t *testing.T) Ref {

FILE: pkg/docker/dockertest/ref_test.go
  function TestRef (line 9) | func TestRef(t *testing.T) {

FILE: pkg/docker/env.go
  constant DockerCommandEnvVarName (line 5) | DockerCommandEnvVarName = "R8_DOCKER_COMMAND"
  function DockerCommandFromEnvironment (line 7) | func DockerCommandFromEnvironment() string {

FILE: pkg/docker/errors.go
  function isTagNotFoundError (line 12) | func isTagNotFoundError(err error) bool {
  function isAuthorizationFailedError (line 18) | func isAuthorizationFailedError(err error) bool {
  function isRepositoryNotFoundError (line 39) | func isRepositoryNotFoundError(err error) bool {
  function isMissingDeviceDriverError (line 45) | func isMissingDeviceDriverError(err error) bool {
  function isNetworkError (line 52) | func isNetworkError(err error) bool {

FILE: pkg/docker/host.go
  function determineDockerHost (line 16) | func determineDockerHost() (string, error) {
  function dockerHostFromContext (line 44) | func dockerHostFromContext(contextName string) (string, string, error) {

FILE: pkg/docker/host_unix.go
  constant defaultDockerHost (line 6) | defaultDockerHost = "unix:///var/run/docker.sock"

FILE: pkg/docker/host_windows.go
  constant defaultDockerHost (line 4) | defaultDockerHost = "npipe:////.pipe/docker_engine"

FILE: pkg/docker/login.go
  function SaveLoginToken (line 18) | func SaveLoginToken(ctx context.Context, registryHost string, username s...
  function saveAuthToConfig (line 27) | func saveAuthToConfig(conf *configfile.ConfigFile, registryHost string, ...
  function saveAuthToCredentialsStore (line 39) | func saveAuthToCredentialsStore(ctx context.Context, credsStore string, ...

FILE: pkg/docker/options.go
  type clientOptions (line 5) | type clientOptions struct
  type Option (line 10) | type Option
  function WithAuthConfig (line 12) | func WithAuthConfig(authConfig registry.AuthConfig) Option {
  function WithHost (line 18) | func WithHost(host string) Option {

FILE: pkg/docker/progress.go
  type ProgressWriter (line 20) | type ProgressWriter struct
    method Write (line 48) | func (p *ProgressWriter) Write(id, status string, current, total int64) {
    method WriteStatus (line 62) | func (p *ProgressWriter) WriteStatus(id, status string) {
    method writeMessage (line 70) | func (p *ProgressWriter) writeMessage(msg jsonmessage.JSONMessage) {
    method Close (line 87) | func (p *ProgressWriter) Close() {
  function NewProgressWriter (line 29) | func NewProgressWriter() *ProgressWriter {

FILE: pkg/docker/push.go
  type BuildInfo (line 13) | type BuildInfo struct
  function Push (line 18) | func Push(ctx context.Context, image string, projectDir string, command ...

FILE: pkg/docker/run.go
  function Run (line 19) | func Run(ctx context.Context, dockerClient command.Command, options comm...
  function RunWithIO (line 23) | func RunWithIO(ctx context.Context, dockerClient command.Command, option...
  function RunDaemon (line 32) | func RunDaemon(ctx context.Context, dockerClient command.Command, option...
  function GetHostPortForContainer (line 37) | func GetHostPortForContainer(ctx context.Context, dockerCommand command....

FILE: pkg/docker/run_test.go
  function TestGetHostPortForContainer (line 14) | func TestGetHostPortForContainer(t *testing.T) {

FILE: pkg/docker/standard_push.go
  function StandardPush (line 9) | func StandardPush(ctx context.Context, image string, command command.Com...

FILE: pkg/docker/standard_push_test.go
  function TestStandardPush (line 11) | func TestStandardPush(t *testing.T) {

FILE: pkg/dockercontext/build_tempdir.go
  function CogBuildArtifactsDirPath (line 11) | func CogBuildArtifactsDirPath(dir string) (string, error) {
  function CogTempDir (line 20) | func CogTempDir(dir string, contextDir string) (string, error) {
  function BuildCogTempDir (line 28) | func BuildCogTempDir(dir string, subDir string) (string, error) {
  function BuildTempDir (line 39) | func BuildTempDir(dir string) (string, error) {

FILE: pkg/dockercontext/build_tempdir_test.go
  function TestBuildCogTempDir (line 10) | func TestBuildCogTempDir(t *testing.T) {

FILE: pkg/dockercontext/directories.go
  constant StandardBuildDirectory (line 5) | StandardBuildDirectory = "."
  constant ContextBuildDir (line 7) | ContextBuildDir = "context"
  constant AptBuildContextName (line 8) | AptBuildContextName = "apt"
  constant RequirementsBuildContextName (line 9) | RequirementsBuildContextName = "requirements"
  constant SrcBuildContextName (line 10) | SrcBuildContextName = "src"

FILE: pkg/dockerfile/base.go
  constant MinimumCUDAVersion (line 16) | MinimumCUDAVersion = "11.6"
  constant MinimumPythonVersion (line 17) | MinimumPythonVersion = "3.10"
  constant MinimumTorchVersion (line 18) | MinimumTorchVersion = "1.13.1"
  constant CogBaseImageName (line 19) | CogBaseImageName = "cog-base"
  type CUDAVersion (line 53) | type CUDAVersion struct
  type PyTorchVersion (line 57) | type PyTorchVersion struct
  type PythonVersion (line 61) | type PythonVersion struct
  type AvailableBaseImageConfigurations (line 67) | type AvailableBaseImageConfigurations struct
  type BaseImageConfiguration (line 71) | type BaseImageConfiguration struct
    method MarshalJSON (line 85) | func (b BaseImageConfiguration) MarshalJSON() ([]byte, error) {
  type BaseImageGenerator (line 77) | type BaseImageGenerator struct
    method GenerateDockerfile (line 184) | func (g *BaseImageGenerator) GenerateDockerfile(ctx context.Context) (...
    method makeConfig (line 205) | func (g *BaseImageGenerator) makeConfig() (*config.Config, error) {
    method pythonPackages (line 222) | func (g *BaseImageGenerator) pythonPackages() []string {
    method runStatements (line 260) | func (g *BaseImageGenerator) runStatements() []config.RunItem {
  function BaseImageConfigurations (line 110) | func BaseImageConfigurations() []BaseImageConfiguration {
  function NewBaseImageGenerator (line 167) | func NewBaseImageGenerator(ctx context.Context, client registry.Client, ...
  function baseImageComponentNormalisation (line 264) | func baseImageComponentNormalisation(cudaVersion string, pythonVersion s...
  function BaseImageName (line 290) | func BaseImageName(cudaVersion string, pythonVersion string, torchVersio...
  function BaseImageConfigurationExists (line 312) | func BaseImageConfigurationExists(ctx context.Context, client registry.C...
  function isVersionCompatible (line 343) | func isVersionCompatible(confVersion, requestedVersion string) bool {

FILE: pkg/dockerfile/base_test.go
  function TestBaseImageName (line 14) | func TestBaseImageName(t *testing.T) {
  function TestGenerateDockerfile (line 37) | func TestGenerateDockerfile(t *testing.T) {
  function TestBaseImageNameWithVersionModifier (line 59) | func TestBaseImageNameWithVersionModifier(t *testing.T) {
  function TestBaseImageConfigurationExists (line 64) | func TestBaseImageConfigurationExists(t *testing.T) {
  function TestBaseImageConfigurationExistsNoTorch (line 76) | func TestBaseImageConfigurationExistsNoTorch(t *testing.T) {
  function TestBaseImageConfigurationExistsNoCUDA (line 87) | func TestBaseImageConfigurationExistsNoCUDA(t *testing.T) {
  function TestIsVersionCompatible (line 99) | func TestIsVersionCompatible(t *testing.T) {
  function TestPythonPackages (line 104) | func TestPythonPackages(t *testing.T) {
  function TestInvalidBaseImage (line 122) | func TestInvalidBaseImage(t *testing.T) {
  function TestBaseImageConfigurationNoTorchPythonVersionDoesNotExist (line 129) | func TestBaseImageConfigurationNoTorchPythonVersionDoesNotExist(t *testi...

FILE: pkg/dockerfile/cacert.go
  constant CACertEnvVar (line 15) | CACertEnvVar = "COG_CA_CERT"
  constant CACertFilename (line 18) | CACertFilename = "cog-ca-cert.crt"
  constant CACertContainerPath (line 21) | CACertContainerPath = "/usr/local/share/ca-certificates/" + CACertFilename
  constant SystemCertBundle (line 24) | SystemCertBundle = "/etc/ssl/certs/ca-certificates.crt"
  function ReadCACert (line 38) | func ReadCACert() ([]byte, error) {
  function readCACertFile (line 69) | func readCACertFile(path string) ([]byte, error) {
  function readCACertDirectory (line 78) | func readCACertDirectory(dir string) ([]byte, error) {
  function validatePEM (line 120) | func validatePEM(data []byte) ([]byte, error) {
  function GenerateCACertInstall (line 144) | func GenerateCACertInstall(certData []byte, writeTemp func(filename stri...

FILE: pkg/dockerfile/cacert_test.go
  constant testCertPEM (line 13) | testCertPEM = `-----BEGIN CERTIFICATE-----
  constant testCertPEM2 (line 23) | testCertPEM2 = `-----BEGIN CERTIFICATE-----
  function TestReadCACert_NotSet (line 33) | func TestReadCACert_NotSet(t *testing.T) {
  function TestReadCACert_FilePath (line 41) | func TestReadCACert_FilePath(t *testing.T) {
  function TestReadCACert_Directory (line 55) | func TestReadCACert_Directory(t *testing.T) {
  function TestReadCACert_InlinePEM (line 74) | func TestReadCACert_InlinePEM(t *testing.T) {
  function TestReadCACert_Base64EncodedPEM (line 83) | func TestReadCACert_Base64EncodedPEM(t *testing.T) {
  function TestReadCACert_InvalidPEM (line 93) | func TestReadCACert_InvalidPEM(t *testing.T) {
  function TestReadCACert_MissingFile (line 102) | func TestReadCACert_MissingFile(t *testing.T) {
  function TestReadCACert_EmptyDirectory (line 111) | func TestReadCACert_EmptyDirectory(t *testing.T) {
  function TestReadCACert_InvalidFileInDirectory (line 121) | func TestReadCACert_InvalidFileInDirectory(t *testing.T) {
  function TestReadCACert_TrimsWhitespace (line 134) | func TestReadCACert_TrimsWhitespace(t *testing.T) {
  function TestGenerateCACertInstall (line 144) | func TestGenerateCACertInstall(t *testing.T) {
  function TestGenerateCACertInstall_EmptyData (line 168) | func TestGenerateCACertInstall_EmptyData(t *testing.T) {

FILE: pkg/dockerfile/env.go
  function envLineFromConfig (line 10) | func envLineFromConfig(c *config.Config) (string, error) {

FILE: pkg/dockerfile/generator.go
  type Generator (line 9) | type Generator interface

FILE: pkg/dockerfile/generator_factory.go
  function NewGenerator (line 9) | func NewGenerator(config *config.Config, dir string, configFilename stri...

FILE: pkg/dockerfile/generator_factory_test.go
  function TestGeneratorFactoryStandardGenerator (line 13) | func TestGeneratorFactoryStandardGenerator(t *testing.T) {

FILE: pkg/dockerfile/standard_generator.go
  constant DockerignoreHeader (line 23) | DockerignoreHeader = `# generated by replicate/cog
  constant LDConfigCacheBuildCommand (line 45) | LDConfigCacheBuildCommand = "RUN find / -type f -name \"*python*.so\" -p...
  constant StripDebugSymbolsCommand (line 46) | StripDebugSymbolsCommand = "find / -type f -name \"*python*.so\" -not -n...
  constant CFlags (line 47) | CFlags = "ENV CFLAGS=\"-O3 -funroll-loops -fno-strict-aliasing -flto -S\""
  constant UVVersion (line 48) | UVVersion = "0.9.26"
  constant uvCacheMount (line 49) | uvCacheMount = "--mount=type=cache,target=/root/.cache/uv"
  constant uvPip (line 50) | uvPip = "uv pip"
  constant PrecompilePythonCommand (line 51) | PrecompilePythonCommand = "RUN find / -type f -name \"*.py[co]\" -delete...
  constant STANDARD_GENERATOR_NAME (line 52) | STANDARD_GENERATOR_NAME = "STANDARD_GENERATOR"
  type StandardGenerator (line 54) | type StandardGenerator struct
    method SetUseCudaBaseImage (line 131) | func (g *StandardGenerator) SetUseCudaBaseImage(argumentValue string) {
    method SetUseCogBaseImage (line 136) | func (g *StandardGenerator) SetUseCogBaseImage(useCogBaseImage bool) {
    method SetUseCogBaseImagePtr (line 141) | func (g *StandardGenerator) SetUseCogBaseImagePtr(useCogBaseImage *boo...
    method IsUsingCogBaseImage (line 145) | func (g *StandardGenerator) IsUsingCogBaseImage() bool {
    method SetStrip (line 153) | func (g *StandardGenerator) SetStrip(strip bool) {
    method SetPrecompile (line 157) | func (g *StandardGenerator) SetPrecompile(precompile bool) {
    method GenerateInitialSteps (line 161) | func (g *StandardGenerator) GenerateInitialSteps(ctx context.Context) ...
    method GenerateModelBase (line 243) | func (g *StandardGenerator) GenerateModelBase(ctx context.Context) (st...
    method GenerateDockerfileWithoutSeparateWeights (line 259) | func (g *StandardGenerator) GenerateDockerfileWithoutSeparateWeights(c...
    method GenerateModelBaseWithSeparateWeights (line 280) | func (g *StandardGenerator) GenerateModelBaseWithSeparateWeights(ctx c...
    method cogEnvVars (line 326) | func (g *StandardGenerator) cogEnvVars() []string {
    method cpCogYaml (line 340) | func (g *StandardGenerator) cpCogYaml() string {
    method generateForWeights (line 348) | func (g *StandardGenerator) generateForWeights() (string, []string, []...
    method Cleanup (line 376) | func (g *StandardGenerator) Cleanup() error {
    method BaseImage (line 383) | func (g *StandardGenerator) BaseImage(ctx context.Context) (string, er...
    method Name (line 402) | func (g *StandardGenerator) Name() string {
    method BuildDir (line 406) | func (g *StandardGenerator) BuildDir() (string, error) {
    method BuildContexts (line 410) | func (g *StandardGenerator) BuildContexts() (map[string]string, error) {
    method preamble (line 414) | func (g *StandardGenerator) preamble() string {
    method installTini (line 421) | func (g *StandardGenerator) installTini() string {
    method aptInstalls (line 441) | func (g *StandardGenerator) aptInstalls() (string, error) {
    method installPython (line 459) | func (g *StandardGenerator) installPython() (string, error) {
    method installUV (line 466) | func (g *StandardGenerator) installUV() string {
    method installPythonCUDA (line 471) | func (g *StandardGenerator) installPythonCUDA() (string, error) {
    method resolveCogWheelConfigs (line 504) | func (g *StandardGenerator) resolveCogWheelConfigs() error {
    method isLegacySDKVersion (line 556) | func (g *StandardGenerator) isLegacySDKVersion() bool {
    method installCog (line 572) | func (g *StandardGenerator) installCog() (string, error) {
    method installCogFromPyPI (line 657) | func (g *StandardGenerator) installCogFromPyPI(config *wheels.WheelCon...
    method installWheelFromURL (line 672) | func (g *StandardGenerator) installWheelFromURL(url string) (string, e...
    method installWheelFromFile (line 702) | func (g *StandardGenerator) installWheelFromFile(path string) (string,...
    method installCogletWheel (line 741) | func (g *StandardGenerator) installCogletWheel(config *wheels.WheelCon...
    method installCogletFromPyPI (line 756) | func (g *StandardGenerator) installCogletFromPyPI(config *wheels.Wheel...
    method installCogletFromURL (line 771) | func (g *StandardGenerator) installCogletFromURL(url string) (string, ...
    method installCogletFromFile (line 781) | func (g *StandardGenerator) installCogletFromFile(path string) (string...
    method filterManagedPackages (line 806) | func (g *StandardGenerator) filterManagedPackages(reqContents string) ...
    method pipInstalls (line 859) | func (g *StandardGenerator) pipInstalls() (string, error) {
    method runCommands (line 912) | func (g *StandardGenerator) runCommands() (string, error) {
    method envVars (line 945) | func (g *StandardGenerator) envVars() (string, error) {
    method installCACert (line 951) | func (g *StandardGenerator) installCACert() (string, error) {
    method writeTemp (line 964) | func (g *StandardGenerator) writeTemp(filename string, contents []byte...
    method GenerateWeightsManifest (line 994) | func (g *StandardGenerator) GenerateWeightsManifest(ctx context.Contex...
    method determineBaseImageName (line 1023) | func (g *StandardGenerator) determineBaseImageName(ctx context.Context...
  function NewStandardGenerator (line 94) | func NewStandardGenerator(config *config.Config, dir string, configFilen...
  function makeDockerignoreForWeights (line 365) | func makeDockerignoreForWeights(dirs, files []string) string {
  constant cogletMinSDKVersion (line 551) | cogletMinSDKVersion = "0.17.0"
  function joinStringsWithoutLineSpace (line 975) | func joinStringsWithoutLineSpace(chunks []string) string {
  function filterEmpty (line 984) | func filterEmpty(list []string) []string {
  function stripPatchVersion (line 1049) | func stripPatchVersion(versionString string) (string, bool, error) {

FILE: pkg/dockerfile/standard_generator_test.go
  function testTini (line 19) | func testTini() string {
  function testInstallCog (line 34) | func testInstallCog(stripped bool) string {
  function pypiWheels (line 48) | func pypiWheels(gen *StandardGenerator) {
  function testInstallPython (line 53) | func testInstallPython(version string) string {
  function TestGenerateEmptyCPU (line 70) | func TestGenerateEmptyCPU(t *testing.T) {
  function TestGenerateEmptyGPU (line 108) | func TestGenerateEmptyGPU(t *testing.T) {
  function TestGenerateFullCPU (line 146) | func TestGenerateFullCPU(t *testing.T) {
  function TestGenerateFullGPU (line 205) | func TestGenerateFullGPU(t *testing.T) {
  function TestPreInstall (line 264) | func TestPreInstall(t *testing.T) {
  function TestPythonRequirements (line 306) | func TestPythonRequirements(t *testing.T) {
  type mockFileInfo (line 330) | type mockFileInfo struct
    method Size (line 334) | func (mfi mockFileInfo) Size() int64 {
    method Name (line 337) | func (mfi mockFileInfo) Name() string {
    method Mode (line 340) | func (mfi mockFileInfo) Mode() os.FileMode {
    method ModTime (line 343) | func (mfi mockFileInfo) ModTime() time.Time {
    method IsDir (line 346) | func (mfi mockFileInfo) IsDir() bool {
    method Sys (line 349) | func (mfi mockFileInfo) Sys() any {
  constant sizeThreshold (line 353) | sizeThreshold = 10 * 1024 * 1024
  function TestGenerateWithLargeModels (line 355) | func TestGenerateWithLargeModels(t *testing.T) {
  function TestGenerateDockerfileWithoutSeparateWeights (line 463) | func TestGenerateDockerfileWithoutSeparateWeights(t *testing.T) {
  function TestGenerateEmptyCPUWithCogBaseImage (line 500) | func TestGenerateEmptyCPUWithCogBaseImage(t *testing.T) {
  function TestGeneratePythonCPUWithCogBaseImage (line 534) | func TestGeneratePythonCPUWithCogBaseImage(t *testing.T) {
  function TestGenerateFullGPUWithCogBaseImage (line 585) | func TestGenerateFullGPUWithCogBaseImage(t *testing.T) {
  function TestGenerateTorchWithStrippedModifiedVersion (line 650) | func TestGenerateTorchWithStrippedModifiedVersion(t *testing.T) {
  function TestGenerateWithStrip (line 707) | func TestGenerateWithStrip(t *testing.T) {
  function TestGenerateDoesNotContainDangerousCFlags (line 765) | func TestGenerateDoesNotContainDangerousCFlags(t *testing.T) {
  function TestGenerateWithPrecompile (line 800) | func TestGenerateWithPrecompile(t *testing.T) {
  function TestGenerateWithCoglet (line 860) | func TestGenerateWithCoglet(t *testing.T) {
  function TestCOGWheelDefault (line 923) | func TestCOGWheelDefault(t *testing.T) {
  function TestCOGWheelEnvPyPI (line 951) | func TestCOGWheelEnvPyPI(t *testing.T) {
  function TestCOGWheelEnvPyPIWithVersion (line 979) | func TestCOGWheelEnvPyPIWithVersion(t *testing.T) {
  function TestCOGWheelEnvURL (line 1007) | func TestCOGWheelEnvURL(t *testing.T) {
  function TestCOGWheelEnvFile (line 1036) | func TestCOGWheelEnvFile(t *testing.T) {
  function TestCogletStrippedFromRequirements (line 1069) | func TestCogletStrippedFromRequirements(t *testing.T) {
  function TestInstallCogWithSDKVersion (line 1094) | func TestInstallCogWithSDKVersion(t *testing.T) {
  function TestInstallCogWithPreReleaseSDKVersion (line 1120) | func TestInstallCogWithPreReleaseSDKVersion(t *testing.T) {
  function TestInstallCogSDKVersionBelowMinimum (line 1146) | func TestInstallCogSDKVersionBelowMinimum(t *testing.T) {
  function TestCOGSDKWheelEnvVarOverridesSDKVersion (line 1170) | func TestCOGSDKWheelEnvVarOverridesSDKVersion(t *testing.T) {

FILE: pkg/dockerfile/version_check.go
  function parse (line 11) | func parse(s string) (string, string, string) {
  function CheckMajorOnly (line 23) | func CheckMajorOnly(s string) bool {
  function CheckMajorMinorOnly (line 28) | func CheckMajorMinorOnly(s string) bool {
  function CheckMajorMinorPatch (line 33) | func CheckMajorMinorPatch(s string) bool {

FILE: pkg/dockerignore/dockerignore.go
  constant DockerIgnoreFilename (line 13) | DockerIgnoreFilename = ".dockerignore"
  function CreateMatcher (line 15) | func CreateMatcher(dir string) (*ignore.GitIgnore, error) {
  function Walk (line 32) | func Walk(root string, ignoreMatcher *ignore.GitIgnore, fn filepath.Walk...
  function readDockerIgnore (line 58) | func readDockerIgnore(dockerIgnorePath string) ([]string, error) {

FILE: pkg/dockerignore/dockerignore_test.go
  function TestWalk (line 11) | func TestWalk(t *testing.T) {

FILE: pkg/env/env.go
  constant SchemeEnvVarName (line 5) | SchemeEnvVarName = "R8_SCHEME"
  constant WebHostEnvVarName (line 6) | WebHostEnvVarName = "R8_WEB_HOST"
  constant APIHostEnvVarName (line 7) | APIHostEnvVarName = "R8_API_HOST"
  constant PytorchHostEnvVarName (line 8) | PytorchHostEnvVarName = "R8_PYTORCH_HOST"
  function SchemeFromEnvironment (line 10) | func SchemeFromEnvironment() string {
  function WebHostFromEnvironment (line 18) | func WebHostFromEnvironment() string {
  function APIHostFromEnvironment (line 26) | func APIHostFromEnvironment() string {
  function PytorchHostFromEnvironment (line 34) | func PytorchHostFromEnvironment() string {

FILE: pkg/env/env_test.go
  function TestSchemeFromEnvironment (line 9) | func TestSchemeFromEnvironment(t *testing.T) {
  function TestWebHostFromEnvironment (line 15) | func TestWebHostFromEnvironment(t *testing.T) {

FILE: pkg/errors/errors.go
  constant CodeConfigNotFound (line 4) | CodeConfigNotFound = "CONFIG_NOT_FOUND"
  type CodedError (line 9) | type CodedError interface
  type codedError (line 13) | type codedError struct
    method Error (line 18) | func (e *codedError) Error() string {
    method Code (line 22) | func (e *codedError) Code() string {
  function ConfigNotFound (line 29) | func ConfigNotFound(msg string) error {
  function IsConfigNotFound (line 38) | func IsConfigNotFound(err error) bool {
  function Code (line 43) | func Code(err error) string {

FILE: pkg/global/global.go
  constant DefaultReplicateRegistryHost (line 6) | DefaultReplicateRegistryHost = "r8.im"
  constant ReplicateWebsiteHost (line 7) | ReplicateWebsiteHost         = "replicate.com"
  function getDefaultRegistryHost (line 23) | func getDefaultRegistryHost() string {

FILE: pkg/http/client.go
  constant UserAgentHeader (line 12) | UserAgentHeader = "User-Agent"
  constant BearerHeaderPrefix (line 13) | BearerHeaderPrefix = "Bearer "
  function ProvideHTTPClient (line 15) | func ProvideHTTPClient(ctx context.Context, dockerCommand command.Comman...

FILE: pkg/http/client_test.go
  function TestClientDecoratesUserAgent (line 13) | func TestClientDecoratesUserAgent(t *testing.T) {

FILE: pkg/http/transport.go
  constant AuthorizationHeader (line 8) | AuthorizationHeader = "Authorization"
  type Transport (line 10) | type Transport struct
    method RoundTrip (line 16) | func (t *Transport) RoundTrip(req *http.Request) (*http.Response, erro...

FILE: pkg/http/transport_test.go
  function TestTransportAddsHeaders (line 12) | func TestTransportAddsHeaders(t *testing.T) {
  function TestTransportOnlyAddsHeaderIfMissing (line 33) | func TestTransportOnlyAddsHeaderIfMissing(t *testing.T) {
  function TestTransportSendsErrorWithMissingToken (line 56) | func TestTransportSendsErrorWithMissingToken(t *testing.T) {

FILE: pkg/http/user_agent.go
  function UserAgent (line 10) | func UserAgent() string {

FILE: pkg/http/user_agent_test.go
  function TestUserAgent (line 10) | func TestUserAgent(t *testing.T) {

FILE: pkg/image/build.go
  constant dockerignoreBackupPath (line 37) | dockerignoreBackupPath = ".dockerignore.cog.bak"
  constant weightsManifestPath (line 38) | weightsManifestPath = ".cog/cache/weights_manifest.json"
  constant bundledSchemaFile (line 39) | bundledSchemaFile = ".cog/openapi_schema.json"
  function Build (line 46) | func Build(
  function BuildAddLabelsAndSchemaToImage (line 415) | func BuildAddLabelsAndSchemaToImage(ctx context.Context, dockerClient co...
  constant staticSchemaGenMinSDKVersion (line 440) | staticSchemaGenMinSDKVersion = "0.17.0"
  function canUseStaticSchemaGen (line 448) | func canUseStaticSchemaGen(cfg *config.Config) bool {
  function resolveSDKVersion (line 477) | func resolveSDKVersion(cfg *config.Config) string {
  function generateStaticSchema (line 496) | func generateStaticSchema(cfg *config.Config, dir string) ([]byte, error) {
  function writeAndValidateSchema (line 506) | func writeAndValidateSchema(schemaJSON []byte) error {
  function isGitWorkTree (line 526) | func isGitWorkTree(ctx context.Context, dir string) bool {
  function gitHead (line 538) | func gitHead(ctx context.Context, dir string) (string, error) {
  function gitTag (line 558) | func gitTag(ctx context.Context, dir string) (string, error) {
  function buildWeightsImage (line 578) | func buildWeightsImage(ctx context.Context, dockerClient command.Command...
  function buildRunnerImage (line 599) | func buildRunnerImage(ctx context.Context, dockerClient command.Command,...
  function makeDockerignoreForWeightsImage (line 623) | func makeDockerignoreForWeightsImage() error {
  function writeDockerignore (line 634) | func writeDockerignore(contents string) error {
  function backupDockerignore (line 647) | func backupDockerignore() error {
  function restoreDockerignore (line 660) | func restoreDockerignore() error {
  function checkCompatibleDockerIgnore (line 676) | func checkCompatibleDockerIgnore(dir string) error {

FILE: pkg/image/build_test.go
  function gitRun (line 21) | func gitRun(ctx context.Context, argv []string, t *testing.T) {
  function setupGitWorkTree (line 31) | func setupGitWorkTree(t *testing.T) string {
  function TestIsGitWorkTree (line 52) | func TestIsGitWorkTree(t *testing.T) {
  function TestGitHead (line 60) | func TestGitHead(t *testing.T) {
  function TestGitTag (line 92) | func TestGitTag(t *testing.T) {
  function TestCanUseStaticSchemaGen (line 123) | func TestCanUseStaticSchemaGen(t *testing.T) {

FILE: pkg/image/config.go
  function CogConfigFromManifest (line 14) | func CogConfigFromManifest(ctx context.Context, manifest *image.InspectR...
  function friendlyName (line 32) | func friendlyName(manifest *image.InspectResponse) string {

FILE: pkg/image/openapi_schema.go
  function GenerateOpenAPISchema (line 20) | func GenerateOpenAPISchema(ctx context.Context, dockerClient command.Com...

FILE: pkg/image/pip_freeze.go
  function GeneratePipFreeze (line 14) | func GeneratePipFreeze(ctx context.Context, dockerClient command.Command...

FILE: pkg/model/artifact.go
  type ArtifactType (line 6) | type ArtifactType
    method String (line 16) | func (t ArtifactType) String() string {
  constant ArtifactTypeImage (line 10) | ArtifactTypeImage ArtifactType = iota + 1
  constant ArtifactTypeWeight (line 12) | ArtifactTypeWeight
  type ArtifactSpec (line 30) | type ArtifactSpec interface
  type Artifact (line 37) | type Artifact interface

FILE: pkg/model/artifact_image.go
  type ImageSource (line 14) | type ImageSource
  constant ImageSourceLocal (line 17) | ImageSourceLocal  ImageSource = "local"
  constant ImageSourceRemote (line 18) | ImageSourceRemote ImageSource = "remote"
  constant ImageSourceBuild (line 19) | ImageSourceBuild  ImageSource = "build"
  type Platform (line 23) | type Platform struct
  type ImageSpecOption (line 42) | type ImageSpecOption
  function WithImageSecrets (line 45) | func WithImageSecrets(secrets []string) ImageSpecOption {
  function WithImageNoCache (line 52) | func WithImageNoCache(noCache bool) ImageSpecOption {
  type ImageSpec (line 64) | type ImageSpec struct
    method Type (line 85) | func (s *ImageSpec) Type() ArtifactType { return ArtifactTypeImage }
    method Name (line 88) | func (s *ImageSpec) Name() string { return s.name }
  function NewImageSpec (line 73) | func NewImageSpec(name, imageName string, opts ...ImageSpecOption) *Imag...
  type ImageArtifact (line 98) | type ImageArtifact struct
    method Type (line 121) | func (a *ImageArtifact) Type() ArtifactType { return ArtifactTypeImage }
    method Name (line 124) | func (a *ImageArtifact) Name() string { return a.name }
    method Descriptor (line 127) | func (a *ImageArtifact) Descriptor() v1.Descriptor { return a.descript...
    method IsCogModel (line 134) | func (a *ImageArtifact) IsCogModel() bool {
    method CogVersion (line 143) | func (a *ImageArtifact) CogVersion() string {
    method Config (line 151) | func (a *ImageArtifact) Config() string {
    method OpenAPISchema (line 159) | func (a *ImageArtifact) OpenAPISchema() string {
    method ParsedConfig (line 169) | func (a *ImageArtifact) ParsedConfig() (*config.Config, error) {
    method ParsedOpenAPISchema (line 185) | func (a *ImageArtifact) ParsedOpenAPISchema() (*openapi3.T, error) {
    method ToModel (line 201) | func (a *ImageArtifact) ToModel() (*Model, error) {
  function NewImageArtifact (line 112) | func NewImageArtifact(name string, desc v1.Descriptor, reference string)...

FILE: pkg/model/artifact_image_test.go
  function TestImageSpec_ImplementsArtifactSpec (line 10) | func TestImageSpec_ImplementsArtifactSpec(t *testing.T) {
  function TestImageSpec_Fields (line 19) | func TestImageSpec_Fields(t *testing.T) {
  function TestImageSpec_DefaultFields (line 30) | func TestImageSpec_DefaultFields(t *testing.T) {
  function TestImageArtifact_ImplementsArtifact (line 38) | func TestImageArtifact_ImplementsArtifact(t *testing.T) {
  function TestImageArtifact_Reference (line 52) | func TestImageArtifact_Reference(t *testing.T) {

FILE: pkg/model/artifact_test.go
  function TestArtifactType_String (line 9) | func TestArtifactType_String(t *testing.T) {
  function TestArtifactType_Values (line 27) | func TestArtifactType_Values(t *testing.T) {

FILE: pkg/model/artifact_weight.go
  constant MediaTypeWeightArtifact (line 12) | MediaTypeWeightArtifact = "application/vnd.cog.weight.v1"
  constant MediaTypeWeightConfig (line 14) | MediaTypeWeightConfig = "application/vnd.cog.weight.config.v1+json"
  constant MediaTypeWeightLayer (line 16) | MediaTypeWeightLayer = "application/vnd.cog.weight.layer.v1"
  constant MediaTypeWeightLayerGzip (line 18) | MediaTypeWeightLayerGzip = "application/vnd.cog.weight.layer.v1+gzip"
  constant MediaTypeWeightLayerZstd (line 20) | MediaTypeWeightLayerZstd = "application/vnd.cog.weight.layer.v1+zstd"
  constant AnnotationWeightName (line 25) | AnnotationWeightName             = "vnd.cog.weight.name"
  constant AnnotationWeightDest (line 26) | AnnotationWeightDest             = "vnd.cog.weight.dest"
  constant AnnotationWeightDigestOriginal (line 27) | AnnotationWeightDigestOriginal   = "vnd.cog.weight.digest.original"
  constant AnnotationWeightSizeUncompressed (line 28) | AnnotationWeightSizeUncompressed = "vnd.cog.weight.size.uncompressed"
  type WeightSpec (line 33) | type WeightSpec struct
    method Type (line 51) | func (s *WeightSpec) Type() ArtifactType { return ArtifactTypeWeight }
    method Name (line 54) | func (s *WeightSpec) Name() string { return s.name }
  function NewWeightSpec (line 42) | func NewWeightSpec(name, source, target string) *WeightSpec {
  type WeightArtifact (line 58) | type WeightArtifact struct
    method Type (line 82) | func (a *WeightArtifact) Type() ArtifactType { return ArtifactTypeWeig...
    method Name (line 85) | func (a *WeightArtifact) Name() string { return a.name }
    method Descriptor (line 88) | func (a *WeightArtifact) Descriptor() v1.Descriptor { return a.descrip...
  function NewWeightArtifact (line 71) | func NewWeightArtifact(name string, desc v1.Descriptor, filePath, target...
  type WeightConfig (line 93) | type WeightConfig struct

FILE: pkg/model/artifact_weight_test.go
  function TestWeightSpec_ImplementsArtifactSpec (line 12) | func TestWeightSpec_ImplementsArtifactSpec(t *testing.T) {
  function TestWeightSpec_Fields (line 21) | func TestWeightSpec_Fields(t *testing.T) {
  function TestWeightArtifact_ImplementsArtifact (line 28) | func TestWeightArtifact_ImplementsArtifact(t *testing.T) {
  function TestWeightArtifact_Fields (line 49) | func TestWeightArtifact_Fields(t *testing.T) {
  function TestWeightConfig_JSONRoundTrip (line 68) | func TestWeightConfig_JSONRoundTrip(t *testing.T) {
  function TestWeightMediaTypeConstants (line 100) | func TestWeightMediaTypeConstants(t *testing.T) {

FILE: pkg/model/builder.go
  type Builder (line 7) | type Builder interface

FILE: pkg/model/builder_test.go
  type mockBuilder (line 12) | type mockBuilder struct
    method Build (line 16) | func (m *mockBuilder) Build(ctx context.Context, spec ArtifactSpec) (A...
  function TestBuilderInterface_Satisfiable (line 20) | func TestBuilderInterface_Satisfiable(t *testing.T) {

FILE: pkg/model/errors_test.go
  function TestSentinelErrors (line 11) | func TestSentinelErrors(t *testing.T) {

FILE: pkg/model/factory.go
  type Factory (line 13) | type Factory interface
  type DockerfileFactory (line 24) | type DockerfileFactory struct
    method Name (line 35) | func (f *DockerfileFactory) Name() string {
    method Build (line 40) | func (f *DockerfileFactory) Build(ctx context.Context, src *Source, op...
  function NewDockerfileFactory (line 30) | func NewDockerfileFactory(docker command.Command, registry registry.Clie...
  function defaultFactory (line 80) | func defaultFactory(docker command.Command, registry registry.Client) Fa...

FILE: pkg/model/factory_test.go
  function TestDockerfileFactory_Name (line 12) | func TestDockerfileFactory_Name(t *testing.T) {
  function TestDockerfileFactory_ImplementsInterface (line 21) | func TestDockerfileFactory_ImplementsInterface(t *testing.T) {
  function TestDefaultFactory_ReturnsDockerfileFactory (line 29) | func TestDefaultFactory_ReturnsDockerfileFactory(t *testing.T) {

FILE: pkg/model/format.go
  function OCIIndexEnabled (line 9) | func OCIIndexEnabled() bool {

FILE: pkg/model/format_test.go
  function TestOCIIndexEnabled_Default (line 9) | func TestOCIIndexEnabled_Default(t *testing.T) {
  function TestOCIIndexEnabled_Enabled (line 14) | func TestOCIIndexEnabled_Enabled(t *testing.T) {
  function TestOCIIndexEnabled_OtherValue (line 19) | func TestOCIIndexEnabled_OtherValue(t *testing.T) {

FILE: pkg/model/hash.go
  function hashFile (line 11) | func hashFile(path string) (digest string, size int64, err error) {

FILE: pkg/model/image_builder.go
  type ImageBuilder (line 16) | type ImageBuilder struct
    method Build (line 37) | func (b *ImageBuilder) Build(ctx context.Context, spec ArtifactSpec) (...
  function NewImageBuilder (line 24) | func NewImageBuilder(factory Factory, docker command.Command, source *So...

FILE: pkg/model/image_builder_test.go
  function TestImageBuilder_HappyPath (line 16) | func TestImageBuilder_HappyPath(t *testing.T) {
  function TestImageBuilder_ErrorWrongSpecType (line 74) | func TestImageBuilder_ErrorWrongSpecType(t *testing.T) {
  function TestImageBuilder_ErrorFactoryBuildFails (line 85) | func TestImageBuilder_ErrorFactoryBuildFails(t *testing.T) {
  function TestImageBuilder_ErrorInspectFails (line 102) | func TestImageBuilder_ErrorInspectFails(t *testing.T) {
  function TestImageBuilder_ImplementsBuilderInterface (line 128) | func TestImageBuilder_ImplementsBuilderInterface(t *testing.T) {

FILE: pkg/model/image_pusher.go
  type ImagePusher (line 30) | type ImagePusher struct
    method Push (line 73) | func (p *ImagePusher) Push(ctx context.Context, artifact *ImageArtifac...
    method canOCIPush (line 106) | func (p *ImagePusher) canOCIPush() bool {
    method ociPush (line 112) | func (p *ImagePusher) ociPush(ctx context.Context, imageRef string, op...
    method pushImage (line 158) | func (p *ImagePusher) pushImage(ctx context.Context, imageRef string, ...
    method pushLayers (line 179) | func (p *ImagePusher) pushLayers(ctx context.Context, repo string, img...
    method pushLayer (line 205) | func (p *ImagePusher) pushLayer(ctx context.Context, repo string, laye...
    method pushConfig (line 243) | func (p *ImagePusher) pushConfig(ctx context.Context, repo string, img...
  function newImagePusher (line 36) | func newImagePusher(docker command.Command, reg registry.Client) *ImageP...
  type imagePushOptions (line 44) | type imagePushOptions struct
  type ImagePushOption (line 50) | type ImagePushOption
  function WithProgressFn (line 53) | func WithProgressFn(fn func(PushProgress)) ImagePushOption {
  function WithOnFallback (line 62) | func WithOnFallback(fn func()) ImagePushOption {
  function shouldFallbackToDocker (line 270) | func shouldFallbackToDocker(err error) bool {
  function sanitizeError (line 292) | func sanitizeError(err error) error {
  type configBlobLayer (line 302) | type configBlobLayer struct
    method Digest (line 307) | func (c *configBlobLayer) Digest() (v1.Hash, error) {
    method DiffID (line 314) | func (c *configBlobLayer) DiffID() (v1.Hash, error) {
    method Compressed (line 318) | func (c *configBlobLayer) Compressed() (io.ReadCloser, error) {
    method Uncompressed (line 322) | func (c *configBlobLayer) Uncompressed() (io.ReadCloser, error) {
    method Size (line 326) | func (c *configBlobLayer) Size() (int64, error) {
    method MediaType (line 330) | func (c *configBlobLayer) MediaType() (types.MediaType, error) {

FILE: pkg/model/image_pusher_test.go
  type ociMockClient (line 27) | type ociMockClient struct
    method WriteLayer (line 36) | func (m *ociMockClient) WriteLayer(_ context.Context, opts registry.Wr...
    method PushImage (line 57) | func (m *ociMockClient) PushImage(_ context.Context, ref string, _ v1....
    method Inspect (line 67) | func (m *ociMockClient) Inspect(context.Context, string, *registry.Pla...
    method GetImage (line 70) | func (m *ociMockClient) GetImage(context.Context, string, *registry.Pl...
    method Exists (line 73) | func (m *ociMockClient) Exists(context.Context, string) (bool, error) ...
    method GetDescriptor (line 74) | func (m *ociMockClient) GetDescriptor(context.Context, string) (v1.Des...
    method PushIndex (line 77) | func (m *ociMockClient) PushIndex(context.Context, string, v1.ImageInd...
  function testArtifact (line 80) | func testArtifact(ref string) *ImageArtifact {
  function fakeImageSaveFunc (line 86) | func fakeImageSaveFunc(img v1.Image, tagStr string) func(context.Context...
  function TestImagePusher_Push (line 105) | func TestImagePusher_Push(t *testing.T) {
  function TestImagePusher_PushArtifact (line 242) | func TestImagePusher_PushArtifact(t *testing.T) {
  function TestImagePusher_Fallback (line 301) | func TestImagePusher_Fallback(t *testing.T) {
  function TestShouldFallbackToDocker (line 434) | func TestShouldFallbackToDocker(t *testing.T) {
  function TestSanitizeError (line 463) | func TestSanitizeError(t *testing.T) {
  function TestImagePusher_OnFallback (line 509) | func TestImagePusher_OnFallback(t *testing.T) {
  function TestConfigBlobLayer (line 564) | func TestConfigBlobLayer(t *testing.T) {
  function TestGetPushConcurrency (line 617) | func TestGetPushConcurrency(t *testing.T) {

FILE: pkg/model/image_test.go
  function TestImage_IsCogModel (line 12) | func TestImage_IsCogModel(t *testing.T) {
  function TestImage_CogVersion (line 65) | func TestImage_CogVersion(t *testing.T) {
  function TestImage_Config (line 109) | func TestImage_Config(t *testing.T) {
  function TestImage_OpenAPISchema (line 139) | func TestImage_OpenAPISchema(t *testing.T) {
  function TestImageSource_Values (line 169) | func TestImageSource_Values(t *testing.T) {
  function TestLabelKeys (line 176) | func TestLabelKeys(t *testing.T) {
  function TestImage_ParsedConfig (line 188) | func TestImage_ParsedConfig(t *testing.T) {
  function TestImage_ToModel (line 267) | func TestImage_ToModel(t *testing.T) {
  function TestImage_ParsedOpenAPISchema (line 357) | func TestImage_ParsedOpenAPISchema(t *testing.T) {

FILE: pkg/model/index.go
  type Index (line 5) | type Index struct
  type IndexManifest (line 17) | type IndexManifest struct
  type ManifestType (line 33) | type ManifestType
  constant ManifestTypeImage (line 37) | ManifestTypeImage ManifestType = "image"
  constant ManifestTypeWeights (line 39) | ManifestTypeWeights ManifestType = "weights"
  constant AnnotationReferenceType (line 44) | AnnotationReferenceType   = "vnd.cog.reference.type"
  constant AnnotationReferenceDigest (line 45) | AnnotationReferenceDigest = "vnd.cog.reference.digest"
  constant AnnotationValueWeights (line 51) | AnnotationValueWeights = "weights"
  constant PlatformUnknown (line 57) | PlatformUnknown = "unknown"

FILE: pkg/model/index_factory.go
  type IndexBuilder (line 13) | type IndexBuilder struct
    method SetImageDescriptor (line 33) | func (b *IndexBuilder) SetImageDescriptor(desc v1.Descriptor, platform...
    method AddWeightDescriptor (line 41) | func (b *IndexBuilder) AddWeightDescriptor(desc v1.Descriptor, imageDi...
    method BuildFromDescriptors (line 53) | func (b *IndexBuilder) BuildFromDescriptors() (v1.ImageIndex, error) {
  type weightDescEntry (line 20) | type weightDescEntry struct
  function NewIndexBuilder (line 28) | func NewIndexBuilder() *IndexBuilder {
  type descriptorAppendable (line 106) | type descriptorAppendable struct
    method MediaType (line 110) | func (d *descriptorAppendable) MediaType() (types.MediaType, error) {
    method Digest (line 114) | func (d *descriptorAppendable) Digest() (v1.Hash, error) {
    method Size (line 118) | func (d *descriptorAppendable) Size() (int64, error) {

FILE: pkg/model/index_factory_test.go
  function TestIndexBuilder_BuildFromDescriptors (line 11) | func TestIndexBuilder_BuildFromDescriptors(t *testing.T) {

FILE: pkg/model/index_test.go
  function TestModel_IsBundle (line 11) | func TestModel_IsBundle(t *testing.T) {
  function TestManifestType (line 37) | func TestManifestType(t *testing.T) {

FILE: pkg/model/model.go
  type Model (line 12) | type Model struct
    method HasGPU (line 32) | func (m *Model) HasGPU() bool {
    method SchemaJSON (line 37) | func (m *Model) SchemaJSON() ([]byte, error) {
    method ImageRef (line 45) | func (m *Model) ImageRef() string {
    method IsBundle (line 53) | func (m *Model) IsBundle() bool {
    method GetImageArtifact (line 59) | func (m *Model) GetImageArtifact() *ImageArtifact {
    method WeightArtifacts (line 69) | func (m *Model) WeightArtifacts() []*WeightArtifact {
    method ArtifactsByType (line 80) | func (m *Model) ArtifactsByType(t ArtifactType) []Artifact {

FILE: pkg/model/model_test.go
  function TestModel_HasGPU (line 14) | func TestModel_HasGPU(t *testing.T) {
  function TestModel_SchemaJSON (line 50) | func TestModel_SchemaJSON(t *testing.T) {
  function TestModel_ImageRef (line 88) | func TestModel_ImageRef(t *testing.T) {
  function TestModel_GetImageArtifact (line 123) | func TestModel_GetImageArtifact(t *testing.T) {
  function TestModel_WeightArtifacts (line 175) | func TestModel_WeightArtifacts(t *testing.T) {
  function TestModel_ArtifactsByType (line 210) | func TestModel_ArtifactsByType(t *testing.T) {

FILE: pkg/model/options.go
  type BuildOptions (line 7) | type BuildOptions struct
    method WithDefaults (line 73) | func (o BuildOptions) WithDefaults(src *Source) BuildOptions {

FILE: pkg/model/options_test.go
  function TestBuildOptions_WithDefaults_ImageName (line 11) | func TestBuildOptions_WithDefaults_ImageName(t *testing.T) {
  function TestBuildOptions_WithDefaults_PreservesExplicitImageName (line 24) | func TestBuildOptions_WithDefaults_PreservesExplicitImageName(t *testing...
  function TestBuildOptions_WithDefaults_ProgressOutput (line 36) | func TestBuildOptions_WithDefaults_ProgressOutput(t *testing.T) {
  function TestBuildOptions_WithDefaults_PreservesExplicitProgressOutput (line 48) | func TestBuildOptions_WithDefaults_PreservesExplicitProgressOutput(t *te...
  function TestBuildOptions_WithDefaults_NilBuildConfig (line 60) | func TestBuildOptions_WithDefaults_NilBuildConfig(t *testing.T) {
  function TestBuildOptions_WithDefaults_NilConfig (line 74) | func TestBuildOptions_WithDefaults_NilConfig(t *testing.T) {
  function TestBuildOptions_AllFieldsPreserved (line 88) | func TestBuildOptions_AllFieldsPreserved(t *testing.T) {
  function TestBuildOptions_WeightsLockPath (line 129) | func TestBuildOptions_WeightsLockPath(t *testing.T) {

FILE: pkg/model/push_helpers.go
  constant DefaultPushConcurrency (line 17) | DefaultPushConcurrency = 5
  constant envPushConcurrency (line 20) | envPushConcurrency = "COG_PUSH_CONCURRENCY"
  function GetPushConcurrency (line 25) | func GetPushConcurrency() int {
  type PushProgress (line 36) | type PushProgress struct
  function writeLayerWithProgress (line 51) | func writeLayerWithProgress(ctx context.Context, reg registry.Client, op...

FILE: pkg/model/pusher.go
  type PushOptions (line 17) | type PushOptions struct
  type BundlePusher (line 50) | type BundlePusher struct
    method Push (line 70) | func (p *BundlePusher) Push(ctx context.Context, m *Model, opts PushOp...
    method pushWeights (line 142) | func (p *BundlePusher) pushWeights(ctx context.Context, repo string, w...
  function NewBundlePusher (line 60) | func NewBundlePusher(docker command.Command, reg registry.Client) *Bundl...
  function repoFromReference (line 170) | func repoFromReference(ref string) string {

FILE: pkg/model/pusher_test.go
  function TestBundlePusher_Push (line 22) | func TestBundlePusher_Push(t *testing.T) {
  function TestResolver_Push (line 420) | func TestResolver_Push(t *testing.T) {
  function TestPushOptions (line 537) | func TestPushOptions(t *testing.T) {
  function TestRepoFromReference (line 558) | func TestRepoFromReference(t *testing.T) {

FILE: pkg/model/ref.go
  type ParseOption (line 12) | type ParseOption
  type parseOptions (line 14) | type parseOptions struct
  function Insecure (line 21) | func Insecure() ParseOption {
  function WithDefaultRegistry (line 29) | func WithDefaultRegistry(registry string) ParseOption {
  function WithDefaultTag (line 37) | func WithDefaultTag(tag string) ParseOption {
  type ParsedRef (line 44) | type ParsedRef struct
    method String (line 71) | func (p *ParsedRef) String() string {
    method Registry (line 76) | func (p *ParsedRef) Registry() string {
    method Repository (line 81) | func (p *ParsedRef) Repository() string {
    method Tag (line 86) | func (p *ParsedRef) Tag() string {
    method Digest (line 94) | func (p *ParsedRef) Digest() string {
    method IsTag (line 102) | func (p *ParsedRef) IsTag() bool {
    method IsDigest (line 108) | func (p *ParsedRef) IsDigest() bool {
    method IsReplicate (line 114) | func (p *ParsedRef) IsReplicate() bool {
  function ParseRef (line 53) | func ParseRef(ref string, opts ...ParseOption) (*ParsedRef, error) {

FILE: pkg/model/ref_test.go
  function TestParseRef (line 9) | func TestParseRef(t *testing.T) {
  function TestParsedRef_IsTag (line 146) | func TestParsedRef_IsTag(t *testing.T) {
  function TestParsedRef_String (line 158) | func TestParsedRef_String(t *testing.T) {
  function TestParseOptions (line 190) | func TestParseOptions(t *testing.T) {

FILE: pkg/model/ref_types.go
  type Ref (line 9) | type Ref interface
  method Resolve (line 17) | func (r *Resolver) Resolve(ctx context.Context, ref Ref) (*Model, error) {
  type TagRef (line 28) | type TagRef struct
    method resolve (line 42) | func (t *TagRef) resolve(ctx context.Context, r *Resolver) (*Model, er...
  function FromTag (line 34) | func FromTag(ref string) (*TagRef, error) {
  type LocalRef (line 53) | type LocalRef struct
    method resolve (line 67) | func (l *LocalRef) resolve(ctx context.Context, r *Resolver) (*Model, ...
  function FromLocal (line 59) | func FromLocal(ref string) (*LocalRef, error) {
  type RemoteRef (line 77) | type RemoteRef struct
    method resolve (line 91) | func (rr *RemoteRef) resolve(ctx context.Context, r *Resolver) (*Model...
  function FromRemote (line 83) | func FromRemote(ref string) (*RemoteRef, error) {
  type BuildRef (line 101) | type BuildRef struct
    method resolve (line 113) | func (b *BuildRef) resolve(ctx context.Context, r *Resolver) (*Model, ...
  function FromBuild (line 109) | func FromBuild(src *Source, opts BuildOptions) *BuildRef {

FILE: pkg/model/ref_types_test.go
  function TestFromTag_ValidRef (line 21) | func TestFromTag_ValidRef(t *testing.T) {
  function TestFromTag_ValidRefWithRegistry (line 30) | func TestFromTag_ValidRefWithRegistry(t *testing.T) {
  function TestFromTag_InvalidRef (line 39) | func TestFromTag_InvalidRef(t *testing.T) {
  function TestFromLocal_ValidRef (line 51) | func TestFromLocal_ValidRef(t *testing.T) {
  function TestFromLocal_InvalidRef (line 60) | func TestFromLocal_InvalidRef(t *testing.T) {
  function TestFromRemote_ValidRef (line 72) | func TestFromRemote_ValidRef(t *testing.T) {
  function TestFromRemote_InvalidRef (line 81) | func TestFromRemote_InvalidRef(t *testing.T) {
  function TestFromBuild (line 93) | func TestFromBuild(t *testing.T) {
  function TestFromBuild_NilSource (line 111) | func TestFromBuild_NilSource(t *testing.T) {
  function TestTagRef_Resolve_Success (line 123) | func TestTagRef_Resolve_Success(t *testing.T) {
  function TestTagRef_Resolve_FallsBackToLocal (line 152) | func TestTagRef_Resolve_FallsBackToLocal(t *testing.T) {
  function TestLocalRef_Resolve_Success (line 196) | func TestLocalRef_Resolve_Success(t *testing.T) {
  function TestLocalRef_Resolve_NotFound (line 226) | func TestLocalRef_Resolve_NotFound(t *testing.T) {
  function TestRemoteRef_Resolve_Success (line 253) | func TestRemoteRef_Resolve_Success(t *testing.T) {
  function TestRemoteRef_Resolve_NotFound (line 284) | func TestRemoteRef_Resolve_NotFound(t *testing.T) {
  function TestBuildRef_Resolve_Success (line 306) | func TestBuildRef_Resolve_Success(t *testing.T) {
  function TestBuildRef_Resolve_BuildError (line 350) | func TestBuildRef_Resolve_BuildError(t *testing.T) {
  function TestResolver_Resolve_DispatchesCorrectly (line 376) | func TestResolver_Resolve_DispatchesCorrectly(t *testing.T) {

FILE: pkg/model/resolver.go
  type Option (line 18) | type Option
  type options (line 20) | type options struct
  function defaultOptions (line 27) | func defaultOptions() *options {
  function LocalOnly (line 33) | func LocalOnly() Option {
  function RemoteOnly (line 43) | func RemoteOnly() Option {
  function PreferLocal (line 52) | func PreferLocal() Option {
  function PreferRemote (line 62) | func PreferRemote() Option {
  function WithPlatform (line 71) | func WithPlatform(p *registry.Platform) Option {
  type Resolver (line 78) | type Resolver struct
    method WithFactory (line 96) | func (r *Resolver) WithFactory(f Factory) *Resolver {
    method Inspect (line 105) | func (r *Resolver) Inspect(ctx context.Context, ref *ParsedRef, opts ....
    method InspectByID (line 144) | func (r *Resolver) InspectByID(ctx context.Context, id string) (*Model...
    method Pull (line 169) | func (r *Resolver) Pull(ctx context.Context, ref *ParsedRef, opts ...O...
    method Build (line 213) | func (r *Resolver) Build(ctx context.Context, src *Source, opts BuildO...
    method Push (line 272) | func (r *Resolver) Push(ctx context.Context, m *Model, opts PushOption...
    method loadLocal (line 294) | func (r *Resolver) loadLocal(ctx context.Context, ref *ParsedRef) (*Mo...
    method loadRemote (line 306) | func (r *Resolver) loadRemote(ctx context.Context, ref *ParsedRef, pla...
    method modelFromImage (line 319) | func (r *Resolver) modelFromImage(img *ImageArtifact, cfg *config.Conf...
    method modelFromInspect (line 335) | func (r *Resolver) modelFromInspect(ref *ParsedRef, resp *image.Inspec...
    method modelFromManifest (line 352) | func (r *Resolver) modelFromManifest(ref *ParsedRef, manifest *registr...
    method modelFromIndex (line 375) | func (r *Resolver) modelFromIndex(ref *ParsedRef, manifest *registry.M...
  function NewResolver (line 86) | func NewResolver(docker command.Command, reg registry.Client) *Resolver {
  function isOCIIndex (line 435) | func isOCIIndex(mr *registry.ManifestResult) bool {
  function findWeightsManifest (line 441) | func findWeightsManifest(manifests []registry.PlatformManifest) *registr...
  function findImageManifest (line 454) | func findImageManifest(manifests []registry.PlatformManifest, platform *...
  function isNotFoundError (line 474) | func isNotFoundError(err error) bool {

FILE: pkg/model/resolver_test.go
  type mockDocker (line 24) | type mockDocker struct
    method Inspect (line 31) | func (m *mockDocker) Inspect(ctx context.Context, ref string) (*image....
    method Pull (line 38) | func (m *mockDocker) Pull(ctx context.Context, ref string, force bool)...
    method Push (line 45) | func (m *mockDocker) Push(ctx context.Context, ref string) error {
    method LoadUserInformation (line 52) | func (m *mockDocker) LoadUserInformation(ctx context.Context, registry...
    method ImageExists (line 56) | func (m *mockDocker) ImageExists(ctx context.Context, ref string) (boo...
    method ContainerLogs (line 60) | func (m *mockDocker) ContainerLogs(ctx context.Context, containerID st...
    method ContainerInspect (line 64) | func (m *mockDocker) ContainerInspect(ctx context.Context, id string) ...
    method ContainerStop (line 68) | func (m *mockDocker) ContainerStop(ctx context.Context, containerID st...
    method RemoveImage (line 72) | func (m *mockDocker) RemoveImage(ctx context.Context, ref string) error {
    method ImageBuild (line 76) | func (m *mockDocker) ImageBuild(ctx context.Context, options command.I...
    method Run (line 80) | func (m *mockDocker) Run(ctx context.Context, options command.RunOptio...
    method ContainerStart (line 84) | func (m *mockDocker) ContainerStart(ctx context.Context, options comma...
    method ImageSave (line 88) | func (m *mockDocker) ImageSave(ctx context.Context, imageRef string) (...
  type mockRegistry (line 96) | type mockRegistry struct
    method Inspect (line 105) | func (m *mockRegistry) Inspect(ctx context.Context, ref string, platfo...
    method GetImage (line 112) | func (m *mockRegistry) GetImage(ctx context.Context, ref string, platf...
    method GetDescriptor (line 119) | func (m *mockRegistry) GetDescriptor(ctx context.Context, ref string) ...
    method Exists (line 126) | func (m *mockRegistry) Exists(ctx context.Context, ref string) (bool, ...
    method PushImage (line 130) | func (m *mockRegistry) PushImage(ctx context.Context, ref string, img ...
    method PushIndex (line 137) | func (m *mockRegistry) PushIndex(ctx context.Context, ref string, idx ...
    method WriteLayer (line 144) | func (m *mockRegistry) WriteLayer(ctx context.Context, opts registry.W...
  type mockFactory (line 153) | type mockFactory struct
    method Build (line 158) | func (f *mockFactory) Build(ctx context.Context, src *Source, opts Bui...
    method Name (line 165) | func (f *mockFactory) Name() string {
  function TestNewResolver (line 169) | func TestNewResolver(t *testing.T) {
  function TestResolver_WithFactory (line 179) | func TestResolver_WithFactory(t *testing.T) {
  function TestResolver_Inspect_LocalOnly_Found (line 194) | func TestResolver_Inspect_LocalOnly_Found(t *testing.T) {
  function TestResolver_Inspect_LocalOnly_NotFound (line 227) | func TestResolver_Inspect_LocalOnly_NotFound(t *testing.T) {
  function TestResolver_Inspect_RemoteOnly_Found (line 250) | func TestResolver_Inspect_RemoteOnly_Found(t *testing.T) {
  function TestResolver_Inspect_RemoteOnly_NotFound (line 283) | func TestResolver_Inspect_RemoteOnly_NotFound(t *testing.T) {
  function TestResolver_Inspect_RemoteOnly_NotCogModel (line 301) | func TestResolver_Inspect_RemoteOnly_NotCogModel(t *testing.T) {
  function TestResolver_Inspect_PreferLocal_FoundLocally (line 327) | func TestResolver_Inspect_PreferLocal_FoundLocally(t *testing.T) {
  function TestResolver_Inspect_PreferLocal_Fallback (line 367) | func TestResolver_Inspect_PreferLocal_Fallback(t *testing.T) {
  function TestResolver_Inspect_PreferLocal_NoFallbackOnRealError (line 402) | func TestResolver_Inspect_PreferLocal_NoFallbackOnRealError(t *testing.T) {
  function TestResolver_Inspect_PreferRemote_FoundRemotely (line 426) | func TestResolver_Inspect_PreferRemote_FoundRemotely(t *testing.T) {
  function TestResolver_Inspect_PreferRemote_Fallback (line 461) | func TestResolver_Inspect_PreferRemote_Fallback(t *testing.T) {
  function TestResolver_Inspect_PreferRemote_NoFallbackOnRealError (line 501) | func TestResolver_Inspect_PreferRemote_NoFallbackOnRealError(t *testing....
  function TestResolver_Inspect_WithPlatform (line 525) | func TestResolver_Inspect_WithPlatform(t *testing.T) {
  function TestResolver_Inspect_ParsesConfigFromLabels (line 555) | func TestResolver_Inspect_ParsesConfigFromLabels(t *testing.T) {
  function TestResolver_Inspect_InvalidConfigJSON (line 587) | func TestResolver_Inspect_InvalidConfigJSON(t *testing.T) {
  function TestResolver_Inspect_NoConfigLabel_ReturnsErrNotCogModel (line 615) | func TestResolver_Inspect_NoConfigLabel_ReturnsErrNotCogModel(t *testing...
  function TestResolver_Inspect_NotCogModel (line 644) | func TestResolver_Inspect_NotCogModel(t *testing.T) {
  function TestResolver_InspectByID_Found (line 673) | func TestResolver_InspectByID_Found(t *testing.T) {
  function TestResolver_InspectByID_FullSHA (line 707) | func TestResolver_InspectByID_FullSHA(t *testing.T) {
  function TestResolver_InspectByID_NotCogModel (line 736) | func TestResolver_InspectByID_NotCogModel(t *testing.T) {
  function TestResolver_InspectByID_NotFound (line 762) | func TestResolver_InspectByID_NotFound(t *testing.T) {
  function TestResolver_Pull_AlreadyLocal (line 781) | func TestResolver_Pull_AlreadyLocal(t *testing.T) {
  function TestResolver_Pull_NotLocal_PullsAndReturns (line 817) | func TestResolver_Pull_NotLocal_PullsAndReturns(t *testing.T) {
  function TestResolver_Pull_NotCogModel (line 871) | func TestResolver_Pull_NotCogModel(t *testing.T) {
  function TestResolver_Pull_LocalOnly_NotFound (line 919) | func TestResolver_Pull_LocalOnly_NotFound(t *testing.T) {
  function TestResolver_Pull_PullFails (line 940) | func TestResolver_Pull_PullFails(t *testing.T) {
  function TestResolver_Pull_LocalInspectRealError (line 960) | func TestResolver_Pull_LocalInspectRealError(t *testing.T) {
  function TestResolver_Build_NoWeightsManifestWithoutWeights (line 985) | func TestResolver_Build_NoWeightsManifestWithoutWeights(t *testing.T) {
  function TestResolver_Build_PopulatesArtifacts (line 1022) | func TestResolver_Build_PopulatesArtifacts(t *testing.T) {
  function TestResolver_Build_PopulatesWeightArtifacts (line 1075) | func TestResolver_Build_PopulatesWeightArtifacts(t *testing.T) {
  function TestResolver_Build_WithWeightsLoadsManifest (line 1153) | func TestResolver_Build_WithWeightsLoadsManifest(t *testing.T) {
  function TestIndexDetectionHelpers (line 1215) | func TestIndexDetectionHelpers(t *testing.T) {
  function TestIsNotFoundError (line 1301) | func TestIsNotFoundError(t *testing.T) {

FILE: pkg/model/source.go
  type Source (line 13) | type Source struct
    method ArtifactSpecs (line 77) | func (s *Source) ArtifactSpecs() []ArtifactSpec {
  function NewSource (line 23) | func NewSource(configPath string) (*Source, error) {
  function NewSourceFromConfig (line 66) | func NewSourceFromConfig(cfg *config.Config, projectDir string) *Source {

FILE: pkg/model/source_test.go
  function TestNewSourceFromConfig (line 11) | func TestNewSourceFromConfig(t *testing.T) {
  function TestNewSourceFromConfig_NilConfig (line 27) | func TestNewSourceFromConfig_NilConfig(t *testing.T) {
  function TestSource_ArtifactSpecs_NoWeights (line 35) | func TestSource_ArtifactSpecs_NoWeights(t *testing.T) {
  function TestSource_ArtifactSpecs_WithWeights (line 57) | func TestSource_ArtifactSpecs_WithWeights(t *testing.T) {
  function TestSource_ArtifactSpecs_EmptyImageName (line 92) | func TestSource_ArtifactSpecs_EmptyImageName(t *testing.T) {
  function TestSource_ArtifactSpecs_NilConfig (line 106) | func TestSource_ArtifactSpecs_NilConfig(t *testing.T) {

FILE: pkg/model/weight_builder.go
  type WeightBuilder (line 15) | type WeightBuilder struct
    method Build (line 34) | func (b *WeightBuilder) Build(ctx context.Context, spec ArtifactSpec) ...
    method findCachedEntry (line 107) | func (b *WeightBuilder) findCachedEntry(name string, fileSize int64) *...
    method updateLockfile (line 125) | func (b *WeightBuilder) updateLockfile(ws *WeightSpec, digest string, ...
  function NewWeightBuilder (line 23) | func NewWeightBuilder(source *Source, cogVersion, lockPath string) *Weig...

FILE: pkg/model/weight_builder_test.go
  function TestWeightBuilder_HappyPath (line 16) | func TestWeightBuilder_HappyPath(t *testing.T) {
  function TestWeightBuilder_WritesLockfile (line 71) | func TestWeightBuilder_WritesLockfile(t *testing.T) {
  function TestWeightBuilder_UpdatesExistingLockfile (line 111) | func TestWeightBuilder_UpdatesExistingLockfile(t *testing.T) {
  function TestWeightBuilder_CacheHit (line 157) | func TestWeightBuilder_CacheHit(t *testing.T) {
  function TestWeightBuilder_CacheMiss_SizeChanged (line 199) | func TestWeightBuilder_CacheMiss_SizeChanged(t *testing.T) {
  function TestWeightBuilder_ErrorWrongSpecType (line 237) | func TestWeightBuilder_ErrorWrongSpecType(t *testing.T) {
  function TestWeightBuilder_ErrorFileNotFound (line 250) | func TestWeightBuilder_ErrorFileNotFound(t *testing.T) {
  function TestWeightBuilder_ErrorContextCancelled (line 262) | func TestWeightBuilder_ErrorContextCancelled(t *testing.T) {
  function TestWeightBuilder_ImplementsBuilderInterface (line 280) | func TestWeightBuilder_ImplementsBuilderInterface(t *testing.T) {

FILE: pkg/model/weight_pusher.go
  type WeightPushOptions (line 24) | type WeightPushOptions struct
  type WeightRetryEvent (line 33) | type WeightRetryEvent struct
  type WeightPushResult (line 47) | type WeightPushResult struct
  type WeightPusher (line 58) | type WeightPusher struct
    method Push (line 71) | func (p *WeightPusher) Push(ctx context.Context, repo string, artifact...
  function NewWeightPusher (line 63) | func NewWeightPusher(reg registry.Client) *WeightPusher {
  function buildWeightImage (line 168) | func buildWeightImage(artifact *WeightArtifact) (v1.Image, error) {
  function descriptorFromImage (line 204) | func descriptorFromImage(img v1.Image) (v1.Descriptor, error) {
  type weightOCIManifest (line 225) | type weightOCIManifest struct
  type weightManifestImage (line 241) | type weightManifestImage struct
    method RawConfigFile (line 250) | func (w *weightManifestImage) RawConfigFile() ([]byte, error) {
    method Digest (line 255) | func (w *weightManifestImage) Digest() (v1.Hash, error) {
    method ArtifactType (line 268) | func (w *weightManifestImage) ArtifactType() (string, error) {
    method Manifest (line 273) | func (w *weightManifestImage) Manifest() (*v1.Manifest, error) {
    method RawManifest (line 297) | func (w *weightManifestImage) RawManifest() ([]byte, error) {
  constant weightTagPrefix (line 325) | weightTagPrefix = "weights-"
  function WeightTag (line 331) | func WeightTag(name, digest string) string {

FILE: pkg/model/weight_pusher_test.go
  function TestWeightPusher_Push_ReturnsErrorForNilArtifact (line 20) | func TestWeightPusher_Push_ReturnsErrorForNilArtifact(t *testing.T) {
  function TestWeightPusher_Push_ReturnsErrorForMissingFile (line 30) | func TestWeightPusher_Push_ReturnsErrorForMissingFile(t *testing.T) {
  function TestWeightPusher_Push_PushesCorrectOCIArtifact (line 48) | func TestWeightPusher_Push_PushesCorrectOCIArtifact(t *testing.T) {
  function TestWeightPusher_Push_PropagatesPushError (line 125) | func TestWeightPusher_Push_PropagatesPushError(t *testing.T) {
  function TestWeightPusher_Push_RawManifestContainsArtifactType (line 152) | func TestWeightPusher_Push_RawManifestContainsArtifactType(t *testing.T) {
  function TestWeightPusher_Push_ReturnsErrorForEmptyRepo (line 202) | func TestWeightPusher_Push_ReturnsErrorForEmptyRepo(t *testing.T) {
  function TestWeightPusher_Push_ReportsProgressViaWriteLayer (line 224) | func TestWeightPusher_Push_ReportsProgressViaWriteLayer(t *testing.T) {
  function TestWeightPusher_Push_ForwardsRetryCallback (line 282) | func TestWeightPusher_Push_ForwardsRetryCallback(t *testing.T) {
  function TestWeightPusher_Push_WriteLayerErrorReported (line 332) | func TestWeightPusher_Push_WriteLayerErrorReported(t *testing.T) {
  function TestWeightPusher_Push_PropagatesContextCancellation (line 359) | func TestWeightPusher_Push_PropagatesContextCancellation(t *testing.T) {

FILE: pkg/model/weights.go
  type WeightFile (line 5) | type WeightFile struct

FILE: pkg/model/weights_lock.go
  constant WeightsLockFilename (line 12) | WeightsLockFilename = "weights.lock"
  type WeightsLock (line 16) | type WeightsLock struct
    method Save (line 44) | func (wl *WeightsLock) Save(path string) error {
  function ParseWeightsLock (line 26) | func ParseWeightsLock(data []byte) (*WeightsLock, error) {
  function LoadWeightsLock (line 35) | func LoadWeightsLock(path string) (*WeightsLock, error) {

FILE: pkg/model/weights_lock_test.go
  function TestWeightsLock (line 13) | func TestWeightsLock(t *testing.T) {

FILE: pkg/model/weights_test.go
  function TestWeightFile (line 9) | func TestWeightFile(t *testing.T) {

FILE: pkg/path/path.go
  function TrimExt (line 9) | func TrimExt(s string) string {
  function IsExtInteger (line 13) | func IsExtInteger(ext string) bool {

FILE: pkg/path/path_test.go
  function TestTrimExt (line 9) | func TestTrimExt(t *testing.T) {
  function TestIsExtInteger (line 14) | func TestIsExtInteger(t *testing.T) {

FILE: pkg/predict/api.go
  type HelpResponse (line 5) | type HelpResponse struct

FILE: pkg/predict/input.go
  type Input (line 19) | type Input struct
  type Inputs (line 28) | type Inputs
    method toMap (line 149) | func (inputs *Inputs) toMap() (map[string]any, error) {
  function NewInputs (line 30) | func NewInputs(keyVals map[string][]string, schema *openapi3.T) (Inputs,...
  function NewInputsForMode (line 34) | func NewInputsForMode(keyVals map[string][]string, schema *openapi3.T, i...
  function NewInputsWithBaseDir (line 136) | func NewInputsWithBaseDir(keyVals map[string]string, baseDir string) Inp...
  function fileToDataURL (line 192) | func fileToDataURL(filePath string) (string, error) {
  function resolveSchemaType (line 212) | func resolveSchemaType(s *openapi3.Schema) *openapi3.Schema {

FILE: pkg/predict/predictor.go
  type status (line 21) | type status
  type HealthcheckResponse (line 23) | type HealthcheckResponse struct
  type RequestContext (line 27) | type RequestContext struct
  type Request (line 31) | type Request struct
  type Response (line 37) | type Response struct
  type ValidationErrorResponse (line 43) | type ValidationErrorResponse struct
  type Predictor (line 51) | type Predictor struct
    method Start (line 75) | func (p *Predictor) Start(ctx context.Context, logsWriter io.Writer, t...
    method waitForContainerReady (line 103) | func (p *Predictor) waitForContainerReady(ctx context.Context, timeout...
    method Stop (line 165) | func (p *Predictor) Stop(ctx context.Context) error {
    method Predict (line 169) | func (p *Predictor) Predict(inputs Inputs, context RequestContext) (*R...
    method GetSchema (line 219) | func (p *Predictor) GetSchema() (*openapi3.T, error) {
    method endpoint (line 235) | func (p *Predictor) endpoint() string {
    method url (line 242) | func (p *Predictor) url() string {
    method buildInputValidationErrorMessage (line 246) | func (p *Predictor) buildInputValidationErrorMessage(errorResponse *Va...
  function NewPredictor (line 61) | func NewPredictor(ctx context.Context, runOptions command.RunOptions, is...

FILE: pkg/provider/generic/generic.go
  type GenericProvider (line 18) | type GenericProvider struct
    method Name (line 25) | func (p *GenericProvider) Name() string {
    method MatchesRegistry (line 29) | func (p *Ge

[
  {
    "path": ".all-contributorsrc",
    "chars": 10850,
    "preview": "{\n  \"projectName\": \"cog\",\n  \"projectOwner\": \"replicate\",\n  \"repoType\": \"github\",\n  \"repoHost\": \"https://github.com\",\n  \""
  },
  {
    "path": ".git_archival.txt",
    "chars": 102,
    "preview": "node: $Format:%H$\nnode-date: $Format:%cI$\ndescribe-name: $Format:%(describe:tags=true,match=*[0-9]*)$\n"
  },
  {
    "path": ".gitattributes",
    "chars": 99,
    "preview": ".git_archival.txt export-subst\nMakefile -linguist-detectable\ndocs/llms.txt linguist-generated=true\n"
  },
  {
    "path": ".github/CODEOWNERS",
    "chars": 65,
    "preview": "# Default code owners for the entire repository\n* @replicate/cog\n"
  },
  {
    "path": ".github/dependabot.yml",
    "chars": 434,
    "preview": "version: 2\nupdates:\n  - package-ecosystem: \"gomod\"\n    directory: \"/\"\n    schedule:\n      interval: \"weekly\"\n  - package"
  },
  {
    "path": ".github/workflows/README.md",
    "chars": 12207,
    "preview": "# CI Architecture\n\nThis document describes the CI/CD architecture for the Cog repository.\n\n## Design Principles\n\n1. **Si"
  },
  {
    "path": ".github/workflows/ci.yaml",
    "chars": 35051,
    "preview": "name: CI\n\non:\n  merge_group:\n  push:\n    branches: [main]\n  pull_request:\n  workflow_dispatch:\n\n# Cancel in-progress run"
  },
  {
    "path": ".github/workflows/codeql.yml",
    "chars": 2732,
    "preview": "# For most projects, this workflow file will not need changing; you simply need\n# to commit it to your repository.\n#\n# Y"
  },
  {
    "path": ".github/workflows/docs.yaml",
    "chars": 684,
    "preview": "name: Deploy docs\n\non:\n  push:\n    branches:\n      - main\n\njobs:\n  deploy:\n    runs-on: ubuntu-latest\n    steps:\n      -"
  },
  {
    "path": ".github/workflows/release-build.yaml",
    "chars": 9152,
    "preview": "---\nname: Release Build\n\n# Triggered on version tags to build release artifacts and create a GitHub release.\n#\n# THREE R"
  },
  {
    "path": ".github/workflows/release-publish.yaml",
    "chars": 8262,
    "preview": "---\nname: Release Publish\n\n# Publishes packages to PyPI and crates.io when a release is published.\n#\n# For stable releas"
  },
  {
    "path": ".gitignore",
    "chars": 881,
    "preview": "/cog\n.ipynb_checkpoints/\nUntitled*.ipynb\n__pycache__\n.cog\n.hypothesis/\nbuild\ndist\n*.egg-info\npkg/wheels/*.whl\n# Used by "
  },
  {
    "path": ".golangci.yaml",
    "chars": 2349,
    "preview": "version: \"2\"\n\nrun:\n  timeout: 20m\n\noutput:\n  # Show all issues, not just first few per linter\n  show-stats: true\n\nlinter"
  },
  {
    "path": ".goreleaser.yaml",
    "chars": 2480,
    "preview": "version: 2\nbefore:\n  hooks:\n    - go mod tidy\ndist: ./dist/go\nenv:\n  # CGo required for go-tree-sitter (static Python sc"
  },
  {
    "path": ".mockery.yml",
    "chars": 542,
    "preview": "all: false\ndir: '{{.InterfaceDir}}'\nfilename: mocks_test.go\nforce-file-write: true\nformatter: goimports\nlog-level: info\n"
  },
  {
    "path": ".vscode/extensions.json",
    "chars": 129,
    "preview": "{\n  \"recommendations\": [\n    \"charliermarsh.ruff\",\n    \"golang.go\",\n    \"ms-python.python\",\n    \"ms-python.vscode-pylanc"
  },
  {
    "path": ".vscode/settings.json",
    "chars": 1079,
    "preview": "{\n  \"editor.formatOnSave\": true,\n  \"editor.formatOnType\": true,\n  \"editor.formatOnPaste\": true,\n  \"editor.renderControlC"
  },
  {
    "path": "AGENTS.md",
    "chars": 15093,
    "preview": "# AGENTS.md\n\nThis file provides guidance to coding agents when working with code in this repository.\n\n## Project Overvie"
  },
  {
    "path": "CONTRIBUTING.md",
    "chars": 10044,
    "preview": "# Contributing guide\n\n## Development environment\n\nDevelopment tasks are managed with [mise](https://mise.jdx.dev/). Run "
  },
  {
    "path": "DESIGN.md",
    "chars": 4951,
    "preview": "# Design\n\n## Background\n\nCog came from Andreas's experience at Spotify and Ben's experience at Docker.\n\nAt Spotify, Andr"
  },
  {
    "path": "LICENSE",
    "chars": 11347,
    "preview": "\n                                 Apache License\n                           Version 2.0, January 2004\n                  "
  },
  {
    "path": "Makefile",
    "chars": 3637,
    "preview": "# Makefile - Shim that delegates to mise tasks\n#\n# This Makefile provides backward compatibility for common targets.\n# A"
  },
  {
    "path": "README.md",
    "chars": 24714,
    "preview": "# Cog: Containers for machine learning\n\nCog is an open-source tool that lets you package machine learning models in a st"
  },
  {
    "path": "architecture/00-overview.md",
    "chars": 4736,
    "preview": "# Cog Architecture Overview\n\nCog packages machine learning models into production-ready OCI images.\n\n## The Big Picture\n"
  },
  {
    "path": "architecture/01-model-source.md",
    "chars": 8685,
    "preview": "# Model Source\n\nThis document covers what a model author provides to Cog and the primitives they work with.\n\n## What Use"
  },
  {
    "path": "architecture/02-schema.md",
    "chars": 13636,
    "preview": "# Schema\n\nThe schema is an **OpenAPI 3.0.2 specification** that describes a model's interface. It's the contract between"
  },
  {
    "path": "architecture/05-build-system.md",
    "chars": 8692,
    "preview": "# Build System\n\nThe build system transforms [Model Source](./01-model-source.md) (cog.yaml + predict.py + weights) into "
  },
  {
    "path": "architecture/06-cli.md",
    "chars": 6371,
    "preview": "# CLI\n\nThe Cog CLI is a Go binary that provides commands for the full model lifecycle: development, building, testing, a"
  },
  {
    "path": "architecture/ffi/03-prediction-api.md",
    "chars": 10594,
    "preview": "# Prediction API (FFI/Rust)\n\nThe FFI runtime implements the same Prediction API as the legacy runtime, using the same en"
  },
  {
    "path": "architecture/ffi/04-container-runtime.md",
    "chars": 18198,
    "preview": "# Container Runtime (FFI/Rust)\n\nThis document covers the FFI runtime implementation using Rust with PyO3 bindings. This "
  },
  {
    "path": "architecture/ffi/README.md",
    "chars": 1805,
    "preview": "# FFI Runtime (Rust + PyO3)\n\nThis directory documents the next-generation Cog runtime implementation using Rust with PyO"
  },
  {
    "path": "architecture/legacy/03-prediction-api.md",
    "chars": 8574,
    "preview": "# Prediction API\n\nThe Prediction API is the HTTP interface for running model inference. It uses a fixed **envelope forma"
  },
  {
    "path": "architecture/legacy/04-container-runtime.md",
    "chars": 8646,
    "preview": "# Container Runtime\n\nThis document covers what happens when a Cog container runs. It's where the [Model Source](./01-mod"
  },
  {
    "path": "architecture/legacy/README.md",
    "chars": 1026,
    "preview": "# Legacy Python Runtime (FastAPI)\n\nThis directory documents the original Cog runtime implementation using Python's FastA"
  },
  {
    "path": "cmd/cog/cog.go",
    "chars": 275,
    "preview": "package main\n\nimport (\n\t\"github.com/replicate/cog/pkg/cli\"\n\t\"github.com/replicate/cog/pkg/util/console\"\n)\n\nfunc main() {"
  },
  {
    "path": "crates/.gitignore",
    "chars": 9,
    "preview": "/target/\n"
  },
  {
    "path": "crates/Cargo.toml",
    "chars": 1200,
    "preview": "[workspace]\nresolver = \"2\"\nmembers = [\"coglet\", \"coglet-python\"]\n\n[workspace.package]\nversion = \"0.17.0-rc.2\"\nedition = "
  },
  {
    "path": "crates/README.md",
    "chars": 12597,
    "preview": "# Coglet: Rust Runtime for Cog\n\nCoglet is the Rust-based prediction server that powers Cog's subprocess isolation model."
  },
  {
    "path": "crates/coglet/Cargo.toml",
    "chars": 1336,
    "preview": "[package]\nname = \"coglet\"\ndescription = \"High-performance prediction server for Cog ML models\"\nversion.workspace = true\n"
  },
  {
    "path": "crates/coglet/README.md",
    "chars": 8805,
    "preview": "# coglet\n\nCore Rust library for the coglet prediction server. Pure Rust with no Python\ndependencies - the Python binding"
  },
  {
    "path": "crates/coglet/src/bridge/codec.rs",
    "chars": 5938,
    "preview": "//! Framed codec for worker communication.\n//!\n//! Uses LengthDelimitedCodec for framing + serde_json for serialization."
  },
  {
    "path": "crates/coglet/src/bridge/mod.rs",
    "chars": 421,
    "preview": "//! IPC bridge for coglet parent-worker communication.\n//!\n//! This module provides the wire protocol and codec for comm"
  },
  {
    "path": "crates/coglet/src/bridge/protocol.rs",
    "chars": 20995,
    "preview": "//! Wire protocol types for parent-worker communication.\n//!\n//! Two channels:\n//! - **Control channel** (stdin/stdout):"
  },
  {
    "path": "crates/coglet/src/bridge/snapshots/coglet__bridge__protocol__tests__control_cancel_serializes.snap",
    "chars": 135,
    "preview": "---\nsource: coglet/src/bridge/protocol.rs\nexpression: req\n---\n{\n  \"type\": \"cancel\",\n  \"slot\": \"550e8400-e29b-41d4-a716-4"
  },
  {
    "path": "crates/coglet/src/bridge/snapshots/coglet__bridge__protocol__tests__control_cancelled_serializes.snap",
    "chars": 139,
    "preview": "---\nsource: coglet/src/bridge/protocol.rs\nexpression: resp\n---\n{\n  \"type\": \"cancelled\",\n  \"slot\": \"550e8400-e29b-41d4-a7"
  },
  {
    "path": "crates/coglet/src/bridge/snapshots/coglet__bridge__protocol__tests__control_failed_serializes.snap",
    "chars": 159,
    "preview": "---\nsource: coglet/src/bridge/protocol.rs\nexpression: resp\n---\n{\n  \"type\": \"failed\",\n  \"slot\": \"550e8400-e29b-41d4-a716-"
  },
  {
    "path": "crates/coglet/src/bridge/snapshots/coglet__bridge__protocol__tests__control_healthcheck_result_healthy_serializes.snap",
    "chars": 139,
    "preview": "---\nsource: coglet/src/bridge/protocol.rs\nexpression: resp\n---\n{\n  \"type\": \"healthcheck_result\",\n  \"id\": \"hc_123\",\n  \"st"
  },
  {
    "path": "crates/coglet/src/bridge/snapshots/coglet__bridge__protocol__tests__control_healthcheck_result_unhealthy_serializes.snap",
    "chars": 187,
    "preview": "---\nsource: coglet/src/bridge/protocol.rs\nexpression: resp\n---\n{\n  \"type\": \"healthcheck_result\",\n  \"id\": \"hc_123\",\n  \"st"
  },
  {
    "path": "crates/coglet/src/bridge/snapshots/coglet__bridge__protocol__tests__control_healthcheck_serializes.snap",
    "chars": 108,
    "preview": "---\nsource: coglet/src/bridge/protocol.rs\nexpression: req\n---\n{\n  \"type\": \"healthcheck\",\n  \"id\": \"hc_123\"\n}\n"
  },
  {
    "path": "crates/coglet/src/bridge/snapshots/coglet__bridge__protocol__tests__control_idle_serializes.snap",
    "chars": 134,
    "preview": "---\nsource: coglet/src/bridge/protocol.rs\nexpression: resp\n---\n{\n  \"type\": \"idle\",\n  \"slot\": \"550e8400-e29b-41d4-a716-44"
  },
  {
    "path": "crates/coglet/src/bridge/snapshots/coglet__bridge__protocol__tests__control_init_serializes.snap",
    "chars": 293,
    "preview": "---\nsource: coglet/src/bridge/protocol.rs\nexpression: req\n---\n{\n  \"type\": \"init\",\n  \"predictor_ref\": \"predict.py:Predict"
  },
  {
    "path": "crates/coglet/src/bridge/snapshots/coglet__bridge__protocol__tests__control_ready_serializes.snap",
    "chars": 146,
    "preview": "---\nsource: coglet/src/bridge/protocol.rs\nexpression: resp\n---\n{\n  \"type\": \"ready\",\n  \"slots\": [\n    \"550e8400-e29b-41d4"
  },
  {
    "path": "crates/coglet/src/bridge/snapshots/coglet__bridge__protocol__tests__control_ready_with_schema_serializes.snap",
    "chars": 256,
    "preview": "---\nsource: coglet/src/bridge/protocol.rs\nexpression: resp\n---\n{\n  \"type\": \"ready\",\n  \"slots\": [\n    \"550e8400-e29b-41d4"
  },
  {
    "path": "crates/coglet/src/bridge/snapshots/coglet__bridge__protocol__tests__control_shutdown_serializes.snap",
    "chars": 87,
    "preview": "---\nsource: coglet/src/bridge/protocol.rs\nexpression: req\n---\n{\n  \"type\": \"shutdown\"\n}\n"
  },
  {
    "path": "crates/coglet/src/bridge/snapshots/coglet__bridge__protocol__tests__slot_cancelled_serializes.snap",
    "chars": 109,
    "preview": "---\nsource: coglet/src/bridge/protocol.rs\nexpression: resp\n---\n{\n  \"type\": \"cancelled\",\n  \"id\": \"pred_123\"\n}\n"
  },
  {
    "path": "crates/coglet/src/bridge/snapshots/coglet__bridge__protocol__tests__slot_done_serializes.snap",
    "chars": 157,
    "preview": "---\nsource: coglet/src/bridge/protocol.rs\nexpression: resp\n---\n{\n  \"type\": \"done\",\n  \"id\": \"pred_123\",\n  \"output\": \"fina"
  },
  {
    "path": "crates/coglet/src/bridge/snapshots/coglet__bridge__protocol__tests__slot_failed_serializes.snap",
    "chars": 146,
    "preview": "---\nsource: coglet/src/bridge/protocol.rs\nexpression: resp\n---\n{\n  \"type\": \"failed\",\n  \"id\": \"pred_123\",\n  \"error\": \"Val"
  },
  {
    "path": "crates/coglet/src/bridge/snapshots/coglet__bridge__protocol__tests__slot_log_serializes.snap",
    "chars": 132,
    "preview": "---\nsource: coglet/src/bridge/protocol.rs\nexpression: resp\n---\n{\n  \"type\": \"log\",\n  \"source\": \"stdout\",\n  \"data\": \"Proce"
  },
  {
    "path": "crates/coglet/src/bridge/snapshots/coglet__bridge__protocol__tests__slot_metric_append_serializes.snap",
    "chars": 145,
    "preview": "---\nsource: coglet/src/bridge/protocol.rs\nexpression: resp\n---\n{\n  \"type\": \"metric\",\n  \"name\": \"logprobs\",\n  \"value\": -1"
  },
  {
    "path": "crates/coglet/src/bridge/snapshots/coglet__bridge__protocol__tests__slot_metric_complex_value_serializes.snap",
    "chars": 189,
    "preview": "---\nsource: coglet/src/bridge/protocol.rs\nexpression: resp\n---\n{\n  \"type\": \"metric\",\n  \"name\": \"timing\",\n  \"value\": {\n  "
  },
  {
    "path": "crates/coglet/src/bridge/snapshots/coglet__bridge__protocol__tests__slot_metric_delete_serializes.snap",
    "chars": 146,
    "preview": "---\nsource: coglet/src/bridge/protocol.rs\nexpression: resp\n---\n{\n  \"type\": \"metric\",\n  \"name\": \"unwanted\",\n  \"value\": nu"
  },
  {
    "path": "crates/coglet/src/bridge/snapshots/coglet__bridge__protocol__tests__slot_metric_increment_serializes.snap",
    "chars": 148,
    "preview": "---\nsource: coglet/src/bridge/protocol.rs\nexpression: resp\n---\n{\n  \"type\": \"metric\",\n  \"name\": \"token_count\",\n  \"value\":"
  },
  {
    "path": "crates/coglet/src/bridge/snapshots/coglet__bridge__protocol__tests__slot_metric_replace_serializes.snap",
    "chars": 148,
    "preview": "---\nsource: coglet/src/bridge/protocol.rs\nexpression: resp\n---\n{\n  \"type\": \"metric\",\n  \"name\": \"temperature\",\n  \"value\":"
  },
  {
    "path": "crates/coglet/src/bridge/snapshots/coglet__bridge__protocol__tests__slot_output_serializes.snap",
    "chars": 109,
    "preview": "---\nsource: coglet/src/bridge/protocol.rs\nexpression: resp\n---\n{\n  \"type\": \"output\",\n  \"output\": \"chunk 1\"\n}\n"
  },
  {
    "path": "crates/coglet/src/bridge/snapshots/coglet__bridge__protocol__tests__slot_predict_file_input_serializes.snap",
    "chars": 257,
    "preview": "---\nsource: coglet/src/bridge/protocol.rs\nexpression: req\n---\n{\n  \"type\": \"predict\",\n  \"id\": \"pred_456\",\n  \"input_file\":"
  },
  {
    "path": "crates/coglet/src/bridge/snapshots/coglet__bridge__protocol__tests__slot_predict_serializes.snap",
    "chars": 221,
    "preview": "---\nsource: coglet/src/bridge/protocol.rs\nexpression: req\n---\n{\n  \"type\": \"predict\",\n  \"id\": \"pred_123\",\n  \"input\": {\n  "
  },
  {
    "path": "crates/coglet/src/bridge/transport.rs",
    "chars": 11567,
    "preview": "//! Slot socket transport for parent-worker IPC.\n//!\n//! Platform-specific implementations:\n//! - **NamedSocketTransport"
  },
  {
    "path": "crates/coglet/src/fd_redirect.rs",
    "chars": 9353,
    "preview": "//! File descriptor redirection for subprocess isolation.\n//!\n//! Worker uses fd 1 (stdout) as the control channel to th"
  },
  {
    "path": "crates/coglet/src/health.rs",
    "chars": 4937,
    "preview": "//! Health status types for coglet runtime.\n\nuse serde::{Deserialize, Serialize};\n\n/// Health status of the coglet runti"
  },
  {
    "path": "crates/coglet/src/input_validation.rs",
    "chars": 12673,
    "preview": "//! Input validation against the OpenAPI schema.\n//!\n//! Validates prediction inputs before dispatching to the Python wo"
  },
  {
    "path": "crates/coglet/src/lib.rs",
    "chars": 1022,
    "preview": "//! coglet: Rust execution engine for cog models.\n\nmod health;\npub mod input_validation;\nmod prediction;\nmod predictor;\n"
  },
  {
    "path": "crates/coglet/src/orchestrator.rs",
    "chars": 55735,
    "preview": "//! Orchestrator - manages worker subprocess lifecycle and event loop.\n//!\n//! Flow:\n//! 1. Spawn worker subprocess\n//! "
  },
  {
    "path": "crates/coglet/src/permit/mod.rs",
    "chars": 862,
    "preview": "//! Permit pool for concurrent slot management.\n//!\n//! The permit system uses typestate to enforce valid state transiti"
  },
  {
    "path": "crates/coglet/src/permit/pool.rs",
    "chars": 16114,
    "preview": "//! Permit pool implementation with typestate for compile-time state transition safety.\n//!\n//! Slot poisoning is a pool"
  },
  {
    "path": "crates/coglet/src/permit/slot.rs",
    "chars": 8764,
    "preview": "//! PredictionSlot - holds Prediction and Permit side-by-side.\n//!\n//! This separation allows the prediction to be behin"
  },
  {
    "path": "crates/coglet/src/prediction.rs",
    "chars": 25088,
    "preview": "//! Prediction state tracking.\n\nuse std::collections::HashMap;\nuse std::sync::Arc;\nuse std::time::Instant;\n\nuse tokio::s"
  },
  {
    "path": "crates/coglet/src/predictor.rs",
    "chars": 3616,
    "preview": "//! Predictor traits and prediction lifecycle types.\n\nuse std::collections::HashMap;\nuse std::time::{Duration, Instant};"
  },
  {
    "path": "crates/coglet/src/service.rs",
    "chars": 43439,
    "preview": "//! PredictionService: Transport-agnostic prediction lifecycle management.\n//!\n//! This service is the single owner of p"
  },
  {
    "path": "crates/coglet/src/setup_log_accumulator.rs",
    "chars": 2264,
    "preview": "//! Tracing layer that accumulates all logs from coglet server during setup.\n//!\n//! Captures every tracing event from t"
  },
  {
    "path": "crates/coglet/src/snapshots/coglet__health__tests__health_all_variants.snap",
    "chars": 238,
    "preview": "---\nsource: coglet/src/health.rs\nexpression: \"[Health::Unknown, Health::Starting, Health::Ready, Health::Busy,\\nHealth::"
  },
  {
    "path": "crates/coglet/src/snapshots/coglet__health__tests__health_response_all_variants.snap",
    "chars": 329,
    "preview": "---\nsource: coglet/src/health.rs\nexpression: \"[HealthResponse::Unknown, HealthResponse::Starting, HealthResponse::Ready,"
  },
  {
    "path": "crates/coglet/src/snapshots/coglet__health__tests__setup_status_all_variants.snap",
    "chars": 165,
    "preview": "---\nsource: coglet/src/health.rs\nexpression: \"[SetupStatus::Starting, SetupStatus::Succeeded, SetupStatus::Failed,]\"\n---"
  },
  {
    "path": "crates/coglet/src/snapshots/coglet__predictor__tests__output_single.snap",
    "chars": 67,
    "preview": "---\nsource: coglet/src/predictor.rs\nexpression: single\n---\n\"hello\"\n"
  },
  {
    "path": "crates/coglet/src/snapshots/coglet__predictor__tests__output_stream.snap",
    "chars": 72,
    "preview": "---\nsource: coglet/src/predictor.rs\nexpression: stream\n---\n[\n  1,\n  2\n]\n"
  },
  {
    "path": "crates/coglet/src/snapshots/coglet__version__tests__version_full.snap",
    "chars": 196,
    "preview": "---\nsource: coglet/src/version.rs\nexpression: info\n---\n{\n  \"coglet\": \"0.1.0\",\n  \"git_sha\": \"abc1234-dirty\",\n  \"build_tim"
  },
  {
    "path": "crates/coglet/src/snapshots/coglet__version__tests__version_minimal.snap",
    "chars": 79,
    "preview": "---\nsource: coglet/src/version.rs\nexpression: info\n---\n{\n  \"coglet\": \"0.1.0\"\n}\n"
  },
  {
    "path": "crates/coglet/src/transport/http/mod.rs",
    "chars": 107,
    "preview": "//! HTTP transport for coglet using axum.\n\nmod routes;\nmod server;\n\npub use server::{ServerConfig, serve};\n"
  },
  {
    "path": "crates/coglet/src/transport/http/routes.rs",
    "chars": 41728,
    "preview": "//! HTTP route handlers.\n\nuse std::sync::Arc;\n\nuse axum::{\n    Router,\n    extract::{DefaultBodyLimit, Path, State},\n   "
  },
  {
    "path": "crates/coglet/src/transport/http/server.rs",
    "chars": 3591,
    "preview": "//! HTTP server implementation.\n\nuse std::net::SocketAddr;\nuse std::sync::Arc;\n\nuse tokio::net::TcpListener;\nuse tokio::"
  },
  {
    "path": "crates/coglet/src/transport/mod.rs",
    "chars": 210,
    "preview": "//! Transport layer for coglet.\n//!\n//! Currently provides HTTP transport via axum. Future transports\n//! (gRPC, bnet) w"
  },
  {
    "path": "crates/coglet/src/version.rs",
    "chars": 3435,
    "preview": "//! Version information for coglet.\n\n/// Coglet version from Cargo.toml\npub const COGLET_VERSION: &str = env!(\"CARGO_PKG"
  },
  {
    "path": "crates/coglet/src/webhook.rs",
    "chars": 20522,
    "preview": "//! Webhook sender for async predictions.\n//!\n//! Implements the cog webhook protocol:\n//! - Throttling (default 500ms b"
  },
  {
    "path": "crates/coglet/src/worker.rs",
    "chars": 33925,
    "preview": "//! Worker subprocess - runs inside the Python subprocess.\n//!\n//! This module provides the child-side of the worker sub"
  },
  {
    "path": "crates/coglet/src/worker_tracing_layer.rs",
    "chars": 3989,
    "preview": "//! Custom tracing layer for worker subprocess.\n//!\n//! Ships structured tracing events over IPC to orchestrator, preser"
  },
  {
    "path": "crates/coglet-python/Cargo.toml",
    "chars": 832,
    "preview": "[package]\nname = \"coglet-python\"\nversion.workspace = true\nedition.workspace = true\nlicense.workspace = true\npublish = fa"
  },
  {
    "path": "crates/coglet-python/README.md",
    "chars": 9736,
    "preview": "# coglet-python\n\nPyO3 bindings that bridge the Rust coglet library to Python. This crate implements\nthe `PredictHandler`"
  },
  {
    "path": "crates/coglet-python/build.rs",
    "chars": 4681,
    "preview": "//! Build script for coglet-python.\n//!\n//! Captures build metadata and converts semver to PEP 440 for Python compatibil"
  },
  {
    "path": "crates/coglet-python/coglet/__init__.py",
    "chars": 265,
    "preview": "\"\"\"coglet — high-performance Rust prediction server for Cog ML models.\"\"\"\n\nfrom coglet._impl import CancelationException"
  },
  {
    "path": "crates/coglet-python/coglet/__init__.pyi",
    "chars": 318,
    "preview": "# This file is automatically generated by stub_gen\n# ruff: noqa: E501, F401\n\nfrom coglet._impl import __build__ as __bui"
  },
  {
    "path": "crates/coglet-python/coglet/_impl.pyi",
    "chars": 2238,
    "preview": "# This file is automatically generated by pyo3_stub_gen\n# ruff: noqa: E501, F401, F403, F405\n\nimport builtins\nimport typ"
  },
  {
    "path": "crates/coglet-python/coglet/_sdk/__init__.pyi",
    "chars": 7553,
    "preview": "# This file is automatically generated by pyo3_stub_gen\n# ruff: noqa: E501, F401, F403, F405\n\nimport builtins\nimport typ"
  },
  {
    "path": "crates/coglet-python/coglet/py.typed",
    "chars": 0,
    "preview": ""
  },
  {
    "path": "crates/coglet-python/pyproject.toml",
    "chars": 1692,
    "preview": "[build-system]\nrequires = [\"maturin>=1.0,<2.0\"]\nbuild-backend = \"maturin\"\n\n[project]\nname = \"coglet\"\ndescription = \"High"
  },
  {
    "path": "crates/coglet-python/src/audit.rs",
    "chars": 9987,
    "preview": "//! Audit hooks to protect Rust-injected runtime objects.\n//!\n//! Uses sys.addaudithook to intercept operations that cou"
  },
  {
    "path": "crates/coglet-python/src/bin/stub_gen.rs",
    "chars": 3205,
    "preview": "//! Generate Python stub files for coglet.\n//!\n//! Run with: cargo run --bin stub_gen\n//!\n//! Custom generate logic: pyo"
  },
  {
    "path": "crates/coglet-python/src/cancel.rs",
    "chars": 3613,
    "preview": "//! Cancellation support for predictions.\n//!\n//! Sync predictors use `PyThreadState_SetAsyncExc` to inject a\n//! `Cance"
  },
  {
    "path": "crates/coglet-python/src/input.rs",
    "chars": 16876,
    "preview": "//! Input processing for cog predictors.\n//!\n//! This module handles file downloads for cog predictor inputs.\n//! Input "
  },
  {
    "path": "crates/coglet-python/src/lib.rs",
    "chars": 19905,
    "preview": "//! coglet-python: PyO3 bindings for coglet.\n\nmod audit;\nmod cancel;\nmod input;\nmod log_writer;\nmod metric_scope;\nmod ou"
  },
  {
    "path": "crates/coglet-python/src/log_writer.rs",
    "chars": 23048,
    "preview": "//! Log routing via prediction_id ContextVar.\n//!\n//! Architecture:\n//! - Rust owns a ContextVar `_coglet_prediction_id`"
  },
  {
    "path": "crates/coglet-python/src/metric_scope.rs",
    "chars": 17178,
    "preview": "//! Metric scope: type-safe metric recording with ContextVar routing.\n//!\n//! Two PyO3 classes:\n//! - `Scope` — the per-"
  },
  {
    "path": "crates/coglet-python/src/output.rs",
    "chars": 18542,
    "preview": "//! Output processing for prediction results.\n//!\n//! Converts Python prediction output to JSON-serializable format:\n//!"
  },
  {
    "path": "crates/coglet-python/src/predictor.rs",
    "chars": 49254,
    "preview": "//! Python predictor loading and invocation.\n\nuse std::sync::{Arc, OnceLock};\n\nuse pyo3::prelude::*;\nuse pyo3::types::Py"
  },
  {
    "path": "crates/coglet-python/src/worker_bridge.rs",
    "chars": 27387,
    "preview": "//! Bridge between coglet-worker's PredictHandler trait and PythonPredictor.\n\nuse std::collections::HashMap;\nuse std::sy"
  },
  {
    "path": "crates/coglet-python/tests/test_coglet.py",
    "chars": 22606,
    "preview": "\"\"\"Tests for coglet Python bindings.\"\"\"\n\nimport queue\nimport re\nimport socket\nimport subprocess\nimport sys\nimport thread"
  },
  {
    "path": "crates/deny.toml",
    "chars": 1641,
    "preview": "# cargo-deny configuration for coglet crates\n# See: https://embarkstudios.github.io/cargo-deny/\n\n[graph]\nall-features = "
  },
  {
    "path": "docs/CNAME",
    "chars": 8,
    "preview": "cog.run\n"
  },
  {
    "path": "docs/cli.md",
    "chars": 9609,
    "preview": "# CLI reference\n\n<!-- This file is auto-generated. Do not edit manually. -->\n\n## `cog`\n\nContainers for machine learning."
  },
  {
    "path": "docs/deploy.md",
    "chars": 2665,
    "preview": "# Deploy models with Cog\n\nCog containers are Docker containers that serve an HTTP server\nfor running predictions on your"
  },
  {
    "path": "docs/environment.md",
    "chars": 4089,
    "preview": "# Environment variables\n\nThis guide lists the environment variables that change how Cog functions.\n\n## Build-time variab"
  },
  {
    "path": "docs/getting-started-own-model.md",
    "chars": 6299,
    "preview": "# Getting started with your own model\n\nThis guide will show you how to put your own machine learning model in a Docker i"
  },
  {
    "path": "docs/getting-started.md",
    "chars": 6581,
    "preview": "# Getting started\n\nThis guide will walk you through what you can do with Cog by using an example model.\n\n> [!TIP]\n> Usin"
  },
  {
    "path": "docs/http.md",
    "chars": 13362,
    "preview": "# HTTP API\n\n> [!TIP]\n> For information about how to run the HTTP server,\n> see [our documentation on deploying models](d"
  },
  {
    "path": "docs/llms.txt",
    "chars": 95715,
    "preview": "# Cog: Containers for machine learning\n\nCog is an open-source tool that lets you package machine learning models in a st"
  },
  {
    "path": "docs/notebooks.md",
    "chars": 1146,
    "preview": "# Notebooks\n\nCog plays nicely with Jupyter notebooks.\n\n## Install the jupyterlab Python package\n\nFirst, add `jupyterlab`"
  },
  {
    "path": "docs/private-package-registry.md",
    "chars": 1707,
    "preview": "# Private package registry\n\nThis guide describes how to build a Docker image with Cog that fetches Python packages from "
  },
  {
    "path": "docs/python.md",
    "chars": 21960,
    "preview": "# Prediction interface reference\n\nThis document defines the API of the `cog` Python module, which is used to define the "
  },
  {
    "path": "docs/stylesheets/extra.css",
    "chars": 256,
    "preview": ".md-typeset h1,\n.md-typeset h2,\n.md-typeset h3 {\n  font-weight: 600;\n}\n\n/* move the \"Cog\" header to the left */\n[dir=\"lt"
  },
  {
    "path": "docs/training.md",
    "chars": 5076,
    "preview": "# Training interface reference\n\n> [!WARNING]  \n> The `cog train` command is deprecated and will be removed in the next v"
  },
  {
    "path": "docs/wsl2/wsl2.md",
    "chars": 8875,
    "preview": "# Using `cog` on Windows 11 with WSL 2\n\n- [0. Prerequisites](#0-prerequisites)\n- [1. Install the GPU driver](#1-install-"
  },
  {
    "path": "docs/yaml.md",
    "chars": 6932,
    "preview": "# `cog.yaml` reference\n\n`cog.yaml` defines how to build a Docker image and how to run predictions on your model inside t"
  },
  {
    "path": "go.mod",
    "chars": 7906,
    "preview": "module github.com/replicate/cog\n\ngo 1.26\n\nrequire (\n\tgithub.com/anaskhan96/soup v1.2.5\n\tgithub.com/containerd/errdefs v1"
  },
  {
    "path": "go.sum",
    "chars": 38687,
    "preview": "cyphar.com/go-pathrs v0.2.1 h1:9nx1vOgwVvX1mNBWDu93+vaceedpbsDqo+XuBGL40b8=\ncyphar.com/go-pathrs v0.2.1/go.mod h1:y8f1EM"
  },
  {
    "path": "integration-tests/.gitignore",
    "chars": 6,
    "preview": ".bin/\n"
  },
  {
    "path": "integration-tests/README.md",
    "chars": 12576,
    "preview": "# Cog Integration Tests\n\nThis directory contains Go-based integration tests for the Cog CLI using the [testscript](https"
  },
  {
    "path": "integration-tests/concurrent/concurrent_test.go",
    "chars": 14164,
    "preview": "//go:build integration\n\npackage concurrent_test\n\nimport (\n\t\"encoding/json\"\n\t\"errors\"\n\t\"fmt\"\n\t\"net\"\n\t\"net/http\"\n\t\"os\"\n\t\"o"
  },
  {
    "path": "integration-tests/harness/cmd_pty.go",
    "chars": 4692,
    "preview": "package harness\n\nimport (\n\t\"bytes\"\n\t\"io\"\n\t\"os\"\n\t\"os/exec\"\n\t\"strings\"\n\t\"sync\"\n\t\"time\"\n\n\t\"github.com/creack/pty\"\n\t\"github."
  },
  {
    "path": "integration-tests/harness/command.go",
    "chars": 949,
    "preview": "package harness\n\nimport \"github.com/rogpeppe/go-internal/testscript\"\n\n// Command defines the interface for testscript co"
  },
  {
    "path": "integration-tests/harness/harness.go",
    "chars": 45094,
    "preview": "// Package harness provides utilities for running cog integration tests.\npackage harness\n\nimport (\n\t\"context\"\n\tcryptoran"
  },
  {
    "path": "integration-tests/login/login_test.go",
    "chars": 14231,
    "preview": "//go:build integration\n\n// Package login provides integration tests for the cog login command.\n//\n// These tests verify:"
  },
  {
    "path": "integration-tests/suite_test.go",
    "chars": 2014,
    "preview": "//go:build integration\n\npackage integration_test\n\nimport (\n\t\"fmt\"\n\t\"os\"\n\t\"os/signal\"\n\t\"path/filepath\"\n\t\"runtime\"\n\t\"sort\""
  },
  {
    "path": "integration-tests/tests/apt_packages.txtar",
    "chars": 635,
    "preview": "# Skip for cog-dataclass and coglet (Rust) which require Python 3.10+\n# Test that system packages are installed correctl"
  },
  {
    "path": "integration-tests/tests/async_generator_precollect.txtar",
    "chars": 983,
    "preview": "# Test that async generator output is pre-collected before response.\n#\n# Coglet collects all async generator yields into"
  },
  {
    "path": "integration-tests/tests/async_predictor.txtar",
    "chars": 358,
    "preview": "# Build the image\ncog build -t $TEST_IMAGE\n\n# Async prediction works\ncog predict $TEST_IMAGE -i s=world\nstdout 'hello wo"
  },
  {
    "path": "integration-tests/tests/async_sleep.txtar",
    "chars": 517,
    "preview": "# Test async predictor with sleep\n\n# Build the image\ncog build -t $TEST_IMAGE\n\n# Async prediction with sleep works\ncog p"
  },
  {
    "path": "integration-tests/tests/bad_dockerignore.txtar",
    "chars": 506,
    "preview": "# Skip for cog-dataclass and coglet (Rust) which require Python 3.10+\n# Test that build fails with proper error when .co"
  },
  {
    "path": "integration-tests/tests/bool_input_output.txtar",
    "chars": 585,
    "preview": "# Test bool as a direct predict input and output type\n\n# Build the image\ncog build -t $TEST_IMAGE\n\n# Bool input and outp"
  },
  {
    "path": "integration-tests/tests/build_base_image_sha.txtar",
    "chars": 1689,
    "preview": "# Test that base image SHA is recorded in labels with --use-cog-base-image\n# Source: test_build.py::test_build_base_imag"
  },
  {
    "path": "integration-tests/tests/build_cog_init.txtar",
    "chars": 308,
    "preview": "# Test that cog init creates a buildable project\n# Source: test_build.py::test_build_with_cog_init_templates\n\n# Initiali"
  },
  {
    "path": "integration-tests/tests/build_cog_version_match.txtar",
    "chars": 6419,
    "preview": "# Note: This test can be flaky if the wheel build time and CI run time\n# cross day boundaries (version date mismatch). I"
  },
  {
    "path": "integration-tests/tests/build_gpu_labels.txtar",
    "chars": 1368,
    "preview": "# Test GPU build labels\n# Source: test_build.py::test_build_gpu_model_on_cpu\n# Requires git init/tag for version labels\n"
  },
  {
    "path": "integration-tests/tests/build_image_option.txtar",
    "chars": 651,
    "preview": "# Test that image: option in cog.yaml names the built image\n# Source: test_build.py::test_build_names_uses_image_option_"
  },
  {
    "path": "integration-tests/tests/build_openapi_schema.txtar",
    "chars": 988,
    "preview": "# Test that OpenAPI schema is embedded in image labels\n# Source: test_build.py::test_build_with_model\n\n# Build the image"
  },
  {
    "path": "integration-tests/tests/build_openapi_schema_complex.txtar",
    "chars": 1722,
    "preview": "# Test that the OpenAPI schema for complex input/output types is correct.\n#\n# Verifies schema generation for:\n# - Multip"
  },
  {
    "path": "integration-tests/tests/build_pip_freeze.txtar",
    "chars": 851,
    "preview": "\n# Test that pip freeze label is embedded in image\n# Source: test_build.py::test_pip_freeze\n\n# Build the image\ncog build"
  },
  {
    "path": "integration-tests/tests/build_python313_base_image.txtar",
    "chars": 843,
    "preview": "# Test Python 3.13 works with --use-cog-base-image\n# Source: test_build.py::test_python_313_base_images\n#\n# Uses a local"
  },
  {
    "path": "integration-tests/tests/build_torch_version_required.txtar",
    "chars": 571,
    "preview": "# Test that build fails with proper error when torch is specified without version and GPU is enabled\n# This validates th"
  },
  {
    "path": "integration-tests/tests/ca_cert.txtar",
    "chars": 6077,
    "preview": "# Test CA certificate injection via COG_CA_CERT\n#\n# This test verifies that custom CA certificates can be injected into\n"
  },
  {
    "path": "integration-tests/tests/cancel_async_prediction.txtar",
    "chars": 1213,
    "preview": "# Test cancellation of a running async prediction.\n#\n# Submits an async prediction (PUT with Prefer: respond-async) that"
  },
  {
    "path": "integration-tests/tests/cancel_repeated.txtar",
    "chars": 1548,
    "preview": "# Test that cancelling the same prediction multiple times doesn't panic or break.\n#\n# Uses time.sleep() (C-level nanosle"
  },
  {
    "path": "integration-tests/tests/cancel_sync_prediction.txtar",
    "chars": 1345,
    "preview": "# Test cancellation of a running sync prediction.\n#\n# Submits an async prediction (PUT with Prefer: respond-async) that "
  },
  {
    "path": "integration-tests/tests/coglet_iterator_path_output.txtar",
    "chars": 882,
    "preview": "# Test iterator prediction with Path outputs (no upload URL — files written to disk)\n\ncog build -t $TEST_IMAGE\ncog predi"
  },
  {
    "path": "integration-tests/tests/coglet_iterator_upload_url.txtar",
    "chars": 1133,
    "preview": "# Test that iterator Path outputs are uploaded per-yield to --upload-url.\n\ncog build -t $TEST_IMAGE\n\n# Start mock upload"
  },
  {
    "path": "integration-tests/tests/coglet_large_file_upload_serial.txtar",
    "chars": 1200,
    "preview": "[short] skip 'large file test - slow'\n\n# Test that a large binary file (50 MiB) is successfully uploaded via --upload-ur"
  },
  {
    "path": "integration-tests/tests/coglet_large_input.txtar",
    "chars": 1672,
    "preview": "# Test that inputs larger than the 6 MiB IPC inline threshold spill to disk\n# and are rehydrated correctly by the worker"
  },
  {
    "path": "integration-tests/tests/coglet_large_output.txtar",
    "chars": 1364,
    "preview": "# Test that outputs larger than the 8MiB IPC frame limit spill to disk\n# and are reconstructed correctly by the orchestr"
  },
  {
    "path": "integration-tests/tests/coglet_list_path_single_element.txtar",
    "chars": 1797,
    "preview": "# Test that List[Path] with a single element returns an array, not a scalar.\n# Regression test: the orchestrator must no"
  },
  {
    "path": "integration-tests/tests/coglet_list_path_upload_url.txtar",
    "chars": 1309,
    "preview": "# Test that List[Path] outputs are uploaded to --upload-url.\n# This verifies that list returns (not just iterators) go t"
  },
  {
    "path": "integration-tests/tests/coglet_metrics.txtar",
    "chars": 1799,
    "preview": "# Test that user-emitted metrics appear in sync prediction responses.\n#\n# Verifies:\n# 1. record_metric() with default mo"
  },
  {
    "path": "integration-tests/tests/coglet_metrics_webhook.txtar",
    "chars": 1325,
    "preview": "# Test that user-emitted metrics appear in webhook payloads.\n#\n# Uses async prediction with webhook to verify metrics fl"
  },
  {
    "path": "integration-tests/tests/coglet_single_path_output.txtar",
    "chars": 1226,
    "preview": "# Test that a single Path return (not List[Path]) returns a scalar string, not an array.\n# This complements coglet_list_"
  },
  {
    "path": "integration-tests/tests/complex_output.txtar",
    "chars": 694,
    "preview": "# Test complex/structured output type using cog.BaseModel (dataclass)\n\n# Build the image\ncog build -t $TEST_IMAGE\n\n# Pre"
  },
  {
    "path": "integration-tests/tests/concatenate_iterator_output.txtar",
    "chars": 689,
    "preview": "# Test ConcatenateIterator[str] as predict output type\n#\n# ConcatenateIterator is the primary streaming text output type"
  },
  {
    "path": "integration-tests/tests/config_subdirectory.txtar",
    "chars": 350,
    "preview": "# Test that cog.yaml is discovered from subdirectories\n# Source: test_config.py::test_config\n\n# Create a subdirectory st"
  },
  {
    "path": "integration-tests/tests/debug_secrets.txtar",
    "chars": 684,
    "preview": "# Test that cog debug shows secret mount syntax in Dockerfile output\n# Source: test_run.py::test_run_with_secret\n\n# Run "
  },
  {
    "path": "integration-tests/tests/dict_output.txtar",
    "chars": 488,
    "preview": "# Test bare dict return type works for predict output\n\n# Build the image\ncog build -t $TEST_IMAGE\n\n# Predict returns a d"
  },
  {
    "path": "integration-tests/tests/emit_metric_deprecated.txtar",
    "chars": 931,
    "preview": "# Test that a predictor using the deprecated emit_metric() still builds,\n# runs, and records metrics correctly.\n#\n# emit"
  },
  {
    "path": "integration-tests/tests/env_vars.txtar",
    "chars": 506,
    "preview": "# Build the image\ncog build -t $TEST_IMAGE\n\n# Environment variables are set\ncog predict $TEST_IMAGE -i name=TEST_VAR\nstd"
  },
  {
    "path": "integration-tests/tests/experimental_feature_warning.txtar",
    "chars": 607,
    "preview": "# Test that a predictor importing the deprecated ExperimentalFeatureWarning\n# still builds and runs successfully.\n\n# Bui"
  },
  {
    "path": "integration-tests/tests/ffmpeg_package.txtar",
    "chars": 578,
    "preview": "# Test that ffmpeg system package is installed (common ML dependency)\n\n# Build the image (the run command verifies ffmpe"
  },
  {
    "path": "integration-tests/tests/file_input.txtar",
    "chars": 405,
    "preview": "# Build the image\ncog build -t $TEST_IMAGE\n\n# File input works\ncog predict $TEST_IMAGE -i file=@input.txt\nstdout 'hello "
  },
  {
    "path": "integration-tests/tests/file_list_input.txtar",
    "chars": 786,
    "preview": "\n# Test list[File] input type (multiple file inputs using File type)\n\n# Build the image\ncog build -t $TEST_IMAGE\n\n# Pred"
  },
  {
    "path": "integration-tests/tests/float_input_output.txtar",
    "chars": 518,
    "preview": "# Test float input and output types work correctly\ncog build -t $TEST_IMAGE\n\n# Float input and output works\ncog predict "
  },
  {
    "path": "integration-tests/tests/function_predictor.txtar",
    "chars": 406,
    "preview": "# Test function-based predictor (no class, just a function)\n\n# Build the image\ncog build -t $TEST_IMAGE\n\n# Predict using"
  },
  {
    "path": "integration-tests/tests/future_annotations.txtar",
    "chars": 839,
    "preview": "\n# Test from __future__ import annotations support\n# This tests that future annotations work correctly with Path types\n\n"
  },
  {
    "path": "integration-tests/tests/glb_project.txtar",
    "chars": 630,
    "preview": "# Test GLB (3D model) file output\n\n# Create a minimal GLB placeholder file (GLB files start with \"glTF\" magic bytes)\nexe"
  },
  {
    "path": "integration-tests/tests/granite_project.txtar",
    "chars": 517,
    "preview": "# Test that Pydantic 2 is not clobbered to a <2 version\n\n# Build the image\ncog build -t $TEST_IMAGE\n\n# Predict and verif"
  },
  {
    "path": "integration-tests/tests/healthcheck.txtar",
    "chars": 910,
    "preview": "# Test custom healthcheck functionality\n# This tests the user-defined healthcheck() method in predictors\n\n# Build the im"
  },
  {
    "path": "integration-tests/tests/healthcheck_async.txtar",
    "chars": 884,
    "preview": "# Test async healthcheck function\n# Ensures async healthchecks work correctly\n\n# Build the image\ncog build -t $TEST_IMAG"
  },
  {
    "path": "integration-tests/tests/healthcheck_async_exception.txtar",
    "chars": 820,
    "preview": "# Test async healthcheck that raises an exception\n# Tests that async def healthcheck() exceptions are handled\n\n# Build t"
  },
  {
    "path": "integration-tests/tests/healthcheck_async_timeout.txtar",
    "chars": 1203,
    "preview": "# Test async healthcheck timeout behavior\n# Tests that async def healthcheck() timeouts are handled (5 second limit)\n\n# "
  },
  {
    "path": "integration-tests/tests/healthcheck_async_unhealthy.txtar",
    "chars": 766,
    "preview": "# Test async unhealthy healthcheck behavior\n# Tests that async def healthcheck() returning False works correctly\n\n# Buil"
  },
  {
    "path": "integration-tests/tests/healthcheck_during_prediction.txtar",
    "chars": 1499,
    "preview": "# Test healthcheck called during active prediction\n# Ensures healthcheck pipe doesn't interfere with prediction pipe\n\n# "
  },
  {
    "path": "integration-tests/tests/healthcheck_exception.txtar",
    "chars": 916,
    "preview": "# Test healthcheck that raises an exception\n# This tests error handling when healthcheck throws\n\n# Build the image\ncog b"
  },
  {
    "path": "integration-tests/tests/healthcheck_immediately_after_prediction.txtar",
    "chars": 1147,
    "preview": "# Test healthcheck immediately after prediction completes\n# Ensures healthcheck works correctly in quick succession with"
  },
  {
    "path": "integration-tests/tests/healthcheck_repeated_calls.txtar",
    "chars": 1177,
    "preview": "# Test repeated healthcheck calls (simulates supervisor container polling pattern)\n# This ensures no resource leaks over"
  },
  {
    "path": "integration-tests/tests/healthcheck_timeout.txtar",
    "chars": 1160,
    "preview": "# Test healthcheck timeout behavior\n# This tests when sync healthcheck takes too long (>5 seconds)\n\n# Build the image\nco"
  },
  {
    "path": "integration-tests/tests/healthcheck_unhealthy.txtar",
    "chars": 859,
    "preview": "# Test unhealthy healthcheck behavior\n# This tests when healthcheck returns False\n\n# Build the image\ncog build -t $TEST_"
  },
  {
    "path": "integration-tests/tests/int_input_output.txtar",
    "chars": 516,
    "preview": "# Test integer input and output types work correctly\ncog build -t $TEST_IMAGE\n\n# Integer input and output works\ncog pred"
  },
  {
    "path": "integration-tests/tests/int_none_output.txtar",
    "chars": 529,
    "preview": "\n# Test int return type that returns None\n# This tests the handling of None values for typed outputs\n\n# Build the image\n"
  },
  {
    "path": "integration-tests/tests/int_predictor.txtar",
    "chars": 417,
    "preview": "# Build the image\ncog build -t $TEST_IMAGE\n\n# Integer input and output works\ncog predict $TEST_IMAGE -i num=5\nstdout '10"
  }
]

// ... and 375 more files (download for full content)