O OAuth2 foi projetado para que o backend ou a API pudesse ser independente do servidor que autentica o usuário.

Mas, neste caso, a mesma aplicação **FastAPI** irá lidar com a API e com a autenticação.

Então, vamos rever de um ponto de vista simplificado:

* O usuário digita o `username` e o `password` no frontend e pressiona `Enter`.

    return builder.toString();
  }

  /**
   * Returns an immutable array containing the same values as {@code this} array. This is logically
   * a no-op, and in some circumstances {@code this} itself is returned. However, if this instance
   * is a {@link #subArray} view of a larger array, this method will copy only the appropriate range
   * of values, resulting in an equivalent array with a smaller memory footprint.
   */

         * Therefore, we can always create our own TypeVariable. (One downside of our TypeVariable
         * in some situations is that it does not support the AnnotatedType API. However, those
         * situations don't arise under Android because Android does not provide the AnnotatedType
         * API at all.)
         *

 *
 * <p>This class supports an optional fairness policy for ordering waiting producer and consumer
 * threads. By default, this ordering is not guaranteed. However, a queue constructed with fairness
 * set to {@code true} grants threads access in FIFO order. Fairness generally decreases throughput
 * but reduces variability and avoids starvation.
 *

   *       to lead to trouble than an incompatible change would be.
   *   <li>We could make {@link #countMap} no longer be {@code final}. Then we could write to it
   *       directly during deserialization. However, we would lose Java's guarantees for {@code
   *       final} fields, including that their values are guaranteed to be visible even when an
   *       instance is unsafely published.
   * </ul>
   */

 * for further instructions. Whenever possible, you should change any references of type {@code
 * Ordering} to be of type {@code Comparator} instead. However, at this time we have no plan to
 * <i>deprecate</i> this class.
 *
 * <p>Many replacements involve adopting {@code Stream}, and these changes can sometimes make your

package jcifs;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;

/**
 * This class represents a resource on an SMB network. Mainly these
 * resources are files and directories however an <code>SmbFile</code>
 * may also refer to servers and workgroups.
 *
 * @see jcifs.smb.SmbFile for the main implementation of this interface
 * @author mbechler
 */
public interface SmbResource extends AutoCloseable {

            name = name.substring(0, last);
        }

        if (shr == null) {
            final String[] nameParts = name.split("/");

            // server is set through URL, however it's still in the name
            int pos = 0;
            if (context.getServer() == null) {
                pos = 1;
            }

            // first remaining path element would be share

				continue
			}
			opts.claims[k] = v
		}
	} else {
		// We still need to ensure that the target user is a valid LDAP user.
		//
		// The target user may be supplied as a (short) username or a DN.
		// However, for now, we only support using the short username.

		isDN := globalIAMSys.LDAPConfig.ParsesAsDN(targetUser)
		opts.claims[ldapUserN] = targetUser // simple username
		var lookupResult *xldap.DNSearchResult

// [Scanner] to read more data into the slice and try again with a
// longer slice starting at the same point in the input.
//
// The function is never called with an empty data slice unless atEOF
// is true. If atEOF is true, however, data may be non-empty and,
// as always, holds unprocessed text.
type SplitFunc func(data []byte, atEOF bool) (advance int, token []byte, err error)

// Errors returned by Scanner.
var (