}

    /**
     * Adds a client with a regular expression pattern.
     * @param regex The regular expression to match URLs.
     * @param client The CrawlerClient instance.
     */
    public void addClient(final String regex, final CrawlerClient client) {
        if (StringUtil.isBlank(regex)) {
            throw new CrawlerSystemException(

  -v D:\data:/data \
  quay.io/minio/minio server /data --console-address ":9001"
```

### Run MinIO Docker as a regular user

Docker provides standardized mechanisms to run docker containers as non-root users.

#### GNU/Linux and macOS (regular user)

On Linux and macOS you can use `--user` to run the container as regular user.

> NOTE: make sure --user has write permission to *${HOME}/data* prior to using `--user`.

```sh

## Add regular expressions { #add-regular-expressions }

You can define a <abbr title="A regular expression, regex or regexp is a sequence of characters that define a search pattern for strings.">regular expression</abbr> `pattern` that the parameter should match:

{* ../../docs_src/query_params_str_validations/tutorial004_an_py310.py hl[11] *}

 * <li>User agent settings</li>
 * <li>URL pattern matching with regular expressions and contains filters</li>
 * </ul>
 *
 */
public class GsaConfigParser extends DefaultHandler {

    /** Logger instance for this class. */
    private static final Logger logger = LogManager.getLogger(GsaConfigParser.class);

    /** Prefix for regular expression patterns. */
    public static final String REGEXP = "regexp:";

     */
    @Override
    public void close() {
        clientFactory.close();
    }

    /**
     * Adds an include filter for URLs.
     * Only URLs matching this regular expression will be crawled.
     * @param regexp The regular expression for the include filter.
     */
    public void addIncludeFilter(final String regexp) {
        if (StringUtil.isNotBlank(regexp)) {
            urlFilter.addInclude(regexp);

) -> Any:
    await websocket.accept()
    await websocket.send_json(
        {"named_session_open": sessions[0].open, "session_open": sessions[1].open}
    )


@app.websocket("/regular-function-scope")
async def get_regular_function_scope(
    websocket: WebSocket, sessions: RegularSessionsDep
) -> Any:
    await websocket.accept()
    await websocket.send_json(

            if (dirManager != null && smbFile.getContext().getConfig().isUseDirectoryLeasing()) {
                return listFilesWithDirectoryLeasing(smbFile, dirManager);
            } else {
                // Fall back to regular directory listing
                return smbFile.listFiles();
            }
        } catch (CIFSException e) {
            throw SmbException.wrap(e);
        }
    }

    /**

    def iter_data():
        yield json.dumps(
            {"named_session_open": sessions[0].open, "session_open": sessions[1].open}
        )

    return StreamingResponse(iter_data())


@app.get("/regular-function-scope")
def get_regular_function_scope(sessions: RegularSessionsDep) -> Any:
    def iter_data():
        yield json.dumps(
            {"named_session_open": sessions[0].open, "session_open": sessions[1].open}

## Agregar expresiones regulares { #add-regular-expressions }

Puedes definir un <abbr title="Una expresión regular, regex o regexp es una secuencia de caracteres que define un patrón de búsqueda para strings.">expresión regular</abbr> `pattern` que el parámetro debe coincidir:

{* ../../docs_src/query_params_str_validations/tutorial004_an_py310.py hl[11] *}

Este patrón específico de expresión regular comprueba que el valor recibido del parámetro:

## Adicione expressões regulares { #add-regular-expressions }

Você pode definir um `pattern` de <abbr title="Uma expressão regular, regex ou regexp é uma sequência de caracteres que define um padrão de busca para strings.">expressão regular</abbr> que o parâmetro deve corresponder:

{* ../../docs_src/query_params_str_validations/tutorial004_an_py310.py hl[11] *}

Esse padrão específico de expressão regular verifica se o valor recebido no parâmetro: