<p align="center">
<a href="https://docs.jina.ai"><img src="https://github.com/jina-ai/jina/blob/master/docs/_static/logo-light.svg?raw=true" alt="Jina logo: Build multimodal AI services via cloud native technologies · Model Serving · Generative AI · Neural Search · Cloud Native" width="150px"></a>
</p>
<p align="center">
<b>Build multimodal AI applications with cloud-native technologies</b>
</p>
<p align=center>
<a href="https://pypi.org/project/jina/"><img alt="PyPI" src="https://img.shields.io/pypi/v/jina?label=Release&style=flat-square"></a>
<!--<a href="https://codecov.io/gh/jina-ai/jina"><img alt="Codecov branch" src="https://img.shields.io/codecov/c/github/jina-ai/jina/master?&logo=Codecov&logoColor=white&style=flat-square"></a>-->
<a href="https://discord.jina.ai"><img src="https://img.shields.io/discord/1106542220112302130?logo=discord&logoColor=white&style=flat-square"></a>
<a href="https://pypistats.org/packages/jina"><img alt="PyPI - Downloads from official pypistats" src="https://img.shields.io/pypi/dm/jina?style=flat-square"></a>
<a href="https://github.com/jina-ai/jina/actions/workflows/cd.yml"><img alt="Github CD status" src="https://github.com/jina-ai/jina/actions/workflows/cd.yml/badge.svg"></a>
</p>
<!-- start jina-description -->
Jina lets you build multimodal [**AI services**](#build-ai-models) and [**pipelines**](#build-a-pipeline) that communicate via gRPC, HTTP and WebSockets, then scale them up and deploy to production. You can focus on your logic and algorithms, without worrying about the infrastructure complexity.
Jina provides a smooth Pythonic experience for serving ML models transitioning from local deployment to advanced orchestration frameworks like Docker-Compose, Kubernetes, or Jina AI Cloud. Jina makes advanced solution engineering and cloud-native technologies accessible to every developer.
- Build and serve models for any [data type](https://docs.docarray.org/data_types/first_steps/) and any mainstream [deep learning framework](https://docarray.org/docarray/how_to/multimodal_training_and_serving/).
- Design high-performance services, with [easy scaling](https://docs.jina.ai/concepts/orchestration/scale-out/), duplex client-server streaming, batching, [dynamic batching](https://docs.jina.ai/concepts/serving/executor/dynamic-batching/), async/non-blocking data processing and any [protocol](https://docs.jina.ai/concepts/serving/gateway/#set-protocol-in-python).
- Serve [LLM models while streaming their output](https://github.com/jina-ai/jina#streaming-for-llms).
- Docker container integration via [Executor Hub](https://cloud.jina.ai), OpenTelemetry/Prometheus observability.
- Streamlined CPU/GPU hosting via [Jina AI Cloud](https://cloud.jina.ai).
- Deploy to your own cloud or system with our [Kubernetes](https://docs.jina.ai/cloud-nativeness/k8s/) and [Docker Compose](https://docs.jina.ai/cloud-nativeness/docker-compose/) integration.
<details>
<summary><strong>Wait, how is Jina different from FastAPI?</strong></summary>
Jina's value proposition may seem quite similar to that of FastAPI. However, there are several fundamental differences:
**Data structure and communication protocols**
- FastAPI communication relies on Pydantic and Jina relies on [DocArray](https://github.com/docarray/docarray) allowing Jina to support multiple protocols
to expose its services. The support for gRPC protocol is specially useful for data intensive applications as for embedding services
where the embeddings and tensors can be more efficiently serialized.
**Advanced orchestration and scaling capabilities**
- Jina allows you to easily containerize and orchestrate your services and models, providing concurrency and scalability.
- Jina lets you deploy applications formed from multiple microservices that can be containerized and scaled independently.
**Journey to the cloud**
- Jina provides a smooth transition from local development (using [DocArray](https://github.com/docarray/docarray)) to local serving using [Deployment](https://docs.jina.ai/concepts/orchestration/deployment/) and [Flow](https://docs.jina.ai/concepts/orchestration/flow/)
to having production-ready services by using Kubernetes capacity to orchestrate the lifetime of containers.
- By using [Jina AI Cloud](https://cloud.jina.ai) you have access to scalable and serverless deployments of your applications in one command.
</details>
<!-- end jina-description -->
## [Documentation](https://docs.jina.ai)
## Install
```bash
pip install jina
```
Find more install options on [Apple Silicon](https://docs.jina.ai/get-started/install/apple-silicon-m1-m2/)/[Windows](https://docs.jina.ai/get-started/install/windows/).
## Get Started
### Basic Concepts
Jina has three fundamental layers:
- Data layer: [**BaseDoc**](https://docarray.docs.org/) and [**DocList**](https://docarray.docs.org/) (from [DocArray](https://github.com/docarray/docarray)) are the input/output formats in Jina.
- Serving layer: An [**Executor**](https://docs.jina.ai/concepts/serving/executor/) is a Python class that transforms and processes Documents. By simply wrapping your models into an Executor, you allow them to be served and scaled by Jina. [**Gateway**](https://docs.jina.ai/concepts/serving/gateway/) is the service making sure connecting all Executors inside a Flow.
- Orchestration layer: [**Deployment**](https://docs.jina.ai/concepts/orchestration/deployment) serves a single Executor, while a [**Flow**](https://docs.jina.ai/concepts/orchestration/flow/) serves Executors chained into a pipeline.
[The full glossary is explained here](https://docs.jina.ai/concepts/preliminaries/#).
### Serve AI models
<!-- start build-ai-services -->
Let's build a fast, reliable and scalable gRPC-based AI service. In Jina we call this an **[Executor](https://docs.jina.ai/concepts/serving/executor/)**. Our simple Executor will wrap the [StableLM](https://huggingface.co/stabilityai/stablelm-base-alpha-3b) LLM from Stability AI. We'll then use a **Deployment** to serve it.
> **Note**
> A Deployment serves just one Executor. To combine multiple Executors into a pipeline and serve that, use a [Flow](#build-a-pipeline).
Let's implement the service's logic:
<table>
<tr>
<th><code>executor.py</code></th>
<tr>
<td>
```python
from jina import Executor, requests
from docarray import DocList, BaseDoc
from transformers import pipeline
class Prompt(BaseDoc):
text: str
class Generation(BaseDoc):
prompt: str
text: str
class StableLM(Executor):
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.generator = pipeline(
'text-generation', model='stabilityai/stablelm-base-alpha-3b'
)
@requests
def generate(self, docs: DocList[Prompt], **kwargs) -> DocList[Generation]:
generations = DocList[Generation]()
prompts = docs.text
llm_outputs = self.generator(prompts)
for prompt, output in zip(prompts, llm_outputs):
generations.append(Generation(prompt=prompt, text=output))
return generations
```
</td>
</tr>
</table>
Then we deploy it with either the Python API or YAML:
<div class="table-wrapper">
<table>
<tr>
<th> Python API: <code>deployment.py</code> </th>
<th> YAML: <code>deployment.yml</code> </th>
</tr>
<tr>
<td>
```python
from jina import Deployment
from executor import StableLM
dep = Deployment(uses=StableLM, timeout_ready=-1, port=12345)
with dep:
dep.block()
```
</td>
<td>
```yaml
jtype: Deployment
with:
uses: StableLM
py_modules:
- executor.py
timeout_ready: -1
port: 12345
```
And run the YAML Deployment with the CLI: `jina deployment --uses deployment.yml`
</td>
</tr>
</table>
</div>
Use [Jina Client](https://docs.jina.ai/concepts/client/) to make requests to the service:
```python
from jina import Client
from docarray import DocList, BaseDoc
class Prompt(BaseDoc):
text: str
class Generation(BaseDoc):
prompt: str
text: str
prompt = Prompt(
text='suggest an interesting image generation prompt for a mona lisa variant'
)
client = Client(port=12345) # use port from output above
response = client.post(on='/', inputs=[prompt], return_type=DocList[Generation])
print(response[0].text)
```
```text
a steampunk version of the Mona Lisa, incorporating mechanical gears, brass elements, and Victorian era clothing details
```
<!-- end build-ai-services -->
> **Note**
> In a notebook, you can't use `deployment.block()` and then make requests to the client. Please refer to the Colab link above for reproducible Jupyter Notebook code snippets.
### Build a pipeline
<!-- start build-pipelines -->
Sometimes you want to chain microservices together into a pipeline. That's where a [Flow](https://docs.jina.ai/concepts/orchestration/flow/) comes in.
A Flow is a [DAG](https://en.wikipedia.org/wiki/Directed_acyclic_graph) pipeline, composed of a set of steps, It orchestrates a set of [Executors](https://docs.jina.ai/concepts/serving/executor/) and a [Gateway](https://docs.jina.ai/concepts/serving/gateway/) to offer an end-to-end service.
> **Note**
> If you just want to serve a single Executor, you can use a [Deployment](#build-ai--ml-services).
For instance, let's combine [our StableLM language model](#build-ai--ml-services) with a Stable Diffusion image generation model. Chaining these services together into a [Flow](https://docs.jina.ai/concepts/orchestration/flow/) will give us a service that will generate images based on a prompt generated by the LLM.
<table>
<tr>
<th><code>text_to_image.py</code></th>
<tr>
<td>
```python
import numpy as np
from jina import Executor, requests
from docarray import BaseDoc, DocList
from docarray.documents import ImageDoc
class Generation(BaseDoc):
prompt: str
text: str
class TextToImage(Executor):
def __init__(self, **kwargs):
super().__init__(**kwargs)
from diffusers import StableDiffusionPipeline
import torch
self.pipe = StableDiffusionPipeline.from_pretrained(
"CompVis/stable-diffusion-v1-4", torch_dtype=torch.float16
).to("cuda")
@requests
def generate_image(self, docs: DocList[Generation], **kwargs) -> DocList[ImageDoc]:
result = DocList[ImageDoc]()
images = self.pipe(
docs.text
).images # image here is in [PIL format](https://pillow.readthedocs.io/en/stable/)
result.tensor = np.array(images)
return result
```
</td>
</tr>
</table>
Build the Flow with either Python or YAML:
<div class="table-wrapper">
<table>
<tr>
<th> Python API: <code>flow.py</code> </th>
<th> YAML: <code>flow.yml</code> </th>
</tr>
<tr>
<td>
```python
from jina import Flow
from executor import StableLM
from text_to_image import TextToImage
flow = (
Flow(port=12345)
.add(uses=StableLM, timeout_ready=-1)
.add(uses=TextToImage, timeout_ready=-1)
)
with flow:
flow.block()
```
</td>
<td>
```yaml
jtype: Flow
with:
port: 12345
executors:
- uses: StableLM
timeout_ready: -1
py_modules:
- executor.py
- uses: TextToImage
timeout_ready: -1
py_modules:
- text_to_image.py
```
Then run the YAML Flow with the CLI: `jina flow --uses flow.yml`
</td>
</tr>
</table>
</div>
Then, use [Jina Client](https://docs.jina.ai/concepts/client/) to make requests to the Flow:
```python
from jina import Client
from docarray import DocList, BaseDoc
from docarray.documents import ImageDoc
class Prompt(BaseDoc):
text: str
prompt = Prompt(
text='suggest an interesting image generation prompt for a mona lisa variant'
)
client = Client(port=12345) # use port from output above
response = client.post(on='/', inputs=[prompt], return_type=DocList[ImageDoc])
response[0].display()
```
<!-- end build-pipelines -->
### Easy scalability and concurrency
Why not just use standard Python to build that service and pipeline? Jina accelerates time to market of your application by making it more scalable and cloud-native. Jina also handles the infrastructure complexity in production and other Day-2 operations so that you can focus on the data application itself.
Increase your application's throughput with scalability features out of the box, like [replicas](https://docs.jina.ai/concepts/orchestration/scale-out/#replicate-executors), [shards](https://docs.jina.ai/concepts/orchestration/scale-out/#customize-polling-behaviors) and [dynamic batching](https://docs.jina.ai/concepts/serving/executor/dynamic-batching/).
Let's scale a Stable Diffusion Executor deployment with replicas and dynamic batching:
* Create two replicas, with [a GPU assigned for each](https://docs.jina.ai/concepts/orchestration/scale-out/#replicate-on-multiple-gpus).
* Enable dynamic batching to process incoming parallel requests together with the same model inference.
<div class="table-wrapper">
<table>
<tr>
<th> Normal Deployment </th>
<th> Scaled Deployment </th>
</tr>
<tr>
<td>
```yaml
jtype: Deployment
with:
uses: TextToImage
timeout_ready: -1
py_modules:
- text_to_image.py
```
</td>
<td>
```yaml
jtype: Deployment
with:
uses: TextToImage
timeout_ready: -1
py_modules:
- text_to_image.py
env:
CUDA_VISIBLE_DEVICES: RR
replicas: 2
uses_dynamic_batching: # configure dynamic batching
/default:
preferred_batch_size: 10
timeout: 200
```
</td>
</tr>
</table>
</div>
Assuming your machine has two GPUs, using the scaled deployment YAML will give better throughput compared to the normal deployment.
These features apply to both [Deployment YAML](https://docs.jina.ai/concepts/orchestration/yaml-spec/#example-yaml) and [Flow YAML](https://docs.jina.ai/concepts/orchestration/yaml-spec/#example-yaml). Thanks to the YAML syntax, you can inject deployment configurations regardless of Executor code.
## Deploy to the cloud
### Containerize your Executor
In order to deploy your solutions to the cloud, you need to containerize your services. Jina provides the [Executor Hub](https://docs.jina.ai/concepts/serving/executor/hub/create-hub-executor/), the perfect tool
to streamline this process taking a lot of the troubles with you. It also lets you share these Executors publicly or privately.
You just need to structure your Executor in a folder:
```shell script
TextToImage/
├── executor.py
├── config.yml
├── requirements.txt
```
<div class="table-wrapper">
<table>
<tr>
<th> <code>config.yml</code> </th>
<th> <code>requirements.txt</code> </th>
</tr>
<tr>
<td>
```yaml
jtype: TextToImage
py_modules:
- executor.py
metas:
name: TextToImage
description: Text to Image generation Executor based on StableDiffusion
url:
keywords: []
```
</td>
<td>
```requirements.txt
diffusers
accelerate
transformers
```
</td>
</tr>
</table>
</div>
Then push the Executor to the Hub by doing: `jina hub push TextToImage`.
This will give you a URL that you can use in your `Deployment` and `Flow` to use the pushed Executors containers.
```yaml
jtype: Flow
with:
port: 12345
executors:
- uses: jinai+docker://<user-id>/StableLM
- uses: jinai+docker://<user-id>/TextToImage
```
### Get on the fast lane to cloud-native
Using Kubernetes with Jina is easy:
```bash
jina export kubernetes flow.yml ./my-k8s
kubectl apply -R -f my-k8s
```
And so is Docker Compose:
```bash
jina export docker-compose flow.yml docker-compose.yml
docker-compose up
```
> **Note**
> You can also export Deployment YAML to [Kubernetes](https://docs.jina.ai/concepts/serving/executor/serve/#serve-via-kubernetes) and [Docker Compose](https://docs.jina.ai/concepts/serving/executor/serve/#serve-via-docker-compose).
That's not all. We also support [OpenTelemetry, Prometheus, and Jaeger](https://docs.jina.ai/cloud-nativeness/opentelemetry/).
What cloud-native technology is still challenging to you? [Tell us](https://github.com/jina-ai/jina/issues) and we'll handle the complexity and make it easy for you.
### Deploy to JCloud
You can also deploy a Flow to JCloud, where you can easily enjoy autoscaling, monitoring and more with a single command.
First, turn the `flow.yml` file into a [JCloud-compatible YAML](https://docs.jina.ai/yaml-spec/) by specifying resource requirements and using containerized Hub Executors.
Then, use `jina cloud deploy` command to deploy to the cloud:
```shell
wget https://raw.githubusercontent.com/jina-ai/jina/master/.github/getting-started/jcloud-flow.yml
jina cloud deploy jcloud-flow.yml
```
> **Warning**
>
> Make sure to delete/clean up the Flow once you are done with this tutorial to save resources and credits.
Read more about [deploying Flows to JCloud](https://docs.jina.ai/concepts/jcloud/#deploy).
### Streaming for LLMs
<!-- start llm-streaming-intro -->
Large Language Models can power a wide range of applications from chatbots to assistants and intelligent systems.
However, these models can be heavy and slow and your users want systems that are both intelligent _and_ fast!
Large language models work by turning your questions into tokens and then generating new token one at a
time until it decides that generation should stop.
This means you want to **stream** the output tokens generated by a large language model to the client.
In this tutorial, we will discuss how to achieve this with Streaming Endpoints in Jina.
<!-- end llm-streaming-intro -->
#### Service Schemas
<!-- start llm-streaming-schemas -->
The first step is to define the streaming service schemas, as you would do in any other service framework.
The input to the service is the prompt and the maximum number of tokens to generate, while the output is simply the
token ID:
```python
from docarray import BaseDoc
class PromptDocument(BaseDoc):
prompt: str
max_tokens: int
class ModelOutputDocument(BaseDoc):
token_id: int
generated_text: str
```
<!-- end llm-streaming-schemas -->
#### Service initialization
<!-- start llm-streaming-init -->
Our service depends on a large language model. As an example, we will use the `gpt2` model. This is how you would load
such a model in your executor
```python
from jina import Executor, requests
from transformers import GPT2Tokenizer, GPT2LMHeadModel
import torch
tokenizer = GPT2Tokenizer.from_pretrained('gpt2')
class TokenStreamingExecutor(Executor):
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.model = GPT2LMHeadModel.from_pretrained('gpt2')
```
<!-- end llm-streaming-init -->
#### Implement the streaming endpoint
<!-- start llm-streaming-endpoint -->
Our streaming endpoint accepts a `PromptDocument` as input and streams `ModelOutputDocument`s. To stream a document back to
the client, use the `yield` keyword in the endpoint implementation. Therefore, we use the model to generate
up to `max_tokens` tokens and yield them until the generation stops:
```python
class TokenStreamingExecutor(Executor):
...
@requests(on='/stream')
async def task(self, doc: PromptDocument, **kwargs) -> ModelOutputDocument:
input = tokenizer(doc.prompt, return_tensors='pt')
input_len = input['input_ids'].shape[1]
for _ in range(doc.max_tokens):
output = self.model.generate(**input, max_new_tokens=1)
if output[0][-1] == tokenizer.eos_token_id:
break
yield ModelOutputDocument(
token_id=output[0][-1],
generated_text=tokenizer.decode(
output[0][input_len:], skip_special_tokens=True
),
)
input = {
'input_ids': output,
'attention_mask': torch.ones(1, len(output[0])),
}
```
Learn more about [streaming endpoints](https://docs.jina.ai/concepts/serving/executor/add-endpoints/#streaming-endpoints) from the `Executor` documentation.
<!-- end llm-streaming-endpoint -->
#### Serve and send requests
<!-- start llm-streaming-serve -->
The final step is to serve the Executor and send requests using the client.
To serve the Executor using gRPC:
```python
from jina import Deployment
with Deployment(uses=TokenStreamingExecutor, port=12345, protocol='grpc') as dep:
dep.block()
```
To send requests from a client:
```python
import asyncio
from jina import Client
async def main():
client = Client(port=12345, protocol='grpc', asyncio=True)
async for doc in client.stream_doc(
on='/stream',
inputs=PromptDocument(prompt='what is the capital of France ?', max_tokens=10),
return_type=ModelOutputDocument,
):
print(doc.generated_text)
asyncio.run(main())
```
```text
The
The capital
The capital of
The capital of France
The capital of France is
The capital of France is Paris
The capital of France is Paris.
```
<!-- end llm-streaming-serve -->
<!-- start support-pitch -->
## Support
- Join our [Discord community](https://discord.jina.ai) and chat with other community members about ideas.
- Subscribe to the latest video tutorials on our [YouTube channel](https://youtube.com/c/jina-ai)
## Join Us
Jina is backed by [Jina AI](https://jina.ai) and licensed under [Apache-2.0](./LICENSE).
<!-- end support-pitch -->
Raw data
{
"_id": null,
"home_page": "https://github.com/jina-ai/jina/",
"name": "jina",
"maintainer": null,
"docs_url": null,
"requires_python": null,
"maintainer_email": null,
"keywords": "jina cloud-native cross-modal multimodal neural-search query search index elastic neural-network encoding embedding serving docker container image video audio deep-learning mlops",
"author": "Jina AI",
"author_email": "hello@jina.ai",
"download_url": "https://files.pythonhosted.org/packages/ea/e5/400db7c387380c4e909326ec0987984b4298144ba1cdc476238520f079b1/jina-3.25.1.tar.gz",
"platform": null,
"description": "<p align=\"center\">\n<a href=\"https://docs.jina.ai\"><img src=\"https://github.com/jina-ai/jina/blob/master/docs/_static/logo-light.svg?raw=true\" alt=\"Jina logo: Build multimodal AI services via cloud native technologies \u00b7 Model Serving \u00b7 Generative AI \u00b7 Neural Search \u00b7 Cloud Native\" width=\"150px\"></a>\n</p>\n\n<p align=\"center\">\n<b>Build multimodal AI applications with cloud-native technologies</b>\n</p>\n\n<p align=center>\n<a href=\"https://pypi.org/project/jina/\"><img alt=\"PyPI\" src=\"https://img.shields.io/pypi/v/jina?label=Release&style=flat-square\"></a>\n<!--<a href=\"https://codecov.io/gh/jina-ai/jina\"><img alt=\"Codecov branch\" src=\"https://img.shields.io/codecov/c/github/jina-ai/jina/master?&logo=Codecov&logoColor=white&style=flat-square\"></a>-->\n<a href=\"https://discord.jina.ai\"><img src=\"https://img.shields.io/discord/1106542220112302130?logo=discord&logoColor=white&style=flat-square\"></a>\n<a href=\"https://pypistats.org/packages/jina\"><img alt=\"PyPI - Downloads from official pypistats\" src=\"https://img.shields.io/pypi/dm/jina?style=flat-square\"></a>\n<a href=\"https://github.com/jina-ai/jina/actions/workflows/cd.yml\"><img alt=\"Github CD status\" src=\"https://github.com/jina-ai/jina/actions/workflows/cd.yml/badge.svg\"></a>\n</p>\n\n<!-- start jina-description -->\n\nJina lets you build multimodal [**AI services**](#build-ai-models) and [**pipelines**](#build-a-pipeline) that communicate via gRPC, HTTP and WebSockets, then scale them up and deploy to production. You can focus on your logic and algorithms, without worrying about the infrastructure complexity.\n\n\n\nJina provides a smooth Pythonic experience for serving ML models transitioning from local deployment to advanced orchestration frameworks like Docker-Compose, Kubernetes, or Jina AI Cloud. Jina makes advanced solution engineering and cloud-native technologies accessible to every developer.\n\n- Build and serve models for any [data type](https://docs.docarray.org/data_types/first_steps/) and any mainstream [deep learning framework](https://docarray.org/docarray/how_to/multimodal_training_and_serving/).\n- Design high-performance services, with [easy scaling](https://docs.jina.ai/concepts/orchestration/scale-out/), duplex client-server streaming, batching, [dynamic batching](https://docs.jina.ai/concepts/serving/executor/dynamic-batching/), async/non-blocking data processing and any [protocol](https://docs.jina.ai/concepts/serving/gateway/#set-protocol-in-python).\n- Serve [LLM models while streaming their output](https://github.com/jina-ai/jina#streaming-for-llms).\n- Docker container integration via [Executor Hub](https://cloud.jina.ai), OpenTelemetry/Prometheus observability.\n- Streamlined CPU/GPU hosting via [Jina AI Cloud](https://cloud.jina.ai).\n- Deploy to your own cloud or system with our [Kubernetes](https://docs.jina.ai/cloud-nativeness/k8s/) and [Docker Compose](https://docs.jina.ai/cloud-nativeness/docker-compose/) integration.\n\n<details>\n <summary><strong>Wait, how is Jina different from FastAPI?</strong></summary>\nJina's value proposition may seem quite similar to that of FastAPI. However, there are several fundamental differences:\n\n **Data structure and communication protocols**\n - FastAPI communication relies on Pydantic and Jina relies on [DocArray](https://github.com/docarray/docarray) allowing Jina to support multiple protocols\n to expose its services. The support for gRPC protocol is specially useful for data intensive applications as for embedding services\n where the embeddings and tensors can be more efficiently serialized.\n\n **Advanced orchestration and scaling capabilities**\n - Jina allows you to easily containerize and orchestrate your services and models, providing concurrency and scalability.\n - Jina lets you deploy applications formed from multiple microservices that can be containerized and scaled independently.\n\n **Journey to the cloud**\n - Jina provides a smooth transition from local development (using [DocArray](https://github.com/docarray/docarray)) to local serving using [Deployment](https://docs.jina.ai/concepts/orchestration/deployment/) and [Flow](https://docs.jina.ai/concepts/orchestration/flow/)\n to having production-ready services by using Kubernetes capacity to orchestrate the lifetime of containers.\n - By using [Jina AI Cloud](https://cloud.jina.ai) you have access to scalable and serverless deployments of your applications in one command.\n</details>\n\n<!-- end jina-description -->\n\n## [Documentation](https://docs.jina.ai)\n\n## Install \n\n```bash\npip install jina\n```\n\nFind more install options on [Apple Silicon](https://docs.jina.ai/get-started/install/apple-silicon-m1-m2/)/[Windows](https://docs.jina.ai/get-started/install/windows/).\n\n## Get Started\n\n### Basic Concepts\n\nJina has three fundamental layers:\n\n- Data layer: [**BaseDoc**](https://docarray.docs.org/) and [**DocList**](https://docarray.docs.org/) (from [DocArray](https://github.com/docarray/docarray)) are the input/output formats in Jina.\n- Serving layer: An [**Executor**](https://docs.jina.ai/concepts/serving/executor/) is a Python class that transforms and processes Documents. By simply wrapping your models into an Executor, you allow them to be served and scaled by Jina. [**Gateway**](https://docs.jina.ai/concepts/serving/gateway/) is the service making sure connecting all Executors inside a Flow.\n- Orchestration layer: [**Deployment**](https://docs.jina.ai/concepts/orchestration/deployment) serves a single Executor, while a [**Flow**](https://docs.jina.ai/concepts/orchestration/flow/) serves Executors chained into a pipeline.\n\n\n[The full glossary is explained here](https://docs.jina.ai/concepts/preliminaries/#).\n\n### Serve AI models\n<!-- start build-ai-services -->\n\nLet's build a fast, reliable and scalable gRPC-based AI service. In Jina we call this an **[Executor](https://docs.jina.ai/concepts/serving/executor/)**. Our simple Executor will wrap the [StableLM](https://huggingface.co/stabilityai/stablelm-base-alpha-3b) LLM from Stability AI. We'll then use a **Deployment** to serve it.\n\n\n\n> **Note**\n> A Deployment serves just one Executor. To combine multiple Executors into a pipeline and serve that, use a [Flow](#build-a-pipeline).\n\nLet's implement the service's logic:\n\n<table>\n<tr>\n<th><code>executor.py</code></th> \n<tr>\n<td>\n\n```python\nfrom jina import Executor, requests\nfrom docarray import DocList, BaseDoc\n\nfrom transformers import pipeline\n\n\nclass Prompt(BaseDoc):\n text: str\n\n\nclass Generation(BaseDoc):\n prompt: str\n text: str\n\n\nclass StableLM(Executor):\n def __init__(self, **kwargs):\n super().__init__(**kwargs)\n self.generator = pipeline(\n 'text-generation', model='stabilityai/stablelm-base-alpha-3b'\n )\n\n @requests\n def generate(self, docs: DocList[Prompt], **kwargs) -> DocList[Generation]:\n generations = DocList[Generation]()\n prompts = docs.text\n llm_outputs = self.generator(prompts)\n for prompt, output in zip(prompts, llm_outputs):\n generations.append(Generation(prompt=prompt, text=output))\n return generations\n```\n\n</td>\n</tr>\n</table>\n\nThen we deploy it with either the Python API or YAML:\n<div class=\"table-wrapper\">\n<table>\n<tr>\n<th> Python API: <code>deployment.py</code> </th> \n<th> YAML: <code>deployment.yml</code> </th>\n</tr>\n<tr>\n<td>\n\n```python\nfrom jina import Deployment\nfrom executor import StableLM\n\ndep = Deployment(uses=StableLM, timeout_ready=-1, port=12345)\n\nwith dep:\n dep.block()\n```\n\n</td>\n<td>\n\n```yaml\njtype: Deployment\nwith:\n uses: StableLM\n py_modules:\n - executor.py\n timeout_ready: -1\n port: 12345\n```\n\nAnd run the YAML Deployment with the CLI: `jina deployment --uses deployment.yml`\n\n</td>\n</tr>\n</table>\n</div>\n\nUse [Jina Client](https://docs.jina.ai/concepts/client/) to make requests to the service:\n\n```python\nfrom jina import Client\nfrom docarray import DocList, BaseDoc\n\n\nclass Prompt(BaseDoc):\n text: str\n\n\nclass Generation(BaseDoc):\n prompt: str\n text: str\n\n\nprompt = Prompt(\n text='suggest an interesting image generation prompt for a mona lisa variant'\n)\n\nclient = Client(port=12345) # use port from output above\nresponse = client.post(on='/', inputs=[prompt], return_type=DocList[Generation])\n\nprint(response[0].text)\n```\n\n```text\na steampunk version of the Mona Lisa, incorporating mechanical gears, brass elements, and Victorian era clothing details\n```\n\n<!-- end build-ai-services -->\n\n> **Note**\n> In a notebook, you can't use `deployment.block()` and then make requests to the client. Please refer to the Colab link above for reproducible Jupyter Notebook code snippets.\n\n### Build a pipeline\n\n<!-- start build-pipelines -->\n\nSometimes you want to chain microservices together into a pipeline. That's where a [Flow](https://docs.jina.ai/concepts/orchestration/flow/) comes in.\n\nA Flow is a [DAG](https://en.wikipedia.org/wiki/Directed_acyclic_graph) pipeline, composed of a set of steps, It orchestrates a set of [Executors](https://docs.jina.ai/concepts/serving/executor/) and a [Gateway](https://docs.jina.ai/concepts/serving/gateway/) to offer an end-to-end service.\n\n> **Note**\n> If you just want to serve a single Executor, you can use a [Deployment](#build-ai--ml-services).\n\nFor instance, let's combine [our StableLM language model](#build-ai--ml-services) with a Stable Diffusion image generation model. Chaining these services together into a [Flow](https://docs.jina.ai/concepts/orchestration/flow/) will give us a service that will generate images based on a prompt generated by the LLM.\n\n\n<table>\n<tr>\n<th><code>text_to_image.py</code></th> \n<tr>\n<td>\n\n```python\nimport numpy as np\nfrom jina import Executor, requests\nfrom docarray import BaseDoc, DocList\nfrom docarray.documents import ImageDoc\n\n\nclass Generation(BaseDoc):\n prompt: str\n text: str\n\n\nclass TextToImage(Executor):\n def __init__(self, **kwargs):\n super().__init__(**kwargs)\n from diffusers import StableDiffusionPipeline\n import torch\n\n self.pipe = StableDiffusionPipeline.from_pretrained(\n \"CompVis/stable-diffusion-v1-4\", torch_dtype=torch.float16\n ).to(\"cuda\")\n\n @requests\n def generate_image(self, docs: DocList[Generation], **kwargs) -> DocList[ImageDoc]:\n result = DocList[ImageDoc]()\n images = self.pipe(\n docs.text\n ).images # image here is in [PIL format](https://pillow.readthedocs.io/en/stable/)\n result.tensor = np.array(images)\n return result\n```\n\n</td>\n</tr>\n</table>\n\n\n\n\nBuild the Flow with either Python or YAML:\n\n<div class=\"table-wrapper\">\n<table>\n<tr>\n<th> Python API: <code>flow.py</code> </th> \n<th> YAML: <code>flow.yml</code> </th>\n</tr>\n<tr>\n<td>\n\n```python\nfrom jina import Flow\nfrom executor import StableLM\nfrom text_to_image import TextToImage\n\nflow = (\n Flow(port=12345)\n .add(uses=StableLM, timeout_ready=-1)\n .add(uses=TextToImage, timeout_ready=-1)\n)\n\nwith flow:\n flow.block()\n```\n\n</td>\n<td>\n\n```yaml\njtype: Flow\nwith:\n port: 12345\nexecutors:\n - uses: StableLM\n timeout_ready: -1\n py_modules:\n - executor.py\n - uses: TextToImage\n timeout_ready: -1\n py_modules:\n - text_to_image.py\n```\n\nThen run the YAML Flow with the CLI: `jina flow --uses flow.yml`\n\n</td>\n</tr>\n</table>\n</div>\n\nThen, use [Jina Client](https://docs.jina.ai/concepts/client/) to make requests to the Flow:\n\n```python\nfrom jina import Client\nfrom docarray import DocList, BaseDoc\nfrom docarray.documents import ImageDoc\n\n\nclass Prompt(BaseDoc):\n text: str\n\n\nprompt = Prompt(\n text='suggest an interesting image generation prompt for a mona lisa variant'\n)\n\nclient = Client(port=12345) # use port from output above\nresponse = client.post(on='/', inputs=[prompt], return_type=DocList[ImageDoc])\n\nresponse[0].display()\n```\n\n\n\n<!-- end build-pipelines -->\n\n### Easy scalability and concurrency\n\nWhy not just use standard Python to build that service and pipeline? Jina accelerates time to market of your application by making it more scalable and cloud-native. Jina also handles the infrastructure complexity in production and other Day-2 operations so that you can focus on the data application itself.\n\nIncrease your application's throughput with scalability features out of the box, like [replicas](https://docs.jina.ai/concepts/orchestration/scale-out/#replicate-executors), [shards](https://docs.jina.ai/concepts/orchestration/scale-out/#customize-polling-behaviors) and [dynamic batching](https://docs.jina.ai/concepts/serving/executor/dynamic-batching/).\n\nLet's scale a Stable Diffusion Executor deployment with replicas and dynamic batching:\n\n\n\n* Create two replicas, with [a GPU assigned for each](https://docs.jina.ai/concepts/orchestration/scale-out/#replicate-on-multiple-gpus).\n* Enable dynamic batching to process incoming parallel requests together with the same model inference.\n\n\n<div class=\"table-wrapper\">\n<table>\n<tr>\n<th> Normal Deployment </th> \n<th> Scaled Deployment </th>\n</tr>\n<tr>\n<td>\n\n```yaml\njtype: Deployment\nwith:\n uses: TextToImage\n timeout_ready: -1\n py_modules:\n - text_to_image.py\n```\n\n</td>\n<td>\n\n```yaml\njtype: Deployment\nwith:\n uses: TextToImage\n timeout_ready: -1\n py_modules:\n - text_to_image.py\n env:\n CUDA_VISIBLE_DEVICES: RR\n replicas: 2\n uses_dynamic_batching: # configure dynamic batching\n /default:\n preferred_batch_size: 10\n timeout: 200\n```\n\n</td>\n</tr>\n</table>\n</div>\n\nAssuming your machine has two GPUs, using the scaled deployment YAML will give better throughput compared to the normal deployment.\n\nThese features apply to both [Deployment YAML](https://docs.jina.ai/concepts/orchestration/yaml-spec/#example-yaml) and [Flow YAML](https://docs.jina.ai/concepts/orchestration/yaml-spec/#example-yaml). Thanks to the YAML syntax, you can inject deployment configurations regardless of Executor code.\n\n## Deploy to the cloud\n\n### Containerize your Executor\n\nIn order to deploy your solutions to the cloud, you need to containerize your services. Jina provides the [Executor Hub](https://docs.jina.ai/concepts/serving/executor/hub/create-hub-executor/), the perfect tool\nto streamline this process taking a lot of the troubles with you. It also lets you share these Executors publicly or privately.\n\nYou just need to structure your Executor in a folder:\n\n```shell script\nTextToImage/\n\u251c\u2500\u2500 executor.py\n\u251c\u2500\u2500 config.yml\n\u251c\u2500\u2500 requirements.txt\n```\n<div class=\"table-wrapper\">\n<table>\n<tr>\n<th> <code>config.yml</code> </th>\n<th> <code>requirements.txt</code> </th>\n</tr>\n<tr>\n<td>\n\n```yaml\njtype: TextToImage\npy_modules:\n - executor.py\nmetas:\n name: TextToImage\n description: Text to Image generation Executor based on StableDiffusion\n url:\n keywords: []\n```\n\n</td>\n<td>\n\n```requirements.txt\ndiffusers\naccelerate\ntransformers\n```\n\n</td>\n</tr>\n</table>\n</div>\n\n\nThen push the Executor to the Hub by doing: `jina hub push TextToImage`.\n\nThis will give you a URL that you can use in your `Deployment` and `Flow` to use the pushed Executors containers.\n\n\n```yaml\njtype: Flow\nwith:\n port: 12345\nexecutors:\n - uses: jinai+docker://<user-id>/StableLM\n - uses: jinai+docker://<user-id>/TextToImage\n```\n\n\n### Get on the fast lane to cloud-native\n\nUsing Kubernetes with Jina is easy:\n\n```bash\njina export kubernetes flow.yml ./my-k8s\nkubectl apply -R -f my-k8s\n```\n\nAnd so is Docker Compose:\n\n```bash\njina export docker-compose flow.yml docker-compose.yml\ndocker-compose up\n```\n\n> **Note**\n> You can also export Deployment YAML to [Kubernetes](https://docs.jina.ai/concepts/serving/executor/serve/#serve-via-kubernetes) and [Docker Compose](https://docs.jina.ai/concepts/serving/executor/serve/#serve-via-docker-compose).\n\nThat's not all. We also support [OpenTelemetry, Prometheus, and Jaeger](https://docs.jina.ai/cloud-nativeness/opentelemetry/).\n\nWhat cloud-native technology is still challenging to you? [Tell us](https://github.com/jina-ai/jina/issues) and we'll handle the complexity and make it easy for you.\n\n### Deploy to JCloud\n\nYou can also deploy a Flow to JCloud, where you can easily enjoy autoscaling, monitoring and more with a single command. \n\nFirst, turn the `flow.yml` file into a [JCloud-compatible YAML](https://docs.jina.ai/yaml-spec/) by specifying resource requirements and using containerized Hub Executors.\n\nThen, use `jina cloud deploy` command to deploy to the cloud:\n\n```shell\nwget https://raw.githubusercontent.com/jina-ai/jina/master/.github/getting-started/jcloud-flow.yml\njina cloud deploy jcloud-flow.yml\n```\n\n> **Warning**\n>\n> Make sure to delete/clean up the Flow once you are done with this tutorial to save resources and credits.\n\nRead more about [deploying Flows to JCloud](https://docs.jina.ai/concepts/jcloud/#deploy).\n\n### Streaming for LLMs\n<!-- start llm-streaming-intro -->\nLarge Language Models can power a wide range of applications from chatbots to assistants and intelligent systems.\nHowever, these models can be heavy and slow and your users want systems that are both intelligent _and_ fast!\n\nLarge language models work by turning your questions into tokens and then generating new token one at a \ntime until it decides that generation should stop.\nThis means you want to **stream** the output tokens generated by a large language model to the client. \nIn this tutorial, we will discuss how to achieve this with Streaming Endpoints in Jina.\n<!-- end llm-streaming-intro -->\n\n#### Service Schemas\n<!-- start llm-streaming-schemas -->\nThe first step is to define the streaming service schemas, as you would do in any other service framework.\nThe input to the service is the prompt and the maximum number of tokens to generate, while the output is simply the \ntoken ID:\n```python\nfrom docarray import BaseDoc\n\n\nclass PromptDocument(BaseDoc):\n prompt: str\n max_tokens: int\n\n\nclass ModelOutputDocument(BaseDoc):\n token_id: int\n generated_text: str\n```\n<!-- end llm-streaming-schemas -->\n\n#### Service initialization\n<!-- start llm-streaming-init -->\nOur service depends on a large language model. As an example, we will use the `gpt2` model. This is how you would load \nsuch a model in your executor\n```python\nfrom jina import Executor, requests\nfrom transformers import GPT2Tokenizer, GPT2LMHeadModel\nimport torch\n\ntokenizer = GPT2Tokenizer.from_pretrained('gpt2')\n\n\nclass TokenStreamingExecutor(Executor):\n def __init__(self, **kwargs):\n super().__init__(**kwargs)\n self.model = GPT2LMHeadModel.from_pretrained('gpt2')\n```\n<!-- end llm-streaming-init -->\n\n\n#### Implement the streaming endpoint\n<!-- start llm-streaming-endpoint -->\nOur streaming endpoint accepts a `PromptDocument` as input and streams `ModelOutputDocument`s. To stream a document back to \nthe client, use the `yield` keyword in the endpoint implementation. Therefore, we use the model to generate \nup to `max_tokens` tokens and yield them until the generation stops: \n```python\nclass TokenStreamingExecutor(Executor):\n ...\n\n @requests(on='/stream')\n async def task(self, doc: PromptDocument, **kwargs) -> ModelOutputDocument:\n input = tokenizer(doc.prompt, return_tensors='pt')\n input_len = input['input_ids'].shape[1]\n for _ in range(doc.max_tokens):\n output = self.model.generate(**input, max_new_tokens=1)\n if output[0][-1] == tokenizer.eos_token_id:\n break\n yield ModelOutputDocument(\n token_id=output[0][-1],\n generated_text=tokenizer.decode(\n output[0][input_len:], skip_special_tokens=True\n ),\n )\n input = {\n 'input_ids': output,\n 'attention_mask': torch.ones(1, len(output[0])),\n }\n```\n\nLearn more about [streaming endpoints](https://docs.jina.ai/concepts/serving/executor/add-endpoints/#streaming-endpoints) from the `Executor` documentation.\n<!-- end llm-streaming-endpoint -->\n\n\n#### Serve and send requests\n<!-- start llm-streaming-serve -->\n\nThe final step is to serve the Executor and send requests using the client.\nTo serve the Executor using gRPC:\n```python\nfrom jina import Deployment\n\nwith Deployment(uses=TokenStreamingExecutor, port=12345, protocol='grpc') as dep:\n dep.block()\n```\n\nTo send requests from a client:\n```python\nimport asyncio\nfrom jina import Client\n\n\nasync def main():\n client = Client(port=12345, protocol='grpc', asyncio=True)\n async for doc in client.stream_doc(\n on='/stream',\n inputs=PromptDocument(prompt='what is the capital of France ?', max_tokens=10),\n return_type=ModelOutputDocument,\n ):\n print(doc.generated_text)\n\n\nasyncio.run(main())\n```\n\n```text\nThe\nThe capital\nThe capital of\nThe capital of France\nThe capital of France is\nThe capital of France is Paris\nThe capital of France is Paris.\n```\n\n<!-- end llm-streaming-serve -->\n\n<!-- start support-pitch -->\n\n## Support\n\n- Join our [Discord community](https://discord.jina.ai) and chat with other community members about ideas.\n- Subscribe to the latest video tutorials on our [YouTube channel](https://youtube.com/c/jina-ai)\n\n## Join Us\n\nJina is backed by [Jina AI](https://jina.ai) and licensed under [Apache-2.0](./LICENSE).\n\n<!-- end support-pitch -->\n",
"bugtrack_url": null,
"license": "Apache 2.0",
"summary": "Multimodal AI services & pipelines with cloud-native stack: gRPC, Kubernetes, Docker, OpenTelemetry, Prometheus, Jaeger, etc.",
"version": "3.25.1",
"project_urls": {
"Documentation": "https://docs.jina.ai",
"Download": "https://github.com/jina-ai/jina/tags",
"Homepage": "https://github.com/jina-ai/jina/",
"Source": "https://github.com/jina-ai/jina/",
"Tracker": "https://github.com/jina-ai/jina/issues"
},
"split_keywords": [
"jina",
"cloud-native",
"cross-modal",
"multimodal",
"neural-search",
"query",
"search",
"index",
"elastic",
"neural-network",
"encoding",
"embedding",
"serving",
"docker",
"container",
"image",
"video",
"audio",
"deep-learning",
"mlops"
],
"urls": [
{
"comment_text": "",
"digests": {
"blake2b_256": "096deb4904ab305233128d11bb29548e7807b1b507059a043f0d17d58f702d71",
"md5": "e7890942db040a8327058885ec74b7af",
"sha256": "02dbce6f6c9fc62064aacb7c76e39f47956bfd1d21a663f91c450feef0c1cf5b"
},
"downloads": -1,
"filename": "jina-3.25.1-cp310-cp310-macosx_10_9_x86_64.whl",
"has_sig": false,
"md5_digest": "e7890942db040a8327058885ec74b7af",
"packagetype": "bdist_wheel",
"python_version": "cp310",
"requires_python": null,
"size": 8953350,
"upload_time": "2024-04-10T14:39:06",
"upload_time_iso_8601": "2024-04-10T14:39:06.428449Z",
"url": "https://files.pythonhosted.org/packages/09/6d/eb4904ab305233128d11bb29548e7807b1b507059a043f0d17d58f702d71/jina-3.25.1-cp310-cp310-macosx_10_9_x86_64.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "ecc535bd0cb425c788755fe7aa745f27ca4f2e03fccc75f2773e58f92f9b5036",
"md5": "cd3e7b7cb430dba4837ced9fb73a3aa3",
"sha256": "92d6b8dc2fcc7c2ed3ca0f445f5c4bcabc8a75aae1d71d521823bee3bd595889"
},
"downloads": -1,
"filename": "jina-3.25.1-cp310-cp310-macosx_11_0_arm64.whl",
"has_sig": false,
"md5_digest": "cd3e7b7cb430dba4837ced9fb73a3aa3",
"packagetype": "bdist_wheel",
"python_version": "cp310",
"requires_python": null,
"size": 8393842,
"upload_time": "2024-04-10T14:39:32",
"upload_time_iso_8601": "2024-04-10T14:39:32.827183Z",
"url": "https://files.pythonhosted.org/packages/ec/c5/35bd0cb425c788755fe7aa745f27ca4f2e03fccc75f2773e58f92f9b5036/jina-3.25.1-cp310-cp310-macosx_11_0_arm64.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "0a2c277092054816ab5956f8ef748c16b98f550d9fa3dd90acacf91195264b2b",
"md5": "5e65f142302b379de3069ac79dfa6cd7",
"sha256": "97271beccfb94c62dd3419df66608da65b12260fb59e1bb1c4c0e8087c85600f"
},
"downloads": -1,
"filename": "jina-3.25.1-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl",
"has_sig": false,
"md5_digest": "5e65f142302b379de3069ac79dfa6cd7",
"packagetype": "bdist_wheel",
"python_version": "cp310",
"requires_python": null,
"size": 7881694,
"upload_time": "2024-04-10T14:39:43",
"upload_time_iso_8601": "2024-04-10T14:39:43.111464Z",
"url": "https://files.pythonhosted.org/packages/0a/2c/277092054816ab5956f8ef748c16b98f550d9fa3dd90acacf91195264b2b/jina-3.25.1-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "1b9b450feb6d5fd909083d53dc52723e47365040753673c07822a64c46a477d2",
"md5": "51e22589a1fe4bfe9031e45cba5f757d",
"sha256": "47248c1816a3ed2a2cd5ac7fc998bd7383563ea21a2e0858c244e564f2b61b4b"
},
"downloads": -1,
"filename": "jina-3.25.1-cp311-cp311-macosx_10_9_x86_64.whl",
"has_sig": false,
"md5_digest": "51e22589a1fe4bfe9031e45cba5f757d",
"packagetype": "bdist_wheel",
"python_version": "cp311",
"requires_python": null,
"size": 8953349,
"upload_time": "2024-04-10T14:39:51",
"upload_time_iso_8601": "2024-04-10T14:39:51.646558Z",
"url": "https://files.pythonhosted.org/packages/1b/9b/450feb6d5fd909083d53dc52723e47365040753673c07822a64c46a477d2/jina-3.25.1-cp311-cp311-macosx_10_9_x86_64.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "54ad0f921873c64bf0da2a0a516aec039ad45e5ba46400b20497be769cce20ed",
"md5": "f33411fbdd8947598fa942602d558604",
"sha256": "691b7b951aad639c6fbae1434f559ed895dcd88898e238f4d3a384aed024d474"
},
"downloads": -1,
"filename": "jina-3.25.1-cp311-cp311-macosx_11_0_arm64.whl",
"has_sig": false,
"md5_digest": "f33411fbdd8947598fa942602d558604",
"packagetype": "bdist_wheel",
"python_version": "cp311",
"requires_python": null,
"size": 8393795,
"upload_time": "2024-04-10T14:40:08",
"upload_time_iso_8601": "2024-04-10T14:40:08.161293Z",
"url": "https://files.pythonhosted.org/packages/54/ad/0f921873c64bf0da2a0a516aec039ad45e5ba46400b20497be769cce20ed/jina-3.25.1-cp311-cp311-macosx_11_0_arm64.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "e657c6c1a6623cadf44045eb37bdb746b2602811875a0a1d48cefcfd73467ff7",
"md5": "043c2afe35ce2909be1a43fa9dceb054",
"sha256": "41339be891bb222f92d3c30347eb2a8728ac60e85544b3fc6a70e52346e94f65"
},
"downloads": -1,
"filename": "jina-3.25.1-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl",
"has_sig": false,
"md5_digest": "043c2afe35ce2909be1a43fa9dceb054",
"packagetype": "bdist_wheel",
"python_version": "cp311",
"requires_python": null,
"size": 7881728,
"upload_time": "2024-04-10T14:40:20",
"upload_time_iso_8601": "2024-04-10T14:40:20.375225Z",
"url": "https://files.pythonhosted.org/packages/e6/57/c6c1a6623cadf44045eb37bdb746b2602811875a0a1d48cefcfd73467ff7/jina-3.25.1-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "b4b7883eb817cb93de4802d5ddb1f59218e749c5fbd05674efb0a7937cb4e614",
"md5": "2affad865ecd1683f1440a911a2a9120",
"sha256": "1fb14545e971102fd5f9d0cf4ccfe50c3e2327da812269390b7f32ac2943ea3c"
},
"downloads": -1,
"filename": "jina-3.25.1-cp37-cp37m-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl",
"has_sig": false,
"md5_digest": "2affad865ecd1683f1440a911a2a9120",
"packagetype": "bdist_wheel",
"python_version": "cp37",
"requires_python": null,
"size": 7881684,
"upload_time": "2024-04-10T14:40:32",
"upload_time_iso_8601": "2024-04-10T14:40:32.934265Z",
"url": "https://files.pythonhosted.org/packages/b4/b7/883eb817cb93de4802d5ddb1f59218e749c5fbd05674efb0a7937cb4e614/jina-3.25.1-cp37-cp37m-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "3b1caa7cc6c5d1b1fa2986c7722ac3f16f7c196c5518207480d59feeb39c94ad",
"md5": "dd1a7e59bda155f86e02b367ad546f49",
"sha256": "5826cba085267f9ade12e3ab73f5526ba61a15c1a1d7f0f5c3639ccd86aa8979"
},
"downloads": -1,
"filename": "jina-3.25.1-cp38-cp38-macosx_10_9_x86_64.whl",
"has_sig": false,
"md5_digest": "dd1a7e59bda155f86e02b367ad546f49",
"packagetype": "bdist_wheel",
"python_version": "cp38",
"requires_python": null,
"size": 8953530,
"upload_time": "2024-04-10T14:40:42",
"upload_time_iso_8601": "2024-04-10T14:40:42.133642Z",
"url": "https://files.pythonhosted.org/packages/3b/1c/aa7cc6c5d1b1fa2986c7722ac3f16f7c196c5518207480d59feeb39c94ad/jina-3.25.1-cp38-cp38-macosx_10_9_x86_64.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "0f9da297fc96f143c6eb2f73630ecf1c00e9124fcc11ed8987e878d0fc9e2a84",
"md5": "45b9b09d9040c0d6580641171725c4b9",
"sha256": "47923e73f1375d1a1a70b51088ae586c56c43a9f4e2074d46e515f3bc28a7698"
},
"downloads": -1,
"filename": "jina-3.25.1-cp38-cp38-macosx_11_0_arm64.whl",
"has_sig": false,
"md5_digest": "45b9b09d9040c0d6580641171725c4b9",
"packagetype": "bdist_wheel",
"python_version": "cp38",
"requires_python": null,
"size": 8393774,
"upload_time": "2024-04-10T14:40:51",
"upload_time_iso_8601": "2024-04-10T14:40:51.722123Z",
"url": "https://files.pythonhosted.org/packages/0f/9d/a297fc96f143c6eb2f73630ecf1c00e9124fcc11ed8987e878d0fc9e2a84/jina-3.25.1-cp38-cp38-macosx_11_0_arm64.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "8531f01f1ef3c1b64a2648c111a24ad4b1561346f060e3620a9141989449d969",
"md5": "31c8bcc7e7f65dfdd9588a2fcb681d12",
"sha256": "09672ed76832e3a76beb28eff31fbc6442f6fdb0904344084f094cdb5b9d5062"
},
"downloads": -1,
"filename": "jina-3.25.1-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl",
"has_sig": false,
"md5_digest": "31c8bcc7e7f65dfdd9588a2fcb681d12",
"packagetype": "bdist_wheel",
"python_version": "cp38",
"requires_python": null,
"size": 7881760,
"upload_time": "2024-04-10T14:41:01",
"upload_time_iso_8601": "2024-04-10T14:41:01.368118Z",
"url": "https://files.pythonhosted.org/packages/85/31/f01f1ef3c1b64a2648c111a24ad4b1561346f060e3620a9141989449d969/jina-3.25.1-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "bc18d2ac693f8800018f10dc5c1b278a0da0825897ba4e2e411620a96640137f",
"md5": "5863b96ea2f6a761675844d77047b263",
"sha256": "b73d9ddd3b43eb4ff9cf8dbf982eafdfebbf53b52b27ee2ba3d1a45bb475ba03"
},
"downloads": -1,
"filename": "jina-3.25.1-cp39-cp39-macosx_10_9_x86_64.whl",
"has_sig": false,
"md5_digest": "5863b96ea2f6a761675844d77047b263",
"packagetype": "bdist_wheel",
"python_version": "cp39",
"requires_python": null,
"size": 8953495,
"upload_time": "2024-04-10T14:41:10",
"upload_time_iso_8601": "2024-04-10T14:41:10.913142Z",
"url": "https://files.pythonhosted.org/packages/bc/18/d2ac693f8800018f10dc5c1b278a0da0825897ba4e2e411620a96640137f/jina-3.25.1-cp39-cp39-macosx_10_9_x86_64.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "755cb7d03ebfb9c9387db9ea7847c1cdf97e0084fab80e0be12c7e718ac9a43a",
"md5": "b0e51c63dbc06f88166795d6c8efc528",
"sha256": "d86cb8001662494414751e3270d1b1355323babd175ef90b9c6830fb9629d93e"
},
"downloads": -1,
"filename": "jina-3.25.1-cp39-cp39-macosx_11_0_arm64.whl",
"has_sig": false,
"md5_digest": "b0e51c63dbc06f88166795d6c8efc528",
"packagetype": "bdist_wheel",
"python_version": "cp39",
"requires_python": null,
"size": 8393786,
"upload_time": "2024-04-10T14:41:24",
"upload_time_iso_8601": "2024-04-10T14:41:24.159614Z",
"url": "https://files.pythonhosted.org/packages/75/5c/b7d03ebfb9c9387db9ea7847c1cdf97e0084fab80e0be12c7e718ac9a43a/jina-3.25.1-cp39-cp39-macosx_11_0_arm64.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "a4ffc17ea972c13f9e31c364162925b8dec822602e667d91bd8b495b440f1b8e",
"md5": "875a5aa57eae09e104a1b0a894f31a4b",
"sha256": "13e2f1a0ace0b3d248eaad27e3851119dbf2e1fe72e53a6956fbb9decf50caeb"
},
"downloads": -1,
"filename": "jina-3.25.1-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl",
"has_sig": false,
"md5_digest": "875a5aa57eae09e104a1b0a894f31a4b",
"packagetype": "bdist_wheel",
"python_version": "cp39",
"requires_python": null,
"size": 7881708,
"upload_time": "2024-04-10T14:41:36",
"upload_time_iso_8601": "2024-04-10T14:41:36.318332Z",
"url": "https://files.pythonhosted.org/packages/a4/ff/c17ea972c13f9e31c364162925b8dec822602e667d91bd8b495b440f1b8e/jina-3.25.1-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "eae5400db7c387380c4e909326ec0987984b4298144ba1cdc476238520f079b1",
"md5": "5b60e73c37cbaa94a5852d1265aa4624",
"sha256": "95bee7119bb459dee152791fb9974f6eecb4bc9d2438d6754b5cf565c705e601"
},
"downloads": -1,
"filename": "jina-3.25.1.tar.gz",
"has_sig": false,
"md5_digest": "5b60e73c37cbaa94a5852d1265aa4624",
"packagetype": "sdist",
"python_version": "source",
"requires_python": null,
"size": 374627,
"upload_time": "2024-04-10T14:41:45",
"upload_time_iso_8601": "2024-04-10T14:41:45.624825Z",
"url": "https://files.pythonhosted.org/packages/ea/e5/400db7c387380c4e909326ec0987984b4298144ba1cdc476238520f079b1/jina-3.25.1.tar.gz",
"yanked": false,
"yanked_reason": null
}
],
"upload_time": "2024-04-10 14:41:45",
"github": true,
"gitlab": false,
"bitbucket": false,
"codeberg": false,
"github_user": "jina-ai",
"github_project": "jina",
"travis_ci": false,
"coveralls": false,
"github_actions": true,
"requirements": [],
"lcname": "jina"
}
JSON
