# Créer des applications plus grandes - Plusieurs fichiers { #bigger-applications-multiple-files }

Si vous créez une application ou une API web, il est rare que vous puissiez tout mettre dans un seul fichier.

**FastAPI** fournit un outil pratique pour structurer votre application tout en conservant toute la flexibilité.

/// info

Si vous venez de Flask, cela équivaut aux Blueprints de Flask.

///

# Aplicaciones más grandes - Múltiples archivos { #bigger-applications-multiple-files }

Si estás construyendo una aplicación o una API web, rara vez podrás poner todo en un solo archivo.

**FastAPI** proporciona una herramienta conveniente para estructurar tu aplicación manteniendo toda la flexibilidad.

/// info | Información

Si vienes de Flask, esto sería el equivalente a los Blueprints de Flask.

///

# Aplicações Maiores - Múltiplos Arquivos { #bigger-applications-multiple-files }

Se você está construindo uma aplicação ou uma API web, é raro que você possa colocar tudo em um único arquivo.

**FastAPI** oferece uma ferramenta conveniente para estruturar sua aplicação, mantendo toda a flexibilidade.

/// info | Informação

Se você vem do Flask, isso seria o equivalente aos Blueprints do Flask.

///

                .proxy(Proxy.NO_PROXY).sslSocketFactory((SSLSocketFactory) SSLSocketFactory.getDefault()).param("filter", "active")
                .param("sort", "name").header("Accept", "application/json").header("Content-Type", "application/json")

  }

  private static Type[] toArray(Collection<Type> types) {
    return types.toArray(new Type[0]);
  }

  private static Iterable<Type> filterUpperBounds(Iterable<Type> bounds) {
    return Iterables.filter(bounds, Predicates.not(Predicates.<Type>equalTo(Object.class)));
  }

  private static void disallowPrimitiveType(Type[] types, String usedAs) {
    for (Type type : types) {
      if (type instanceof Class) {

     *
     * In theory, we can quickly determine the size of any Collection. However, thanks to
     * regrettable implementations like our own Sets.filter, Collection.size() is sometimes a
     * linear-time operation, and it can even have side effects. Thus, we limit the special case to
     * List, which is _even more likely_ to have size() implemented to be fast and side-effect-free.

                    .append(authMethod);
            return sb.toString();
        } finally {
            returnStringBuilder(sb);
        }
    }

    /**
     * Log a file access event
     *
     * @param path file path
     * @param operation operation performed
     * @param success whether operation succeeded
     * @param username user performing operation
     */

     *
     * @return The created OpenSearch client.
     */
    protected Client createClient() {
        final String[] hosts =
                split(address, ",").get(stream -> stream.map(String::trim).filter(StringUtil::isNotEmpty).toArray(n -> new String[n]));
        final Settings settings = Settings.builder().putList("http.hosts", hosts).build();
        return new HttpClient(settings, null);
    }

    /**

import org.codelibs.fess.opensearch.config.cbean.cq.LabelTypeCQ;
import org.codelibs.fess.opensearch.config.cbean.cq.bs.BsLabelTypeCQ;
import org.opensearch.search.aggregations.bucket.filter.FilterAggregationBuilder;
import org.opensearch.search.aggregations.bucket.global.GlobalAggregationBuilder;
import org.opensearch.search.aggregations.bucket.histogram.HistogramAggregationBuilder;

    public void filtered(FilteredCall<FileAuthenticationCQ, FileAuthenticationCQ> filteredLambda,
            ConditionOptionCall<BoolQueryBuilder> opLambda) {
        bool((must, should, mustNot, filter) -> {
            filteredLambda.callback(must, filter);
        }, opLambda);
    }

    public void not(OperatorCall<FileAuthenticationCQ> notLambda) {
        not(notLambda, null);
    }