@Override
    public boolean equals(final Object obj) {
        if (obj instanceof final SmbTree tree) {
            return matches(tree.share, tree.service);
        }
        return false;
    }

    void send(final ServerMessageBlock request, final ServerMessageBlock response) throws SmbException {
        synchronized (session.transport()) {
            if (response != null) {
                response.received = false;
            }

# Module okhttp-sse

```console
$ pip install python-multipart
```

This is because uploaded files are sent as "form data".

///

## Import `File` { #import-file }

Import `File` and `UploadFile` from `fastapi`:

{* ../../docs_src/request_files/tutorial001_an_py39.py hl[3] *}

Alerting with prometheus is two step process. First we setup alerts in Prometheus server and then we need to send alerts to the AlertManager.

        assertEquals(8192, config.getRdmaReadWriteThreshold(), "Default threshold should be 8KB");
        assertEquals(65536, config.getRdmaMaxSendSize(), "Default max send size should be 64KB");
        assertEquals(65536, config.getRdmaMaxReceiveSize(), "Default max receive size should be 64KB");
        assertEquals(255, config.getRdmaCredits(), "Default credits should be 255");
    }

     *
     * @param config the configuration to use
     * @param fid the file ID of the named pipe
     * @param data the data buffer to send
     * @param off the offset in the data buffer
     * @param len the length of data to send
     */
    public TransTransactNamedPipe(final Configuration config, final int fid, final byte[] data, final int off, final int len) {

package jcifs.smb1.util.transport;

/**
 * Marker interface for transport layer request objects.
 * Represents a request that can be sent through the SMB1 transport layer.
 */
public interface Request {

You can declare a parameter in a *path operation function* or dependency function with the type `BackgroundTasks`, and then you can use it to schedule the execution of background tasks after the response is sent.

You can import it directly from `fastapi`:

```python
from fastapi import BackgroundTasks
```

 * multiplexing requests. It encapsulates a stream and some protocol
 * knowledge (provided by a concrete subclass) so that connecting,
 * disconnecting, sending, and receiving can be syncronized
 * properly. Apparatus is provided to send and receive requests
 * concurrently.
 */

public abstract class Transport implements Runnable {

    /**
     * Default constructor for Transport.
     */
    public Transport() {

            } catch (final IOException ioe) {
                this.state = 0;
                throw ioe;
            }
        }
    }

    /**
     * Send and receive a DCE/RPC message
     *
     * @param msg
     *            the message to send
     * @throws DcerpcException
     *            if there is a DCE/RPC protocol error
     * @throws IOException