# Lifespan Events { #lifespan-events }

You can define logic (code) that should be executed before the application **starts up**. This means that this code will be executed **once**, **before** the application **starts receiving requests**.

The same way, you can define logic (code) that should be executed when the application is **shutting down**. In this case, this code will be executed **once**, **after** having handled possibly **many requests**.

 * either express or implied. See the License for the specific language
 * governing permissions and limitations under the License.
 */
package org.codelibs.fess.llm;

/**
 * Callback interface for receiving streaming chat responses from LLM.
 */
@FunctionalInterface
public interface LlmStreamCallback {

    /**
     * Called for each chunk of the streaming response.
     *

You **should not** install this package.

Install instead:

```bash
pip install fastapi
```

This package is deprecated and will stop receiving any updates and published versions.

## License

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */
package jcifs;

import java.util.List;
import java.util.concurrent.Callable;

/**
 * Handle for receiving change notifications from an SMB server
 *
 *
 * @author mbechler
 *
 */
public interface SmbWatchHandle extends AutoCloseable, Callable<List<FileNotifyInformation>> {

    /**

 * either express or implied. See the License for the specific language
 * governing permissions and limitations under the License.
 */
package org.codelibs.fess.chat;

/**
 * Callback interface for receiving notifications about chat processing phases.
 * Used for SSE streaming to notify clients about the current processing state.
 */
public interface ChatPhaseCallback {

    /** Phase name for intent detection */

And of course, you can use the same model configured to use base64 to handle both input (*validate*) with `val_json_bytes` and output (*serialize*) with `ser_json_bytes` when receiving and sending JSON data.

## A Custom `PNGStreamingResponse` { #a-custom-pngstreamingresponse }

In the examples above, the data bytes were streamed, but the response didn't have a `Content-Type` header, so the client didn't know what type of data it was receiving.

You can create a custom sub-class of `StreamingResponse` that sets the `Content-Type` header to the type of data you're streaming.

The contents are **encrypted**, even though they are being sent with the **HTTP protocol**.

It is a common practice to have **one program/HTTP server** running on the server (the machine, host, etc.) and **managing all the HTTPS parts**: receiving the **encrypted HTTPS requests**, sending the **decrypted HTTP requests** to the actual HTTP application running in the same server (the **FastAPI** application, in this case), take the **HTTP response** from the application, **encrypt it** using...

You can define background tasks to be run *after* returning a response.

This is useful for operations that need to happen after a request, but that the client doesn't really have to be waiting for the operation to complete before receiving the response.

This includes, for example:

* Email notifications sent after performing an action:

   * leaking resources callers must [close the response body][ResponseBody] or the response.
   *
   * Note that transport-layer success (receiving a HTTP response code, headers and body) does not
   * necessarily indicate application-layer success: `response` may still indicate an unhappy HTTP
   * response code like 404 or 500.
   *