# Pluggability of Cloud Storage

In this guide, we will learn how to plugin a new cloud storage wrapper by extending the `BaseStorageClass` interface.

 You can seamlessly leverage it within existing Sakhi API workflows with minimal code changes.

### Integration <a href="#implementation" id="implementation"></a>

Cloud storage is used for storing the response generated from LLM which is then converted to **audio format** using a translation util. Link of the audio response files will be used by clients connecting to sakhi-api-service for playing the response.

### BaseStorageClass <a href="#base-chat-model" id="base-chat-model"></a>

This `BaseStorageClass` class has below methods which are to be implemented mandatorily.

| Method/Property       | Description                                                        | Required/Optional |
| --------------------- | ------------------------------------------------------------------ | ----------------- |
| \_\_init\_\_          | Used to instantiate the storage account client                     | Required          |
| upload\_to\_storage   | Takes name of the file to be uploaded                              | Required          |
| generate\_public\_url | Takes name of the file for which the public url is to be generated | Required          |

### Implementation <a href="#implementation" id="implementation"></a>

Let's say we create a `YourStorageClass` class inheriting from `BaseStorageClass.` The class needs to implement the following methods \_\_init\_\_, upload\_to\_storage and generate\_public\_url.

Add the necessary environment variables to  `.env` file. `BUCKET_TYPE` is to be defined mandatorily.

```
BUCKET_TYPE=your_cloud
```

Now go to the 'storage' folder and create your plugin: `your_cloud.py`

{% code title="your\_cloud.py" %}

```python

from storage.base import BaseStorageClass


class YourBucketClass(BaseStorageClass):
    def __init__(self):
        your_client = # instantiate your client
        super().__init__(your_client)

    def upload_to_storage(self, file_name: str, object_name: Optional[str] = None) -> bool:
        # code to upload file to your cloud storage
        return True

    def generate_public_url(self, object_name: str) -> Union[tuple[str, None], tuple[None, str]]:
        try:
            public_url = # you code to fetch public url of the uploaded file
            return public_url, None
        except Exception as e:
            logger.error(f"Exception Preparing public URL: {e}", exc_info=True)
            return None, "Error while generating public URL"
```

{% endcode %}

Go to the 'storage' folder and update `__init__.py` with the module lookup entry for "YourBucketClass" and also for TYPE\_CHECKING.

```python
if TYPE_CHECKING:
    ...
    from storage.your_cloud import (
        YourBucketClass
    )

_module_lookup = {
    ...,
    "YourBucketClass": "storage.your_cloud"
}
```

Modify `env_manager.py` to import `YourStorageClass`  and add a mapping for `YourStorageClass` in the `self.indexes` dictionary.

```python
from storage import (
    ...,
    YourBucketClass
)
```

<pre class="language-python"><code class="lang-python"><strong>self.indexes = {
</strong>    "storage": {
        "class": {
            ...,
            "your_cloud": YourBucketClass
        },
        "env_key": "BUCKET_TYPE"
    }
}
</code></pre>

This setup ensures that `YourBucketClass` can be instantiated based on specific environment variables, effectively integrating it into the environment management system. The `self.indexes` the dictionary now includes a mapping where `"your_cloud"` corresponds to the `"YourBucketClass"` class and uses `"BUCKET_TYPE"` as the environment key.


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://ai-assistant.sunbird.org/components/sakhi-api-service/pluggability-of-cloud-storage.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.