8. Notice that this *path operation function* uses regular `def` instead of `async def`.

    As always, in FastAPI you can combine `def` and `async def` as needed.

    If you need a refresher about when to use which, check out the section _"In a hurry?"_ in the docs about [`async` and `await`](../async.md#in-a-hurry){.internal-link target=_blank}.

# Background Tasks - `BackgroundTasks`

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
```

# `UploadFile` class

You can define *path operation function* parameters to be of the type `UploadFile` to receive files from the request.

You can import it directly from `fastapi`:

```python
from fastapi import UploadFile
```

::: fastapi.UploadFile
    options:
        members:
            - file
            - filename
            - size
            - headers
            - content_type
            - read

    public static class ShareEnumAll extends DcerpcMessage {

        @Override
        public int getOpnum() {
            return 0x0f;
        }

        /**
         * The return value of the operation.
         */
        public int retval;
        /**
         * The name of the server.
         */
        public String servername;
        /**
         * The information level to return.

    return this.<T>trustedPut(type.rejectTypeVariables(), value);
  }

  /**
   * Not supported. Use {@link #putInstance} instead.
   *
   * @deprecated unsupported operation
   * @throws UnsupportedOperationException always
   */
  @CanIgnoreReturnValue
  @Deprecated
  @Override
  @DoNotCall("Always throws UnsupportedOperationException")

            return SpnegoAuthenticator.class.getName();
        }

        /**
         * Gets the servlet context. This operation is not supported.
         *
         * @return Never returns, always throws UnsupportedOperationException
         * @throws UnsupportedOperationException Always thrown as this operation is not supported
         */
        @Override
        public ServletContext getServletContext() {

        // Given
        String operation = "TestOperation";
        when(mockDelegate.getBatchLimit(operation)).thenReturn(100);

        // When
        int batchLimit = delegatingConfig.getBatchLimit(operation);

        // Then
        assertEquals(100, batchLimit, "Should delegate batch limit");
        verify(mockDelegate).getBatchLimit(operation);
    }

    @Test

                        break;
                    default:
                        throw new SmbException("Invalid operation for " + service + " service");
                    }
                    break;
                default:
                    throw new SmbException("Invalid operation for " + service + " service" + request);
                }
            }
            request.tid = tid;

   * An object that holds the final result of an asynchronous {@link ClosingFuture} operation and
   * allows the user to close all the closeable objects that were captured during it for later
   * closing.
   *
   * <p>The asynchronous operation will have completed before this object is created.
   *
   * @param <V> the type of the value of a successful operation
   * @see ClosingFuture#finishToValueAndCloser(ValueAndCloserConsumer, Executor)

# `Request` class

You can declare a parameter in a *path operation function* or dependency to be of type `Request` and then you can access the raw request object directly, without any validation, etc.

You can import it directly from `fastapi`:

```python
from fastapi import Request
```

/// tip