{"passport":{"unfragile":{"@version":"1.0","version":"2026-05","artifact":{"id":"pypi_pypi-modal","slug":"pypi-modal","name":"modal","type":"framework","url":"https://pypi.org/project/modal/","page_url":"https://unfragile.ai/pypi-modal","categories":["deployment-infra"],"tags":["modal","client","cloud","serverless","infrastructure"],"pricing":{"model":"open_source","free":true,"starting_price":null},"status":"active","verified":false},"capabilities":[{"id":"pypi_pypi-modal__cap_0","uri":"capability://automation.workflow.decorator.based.serverless.function.definition.and.remote.execution","name":"decorator-based serverless function definition and remote execution","description":"Enables developers to define Python functions as serverless tasks using @app.function() decorators that automatically serialize, containerize, and execute code on Modal's infrastructure. The decorator system captures function metadata, dependencies, and configuration at definition time, then uses gRPC client-server communication to orchestrate remote execution with automatic input/output serialization and streaming I/O support.","intents":["Define a Python function that runs on Modal's cloud infrastructure without managing containers or deployment","Execute long-running or compute-intensive tasks without blocking local execution","Scale function execution across multiple concurrent invocations with automatic resource allocation"],"best_for":["Python developers building serverless applications","Teams migrating from Lambda/Cloud Functions to a more Pythonic interface","Researchers and data scientists running distributed compute jobs"],"limitations":["Functions must be picklable or use Modal's serialization system — complex closures or unpicklable objects require workarounds","Execution latency includes container startup time (cold starts) unless using persistent containers or lifecycle hooks","Limited to Python; no native support for polyglot execution within a single function definition"],"requires":["Python 3.8+","Modal API credentials (token/workspace setup)","Network connectivity to Modal backend (gRPC endpoint)"],"input_types":["Python primitives (int, str, dict, list)","Serializable objects (dataclasses, Pydantic models)","File paths (via Mounts)"],"output_types":["Python primitives and objects","Streaming output via generator functions","Structured data (JSON-serializable)"],"categories":["automation-workflow","code-generation-editing"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-modal__cap_1","uri":"capability://automation.workflow.container.image.building.and.layering.with.dependency.management","name":"container image building and layering with dependency management","description":"Constructs Docker-compatible container images on-demand using a layered build system that caches base images, installs Python packages via pip, and mounts local files. The Image class uses a builder pattern to compose layers (base OS, Python packages, system dependencies, local code) and integrates with Modal's backend to build and cache images efficiently, avoiding redundant rebuilds across deployments.","intents":["Define custom container environments with specific Python packages and system dependencies for remote functions","Reuse container image definitions across multiple functions to avoid rebuilding identical environments","Layer dependencies efficiently so that changing application code doesn't trigger full image rebuilds"],"best_for":["Teams with complex dependency requirements (compiled packages, system libraries, GPU drivers)","Projects requiring reproducible, version-pinned execution environments","Developers optimizing build times through intelligent layer caching"],"limitations":["Image building happens server-side; local Docker daemon is not used, limiting offline development workflows","Large dependency sets (100+ packages) can increase deployment latency by 30-60 seconds on first build","Custom system packages require Dockerfile-style commands; no direct shell access during image build"],"requires":["Python 3.8+","Modal API credentials","requirements.txt or pyproject.toml for dependency specification"],"input_types":["Python package specifications (pip, conda-compatible)","System package names (apt-get compatible on Debian-based images)","Local file paths (via Mounts)"],"output_types":["Container image references (internal Modal identifiers)","Image metadata (digest, size, build time)"],"categories":["automation-workflow","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-modal__cap_10","uri":"capability://tool.use.integration.grpc.client.server.communication.with.protocol.buffer.serialization","name":"grpc client-server communication with protocol buffer serialization","description":"Implements client-server communication using gRPC with Protocol Buffer (protobuf) message serialization for efficient binary encoding and schema validation. The system defines API contracts in modal_proto/api.proto, generates Python stubs via protoc, and uses gRPC channels for bidirectional streaming of function inputs/outputs. TLS encryption is used for all client-server communication, and connection pooling is implemented for performance.","intents":["Efficiently serialize and transmit function arguments and results between client and Modal backend","Validate message schemas at the protocol level to catch serialization errors early","Support streaming I/O (generators, large outputs) without buffering entire results in memory"],"best_for":["High-performance applications requiring efficient serialization","Systems with large payloads (models, datasets) requiring compression","Teams requiring schema validation and API versioning"],"limitations":["gRPC adds complexity compared to REST; debugging requires gRPC-aware tools (grpcurl, Postman gRPC support)","Protocol Buffer definitions must be maintained in sync with Python code; schema changes require code generation","Large messages (>100MB) may hit gRPC size limits; requires manual chunking or alternative transport","Connection pooling adds memory overhead; not suitable for extremely resource-constrained environments"],"requires":["Python 3.8+","gRPC Python library (included in modal package)","TLS certificates for secure communication (managed by Modal)"],"input_types":["Protocol Buffer messages","Python objects (automatically serialized to protobuf)"],"output_types":["Protocol Buffer messages","Python objects (deserialized from protobuf)"],"categories":["tool-use-integration","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-modal__cap_11","uri":"capability://automation.workflow.application.lifecycle.management.with.deployment.and.cleanup","name":"application lifecycle management with deployment and cleanup","description":"Manages application lifecycle through the App object, which tracks all defined functions, classes, and resources. The system supports deployment via app.deploy() or CLI commands, which uploads the application definition to Modal's backend and creates/updates remote resources. Cleanup is handled via context managers or explicit app.stop() calls, which terminate containers and release resources. The resolver system tracks dependencies and ensures correct initialization order.","intents":["Deploy an entire application (all functions, classes, resources) to Modal's infrastructure with a single command","Manage application lifecycle (create, update, delete) without manual resource management","Track dependencies between functions and ensure correct initialization order"],"best_for":["Production deployments requiring reproducible, versioned application definitions","Teams managing multiple functions and resources as a cohesive unit","CI/CD pipelines automating application deployment"],"limitations":["Deployment is all-or-nothing; no selective function updates without redeploying entire app","Rollback requires manual version management; no built-in blue-green deployment","Dependency tracking is static (defined at decoration time); dynamic dependencies are not supported","No built-in monitoring or alerting; requires external tools for production observability"],"requires":["Python 3.8+","Modal API credentials with deployment permissions","App object with defined functions/classes"],"input_types":["Function and class definitions","Resource definitions (Images, Volumes, Secrets)"],"output_types":["Deployment status (success/failure)","Resource identifiers (function URLs, volume IDs)"],"categories":["automation-workflow","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-modal__cap_12","uri":"capability://automation.workflow.command.line.interface.for.deployment.resource.management.and.configuration","name":"command-line interface for deployment, resource management, and configuration","description":"Provides a comprehensive CLI (modal command) for deploying applications, managing resources, viewing logs, and configuring authentication. The CLI is built on Click and includes subcommands for app deployment (modal deploy), function invocation (modal run), resource inspection (modal volume list, modal secret list), and configuration management (modal config create-profile). The system integrates with the gRPC client for backend communication.","intents":["Deploy applications and manage resources from the command line without writing Python code","View logs and debug function execution from the terminal","Configure authentication and workspace settings without manual configuration files"],"best_for":["DevOps engineers and operators managing Modal infrastructure","CI/CD pipelines automating deployment and resource management","Teams preferring CLI-based workflows over Python SDK"],"limitations":["CLI is less discoverable than IDE autocomplete; requires memorizing subcommands and flags","Complex workflows (conditional deployments, multi-step orchestration) are difficult to express in CLI","No built-in templating or variable substitution; requires shell scripting for parameterized deployments","Error messages are sometimes cryptic; debugging requires understanding Modal's internal error codes"],"requires":["Python 3.8+","Modal SDK installed (pip install modal)","Modal API credentials"],"input_types":["Command-line arguments and flags","Configuration files (modal.toml, .modal/config.toml)"],"output_types":["Deployment status and logs","Resource listings (JSON or table format)","Configuration confirmation"],"categories":["automation-workflow","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-modal__cap_13","uri":"capability://memory.knowledge.object.system.and.hydration.with.lazy.loading.and.serialization","name":"object system and hydration with lazy loading and serialization","description":"Implements a custom object system for Modal resources (Functions, Classes, Volumes, etc.) with lazy loading and serialization support. Objects are defined locally but hydrated (resolved to remote references) only when needed, reducing overhead for unused resources. The hydration system uses the resolver pattern to track dependencies and ensure correct initialization order. Serialization is handled via pickle with custom handlers for non-serializable objects.","intents":["Define Modal resources (functions, classes, volumes) that are lazily resolved to remote references","Serialize and deserialize Modal objects across process boundaries","Track dependencies between resources and ensure correct initialization order"],"best_for":["Large applications with many resources where lazy loading reduces overhead","Complex dependency graphs requiring explicit ordering","Teams needing fine-grained control over resource lifecycle"],"limitations":["Lazy loading adds complexity; errors may be deferred until resource is actually used","Serialization relies on pickle, which has security implications if deserializing untrusted data","Custom serialization handlers are not well-documented; complex objects may require manual serialization logic","Dependency tracking is static; dynamic dependencies are not supported"],"requires":["Python 3.8+","Modal API credentials","Understanding of Modal's object model and hydration system"],"input_types":["Modal resource definitions (Functions, Classes, Volumes, etc.)","Serialized objects (pickle format)"],"output_types":["Hydrated Modal objects with remote references","Serialized objects (pickle format)"],"categories":["memory-knowledge","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-modal__cap_2","uri":"capability://memory.knowledge.distributed.file.system.mounting.and.persistent.volume.management","name":"distributed file system mounting and persistent volume management","description":"Provides Mounts and Volumes abstractions for attaching local directories and persistent network storage to remote functions. Mounts enable read-only or read-write access to local files during function execution via NFS-like semantics, while Volumes provide persistent, shared storage across function invocations with distributed dict and queue data structures. Both integrate with Modal's container runtime to handle file synchronization and lifecycle management.","intents":["Access local files (code, data, models) from within remote function execution without uploading them as part of the function package","Share mutable state (dictionaries, queues) across multiple concurrent function invocations","Persist data between function runs without external databases or object storage"],"best_for":["Data processing pipelines requiring large input files or model artifacts","Distributed applications needing inter-process communication (queues, shared state)","Development workflows where local code changes should be reflected in remote execution"],"limitations":["Mounts add network latency for file access (NFS-like semantics); not suitable for high-frequency random I/O","Volumes are in-memory by default; no built-in persistence to external storage (S3, GCS) — requires manual serialization","Distributed dict/queue operations are not ACID-compliant; eventual consistency model with potential data loss on container restart"],"requires":["Python 3.8+","Modal API credentials","Local file paths accessible from client machine (for Mounts)","Network connectivity to Modal backend"],"input_types":["Local file system paths (for Mounts)","Python objects (for Volumes/DistributedDict)","Serializable data structures (for queues)"],"output_types":["File handles and directory listings (from Mounts)","Python objects retrieved from Volumes","Queue items (FIFO order)"],"categories":["memory-knowledge","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-modal__cap_3","uri":"capability://safety.moderation.secrets.and.environment.variable.injection.with.secure.credential.management","name":"secrets and environment variable injection with secure credential management","description":"Manages sensitive credentials and environment variables through a Secret abstraction that stores encrypted values in Modal's backend and injects them into container environments at runtime. Secrets are defined via modal.Secret.from_dict() or environment variable references, then attached to functions via the secrets parameter. The system uses gRPC with TLS to transmit secrets securely and prevents them from appearing in logs or function code.","intents":["Pass API keys, database credentials, and other secrets to remote functions without hardcoding them in source code","Manage environment-specific configuration (dev/staging/prod) without code changes","Ensure secrets are never logged or exposed in function output"],"best_for":["Production deployments requiring secure credential management","Teams with compliance requirements (PCI-DSS, SOC2) for secret handling","Multi-environment deployments (dev, staging, prod) with different credentials"],"limitations":["Secrets are stored in Modal's backend; no option for customer-managed key encryption (CMKE)","Secret rotation requires redeploying functions; no dynamic secret refresh without restart","Limited to environment variable injection; no support for file-based secrets (e.g., mounted certificates)"],"requires":["Python 3.8+","Modal API credentials with secret management permissions","Environment variables or dict-based secret definitions"],"input_types":["Dictionary of key-value pairs (via modal.Secret.from_dict())","Environment variable names (via modal.Secret.from_name())"],"output_types":["Environment variables injected into container (accessible via os.environ)","Secret metadata (name, creation timestamp)"],"categories":["safety-moderation","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-modal__cap_4","uri":"capability://automation.workflow.class.based.stateful.service.definition.with.lifecycle.hooks","name":"class-based stateful service definition with lifecycle hooks","description":"Enables definition of stateful services using @app.cls() decorator on Python classes, where instance methods become remotely callable functions. The system supports lifecycle hooks (@modal.enter and @modal.exit) for initialization and cleanup, allowing services to maintain state (database connections, model caches, GPU memory) across multiple invocations. State is preserved in container memory and shared across concurrent requests to the same instance.","intents":["Define services that maintain expensive state (ML models, database connections) across multiple invocations","Initialize resources once and reuse them across many function calls to reduce latency and cost","Implement cleanup logic (closing connections, freeing GPU memory) that runs when the service shuts down"],"best_for":["Machine learning inference services requiring model loading once per container","Database-backed applications needing persistent connection pools","Services with expensive initialization (GPU setup, large file loading)"],"limitations":["State is not shared across multiple container instances; each instance maintains its own copy (no distributed state without Volumes)","Lifecycle hooks run once per container, not per invocation; cleanup may be delayed if containers are kept alive for reuse","No automatic state serialization; complex state objects must be manually managed or stored in Volumes"],"requires":["Python 3.8+","Modal API credentials","Class definition with @app.cls() decorator"],"input_types":["Method arguments (same as function inputs)","Instance state (Python objects stored in self)"],"output_types":["Method return values","Instance state modifications (persisted across invocations)"],"categories":["automation-workflow","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-modal__cap_5","uri":"capability://tool.use.integration.web.endpoint.exposure.and.http.request.handling","name":"web endpoint exposure and http request handling","description":"Exposes remote functions as HTTP endpoints using @app.function(image=...).web_endpoint() or @app.web_endpoint() decorators, automatically generating URL routes and handling HTTP request/response serialization. The system manages HTTPS termination, request routing, and response formatting, allowing functions to receive HTTP requests and return JSON/HTML responses without explicit web framework setup.","intents":["Expose a Python function as a public HTTP API without setting up a web server or reverse proxy","Handle HTTP requests (GET, POST, etc.) and return JSON responses from serverless functions","Create simple webhooks or API endpoints for third-party integrations"],"best_for":["Rapid prototyping of APIs without web framework boilerplate","Simple webhook handlers or notification endpoints","Exposing ML inference services as REST APIs"],"limitations":["Limited HTTP customization; no direct control over status codes, headers, or streaming responses","No built-in authentication/authorization; requires manual request validation","Request body size limits (typically 10MB); large file uploads require alternative approaches","No built-in rate limiting or DDoS protection; requires external API gateway"],"requires":["Python 3.8+","Modal API credentials","Function decorated with @app.function() or @app.web_endpoint()"],"input_types":["HTTP request body (JSON, form data, raw bytes)","Query parameters","HTTP headers"],"output_types":["JSON responses","HTML responses","Raw bytes (with appropriate Content-Type)"],"categories":["tool-use-integration","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-modal__cap_6","uri":"capability://automation.workflow.batch.processing.with.concurrent.input.handling.and.automatic.scaling","name":"batch processing with concurrent input handling and automatic scaling","description":"Enables batch processing of multiple inputs via @app.function().batch() or @app.function().map() methods, which automatically parallelize execution across Modal's infrastructure. The system queues inputs, distributes them to available container instances, and collects results, with automatic scaling based on queue depth and configured concurrency limits. Supports both eager (wait for all results) and lazy (streaming results) evaluation modes.","intents":["Process large datasets by distributing work across multiple concurrent function invocations","Map a function over a list of inputs and collect results without manual parallelization","Automatically scale execution based on input queue depth without manual resource provisioning"],"best_for":["Data processing pipelines (ETL, batch inference, image processing)","Embarrassingly parallel workloads with independent inputs","Teams without Kubernetes/distributed systems expertise"],"limitations":["Batch operations are not atomic; partial failures don't automatically trigger rollback or retry of entire batch","Results are collected in memory; very large result sets (>1GB) may cause memory issues","No built-in deduplication; duplicate inputs are processed multiple times","Concurrency limits are per-function, not per-app; no global resource pooling across functions"],"requires":["Python 3.8+","Modal API credentials","Function decorated with @app.function()"],"input_types":["Iterable of inputs (list, generator, etc.)","Serializable objects"],"output_types":["List of results (eager evaluation)","Generator of results (lazy evaluation)"],"categories":["automation-workflow","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-modal__cap_7","uri":"capability://automation.workflow.autoscaling.configuration.with.concurrency.and.resource.limits","name":"autoscaling configuration with concurrency and resource limits","description":"Configures automatic scaling behavior via @app.function(concurrency_limit=N, allow_concurrent_inputs=True/False) parameters, which control how many concurrent invocations a function can handle and whether inputs are queued or rejected. The system monitors queue depth and container utilization, automatically spawning new containers up to configured limits and terminating idle containers. Scaling decisions are made server-side based on metrics collected from the Modal backend.","intents":["Control how many concurrent requests a function can handle without manual container management","Prevent resource exhaustion by setting hard limits on concurrent invocations","Enable automatic scaling based on demand without manual intervention"],"best_for":["Production services with variable load (web APIs, webhooks)","Resource-constrained functions (GPU inference, database-backed services)","Teams without Kubernetes expertise"],"limitations":["Scaling decisions are made server-side; no client-side visibility into scaling metrics or queue depth","Cold start latency is not optimized; new containers may take 5-30 seconds to become available","No predictive scaling; scaling reacts to current demand rather than anticipating future load","Concurrency limits are per-function, not per-app; no global resource pooling"],"requires":["Python 3.8+","Modal API credentials","Function decorated with @app.function()"],"input_types":["Concurrency limit (integer)","Boolean flag for concurrent input handling"],"output_types":["Scaling metrics (server-side only, not exposed to client)"],"categories":["automation-workflow","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-modal__cap_8","uri":"capability://automation.workflow.error.handling.and.automatic.retry.logic.with.exponential.backoff","name":"error handling and automatic retry logic with exponential backoff","description":"Implements automatic retry logic via @app.function(retries=N) parameter and exponential backoff strategy for transient failures. The system catches exceptions during function execution, logs them, and automatically retries up to N times with exponential backoff delays. Retries are transparent to the caller and can be configured per-function with custom retry conditions via custom exception handling.","intents":["Automatically retry failed function invocations due to transient network errors or temporary resource unavailability","Reduce manual error handling code by delegating retries to the Modal runtime","Implement resilient distributed systems without explicit retry logic in application code"],"best_for":["Functions calling external APIs or databases prone to transient failures","Distributed systems requiring resilience to temporary outages","Teams wanting to reduce boilerplate error handling code"],"limitations":["Retries are not idempotent by default; functions with side effects may execute multiple times","Exponential backoff delays are fixed; no custom backoff strategies (e.g., jitter, linear backoff)","Retry logic is function-level only; no cross-function retry orchestration or circuit breakers","No visibility into retry attempts; logs show final result but not intermediate failures"],"requires":["Python 3.8+","Modal API credentials","Function decorated with @app.function(retries=N)"],"input_types":["Retry count (integer)","Exception types (optional, for custom retry conditions)"],"output_types":["Function result (after successful retry or final failure)","Exception (if all retries exhausted)"],"categories":["automation-workflow","safety-moderation"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-modal__cap_9","uri":"capability://automation.workflow.local.development.and.testing.with.mock.server.and.hot.reloading","name":"local development and testing with mock server and hot reloading","description":"Provides local development capabilities via modal.run() for executing functions locally and a mock server for testing without deploying to Modal's infrastructure. The system supports hot reloading of code changes during development, allowing developers to iterate quickly. Local execution uses the same function definitions as production but runs in the local Python environment, enabling debugging with standard tools (pdb, IDE breakpoints).","intents":["Test and debug functions locally before deploying to Modal's infrastructure","Iterate quickly on function code with hot reloading without manual redeploy","Use standard Python debugging tools (pdb, IDE breakpoints) on serverless functions"],"best_for":["Development workflows requiring rapid iteration and debugging","Teams without access to production infrastructure during development","Debugging complex function logic before cloud deployment"],"limitations":["Local execution doesn't replicate container environment; missing system dependencies or environment variables may cause local-only failures","Hot reloading doesn't work for all code changes (e.g., decorator parameters, Image definitions); some changes require manual restart","Mock server has limited HTTP feature support compared to production (no streaming, limited header handling)","Local execution is single-threaded; concurrent execution behavior is not replicated"],"requires":["Python 3.8+","Modal SDK installed locally","No Modal API credentials required for local-only testing"],"input_types":["Function definitions (same as production)","Test inputs (same as production)"],"output_types":["Function results (same as production)","Debug output (stdout, stderr)"],"categories":["automation-workflow","code-generation-editing"],"confidence":0.5,"matches":0,"success_rate":0}],"trust":{"score":33,"verified":false,"data_access_risk":"high","permissions":["Python 3.8+","Modal API credentials (token/workspace setup)","Network connectivity to Modal backend (gRPC endpoint)","Modal API credentials","requirements.txt or pyproject.toml for dependency specification","gRPC Python library (included in modal package)","TLS certificates for secure communication (managed by Modal)","Modal API credentials with deployment permissions","App object with defined functions/classes","Modal SDK installed (pip install modal)"],"failure_modes":["Functions must be picklable or use Modal's serialization system — complex closures or unpicklable objects require workarounds","Execution latency includes container startup time (cold starts) unless using persistent containers or lifecycle hooks","Limited to Python; no native support for polyglot execution within a single function definition","Image building happens server-side; local Docker daemon is not used, limiting offline development workflows","Large dependency sets (100+ packages) can increase deployment latency by 30-60 seconds on first build","Custom system packages require Dockerfile-style commands; no direct shell access during image build","gRPC adds complexity compared to REST; debugging requires gRPC-aware tools (grpcurl, Postman gRPC support)","Protocol Buffer definitions must be maintained in sync with Python code; schema changes require code generation","Large messages (>100MB) may hit gRPC size limits; requires manual chunking or alternative transport","Connection pooling adds memory overhead; not suitable for extremely resource-constrained environments","builder identity is not verified yet","no observed match outcomes yet"],"rank_breakdown":{"adoption":0.05,"quality":0.35,"ecosystem":0.55,"match_graph":0.25,"freshness":0.9,"weights":{"adoption":0.3,"quality":0.2,"ecosystem":0.15,"match_graph":0.23,"freshness":0.12}},"observed_outcomes":{"matches":0,"success_rate":0,"avg_confidence":0,"top_intents":[],"last_matched_at":null},"maintenance":{"status":"active","updated_at":"2026-05-24T12:16:25.060Z","last_scraped_at":"2026-05-03T15:20:19.404Z","last_commit":null},"community":{"stars":null,"forks":null,"weekly_downloads":null,"model_downloads":null,"model_likes":null}},"distribution":{"claim_url":"https://unfragile.ai/submit?claim=pypi-modal","compare_url":"https://unfragile.ai/compare?artifact=pypi-modal"}},"signature":"tsx+VseBgdWQc96PKVSx6DgcTjwP4J4/TuLqs4xYiPiEnaog60DWsA/BfhneWsT5hvW4NyqIg/wX1FfXAUA+DA==","signedAt":"2026-06-17T01:11:32.877Z","signedBy":"unfragile.ai","version":1},"_links":{"self":"https://unfragile.ai/api/v1/passport/pypi-modal","artifact":"https://unfragile.ai/pypi-modal","verify":"https://unfragile.ai/api/v1/verify?slug=pypi-modal","publicKey":"https://unfragile.ai/api/v1/trust-passport-public-key","spec":"https://unfragile.ai/trust","schema":"https://unfragile.ai/schema.json","docs":"https://unfragile.ai/docs"}}