kn[m] = kn[n] = 0;
            for (j = 0; j < 28; ++j) {
                l = j + totrot[i];
                if (l < 28) {
                    pcr[j] = pc1m[l];
                } else {
                    pcr[j] = pc1m[l - 28];
                }
            }
            for (j = 28; j < 56; ++j) {
                l = j + totrot[i];
                if (l < 56) {
                    pcr[j] = pc1m[l];

		} else {
			errs[i] = nil
		}
	}
	return errs
}

// Returns hash sum for whole-bitrot, nil for streaming-bitrot.
func bitrotWriterSum(w io.Writer) []byte {
	if bw, ok := w.(*wholeBitrotWriter); ok {
		return bw.Sum(nil)
	}
	return nil
}

// Returns the size of the file with bitrot protection
func bitrotShardFileSize(size int64, shardSize int64, algo BitrotAlgorithm) int64 {

}

func (b *streamingBitrotWriter) Write(p []byte) (int, error) {
	if len(p) == 0 {
		return 0, nil
	}
	if b.finished {
		return 0, errors.New("bitrot write not allowed")
	}
	if int64(len(p)) > b.shardSize {
		return 0, errors.New("unexpected bitrot buffer size")
	}
	if int64(len(p)) < b.shardSize {
		b.finished = true
	}
	b.h.Reset()
	b.h.Write(p)
	hashBytes := b.h.Sum(nil)

* Hay un subdirectorio `app/routers/` con otro archivo `__init__.py`, por lo que es un "subpaquete de Python": `app.routers`.
* El archivo `app/routers/items.py` está dentro de un paquete, `app/routers/`, por lo que es un submódulo: `app.routers.items`.
* Lo mismo con `app/routers/users.py`, es otro submódulo: `app.routers.users`.
* También hay un subdirectorio `app/internal/` con otro archivo `__init__.py`, por lo que es otro "subpaquete de Python": `app.internal`.

* En la clave `content`, que tiene como valor otro objeto JSON (`dict`) que contiene:
  * Una clave con el media type, por ejemplo, `application/json`, que contiene como valor otro objeto JSON, que contiene:
    * Una clave `schema`, que tiene como valor el JSON Schema del modelo, aquí es el lugar correcto.

Y estos modelos están compartiendo muchos de los datos y duplicando nombres y tipos de atributos.

Podríamos hacerlo mejor.

Podemos declarar un modelo `UserBase` que sirva como base para nuestros otros modelos. Y luego podemos hacer subclases de ese modelo que heredan sus atributos (declaraciones de tipos, validación, etc).

Por ejemplo, podrías crear un proyecto llamado `philosophers-stone`, este programa depende de otro paquete llamado **`harry`, usando la versión `1`**. Así que, necesitas instalar `harry`.

```mermaid
flowchart LR
    stone(philosophers-stone) -->|requires| harry-1[harry v1]
```

Podría ser otro contenedor, por ejemplo, con [Traefik](https://traefik.io/), manejando **HTTPS** y la adquisición **automática** de **certificados**.

/// tip | Consejo

Traefik tiene integraciones con Docker, Kubernetes, y otros, por lo que es muy fácil configurar y configurar HTTPS para tus contenedores con él.

///

Como se dice en la sección [Alternativas](alternatives.md):

<blockquote markdown="1">

**FastAPI** no existiría si no fuera por el trabajo previo de otros.

Ha habido muchas herramientas creadas antes que han ayudado a inspirar su creación.

Al agregar una estrella, otros usuarios podrán encontrarlo más fácilmente y ver que ya ha sido útil para otros.

## Observa el repositorio de GitHub para lanzamientos { #watch-the-github-repository-for-releases }