Is there any interest for an async/aiohttp based client?

Advantages:

• Much lower overhead than threadpools
• Users who use the api as a step in their async codebase (e.g. fastapi) are not forced to block

Disadvantages:

• Needs significant refactoring to not end up with code duplication
• Extra (optional?) dependency

Before:

res = co.classify(...)
res.classifications[0].confidence # [ Confidence(label: __, confidence: 0.8), Confidence(label: __, confidence: ___), ...)

After

res = co.classify(...)
res.classifications[0].confidence # 0.8

• Adds co.batch_{generate/tokenize/detokenize}
• Makes the Generations/Detokenize/Tokenize objects all (optionally) lazy in the sense that they can be constructed and manipulated without the REST call response they represent being complete yet. As soon as a class attribute that depends on the REST call is accessed it will block until that attribute is resolved.
• Generation object is now a subclass of str so that it can be thrown into code as though it were one.
• Improved the Generations object so that is can be more easily sliced/indexed into without needing to access an ugly next of attributes.
• Converted a bunch of bloat objects that were actually just NamedTuples
• Remove the "one time iterator" design decision that was made: Previously, if you wrote:

generations = co.generate(...)
for g in generations:
    print(g)
# the lines above will print the generations successfully
for g in generations:
    print(g)
# the loop above won't be executed because the iterator in generations can only be run once

This PR removes that strange behaviour.

This PR adds Extract to the Python SDK.

Usage:

import cohere
from cohere.extract import Entity, Example

co = cohere.Client('API_KEY')

result = co.extract(
    model="large",
    examples=[
        Example(
            text="hello my name is John, and I like to play ping pong",
            entities=[
                Entity(type="Name", value="John"),
                Entity(type="Game", value="ping pong")
            ]
        ),
        Example(
            text="Jon Ke from work is amazing at chess!",
            entities=[
                Entity(type="Name", value="Jon Ke"),
                Entity(type="Game", value="chess")
            ]
        ),
        Example(
            text="David won't stop talking about playing tennis!",
            entities=[
                Entity(type="Name", value="David"),
                Entity(type="Game", value="tennis")
            ]
        ),
    ],
    texts=[
        "David will be playing soccer?"
    ]
)

print(result)
'''
cohere.Extractions {
        extractions: [
          {'id': 'caf0d948-57e8-4d48-849c-007a0c13b4cb',
          'text': 'David will be playing soccer?',
          'entities': [{'type': 'Name', 'value': 'David'}, {'type': 'Game', 'value': 'soccer'}]}]
}
'''

the Classify parameters taskDescription and outputIndicator are being replaced with task_description and output_indicator respectively to be consistent with the casing of other parameters.

This PR updates the SDK to use these new params.

As part of https://github.com/cohere-ai/blobheart/pull/3680 the Generate API now accepts a "language" parameter. This PR updates the SDK to accept "language" as an argument and include it in the API request.

• when making requests spin up the thread to request and return immediately
• give all the cohere response objects a mutex, when a request is running a thread should hold onto that mutex
• if accessed, block <-- this is the spooky part

CI to Publish Our PyPi Server on all merges/pushes to main so that we dont need to manually build and upload every time.

• Github Action
• https://pythonprogramming.org/automatically-building-python-package-using-github-actions/

cc: @jimwu6 @choicallum

How to reproduce:

1. Go to: https://cohere-ai.github.io/jupyter_lite/repl/?toolbar=1&kernel=python
2. Add the following code snippet

import piplite
await piplite.install("cohere")
import cohere
co = cohere.Client('<your_prod_api_key>')
prediction = co.generate(
  model='xlarge-20220301',
  prompt='The table lists the following professions as artistic careers:\n1. Painter\n2.',
  max_tokens=50,
  temperature=1,
  k=0,
  p=0.75,
  frequency_penalty=0,
  presence_penalty=0,
  stop_sequences=[],
  return_likelihoods='NONE')
print('Prediction: {}'.format(prediction.generations[0].text))

3. It fails due to the stdlib used for performing HTTP requests, which is not compatible with Pyodide (Python port for WASM)

Expected behavior:

1. We should support using the SDK in a Pyodide environment, by either allowing passing a custom http client or building a separate SDK for Pyodide.

Don't know about how we should name objects yet.

Originally, I wanted to have one "catch all" CohereResponse object, but the names were confusing because we had "likelihood" and "likelihoods", thus designing it this way.

This should also be refactored into bzz and docs

closes #8

Hello, I implemented async style for cohere client. All methods are implemented with the same parameter signatures and response type. Added tests for each method.

Example of usage:

co = await cohere.async_client.AsyncClient.create(API_KEY)

response = await co.generate(
    model="xlarge",
    prompt="""Summarize this dialogue:
        Customer: Please connect me with a support agent.
        AI: Hi there, how can I assist you today?
        Customer: I forgot my password and lost access to the email affiliated to my account. Can you please help me?
        AI: Yes of course. First I\'ll need to confirm your identity and then I can connect you with one of our support agents.
        TLDR: A customer lost access to their account.
         --
        Summarize this dialogue:
        AI: Hi there, how can I assist you today?
        Customer: I want to book a product demo.
        AI: Sounds great. What country are you located in?
        Customer: I\'ll connect you with a support agent who can get something scheduled for you.
        TLDR: A customer wants to book a product demo.
        --
        Summarize this dialogue:
        AI: Hi there, how can I assist you today?
        Customer: I want to get more information about your pricing.
        AI: I can pull this for you, just a moment.
        TLDR:""",
    max_tokens=20,
    temperature=0.6,
    k=0,
    p=1,
    stop_sequences=["--"])

response
cohere.Generations {
	generations: [cohere.Generation {
	text:  A customer wants to get more information about pricing.
  --
	likelihood: None
	token_likelihoods: None
}]
	return_likelihoods: None
}

Add token streaming support for python sdk, add stream and chunk_size optional params to co.generate()

Sample use case

import cohere
import os

co = cohere.Client(os.environ["CO_API_KEY"])

response_generator = co.generate("Today I went to the park", stream=True)

for gen in response_generator.stream():
   # do something with gen

final_response = response_generator.response()

Sample client

import cohere
import os
import base64

API_KEY = os.getenv('COHERE_API_KEY')
cohere.COHERE_API_URL = "https://dev.api.cohere.ai/"
co = cohere.Client(API_KEY)

# x = co.whisper(file_paths=<INSERT_FILE_PATH>)
x = co.image(<INSERT_PROMPT>)
with open("image.png", "wb") as f:
    f.write(base64.b64decode(x.image))

Hello, Will it be possible to provide an enum for different message errors types so we can check against ? or at least provide the message error type in the documentation. Thanks