if err != nil {
		err = msgp.WrapError(err, "Versions")
		return
	}
	if cap(z.Versions) >= int(zb0002) {
		z.Versions = (z.Versions)[:zb0002]
	} else {
		z.Versions = make([]FileInfo, zb0002)
	}
	for za0001 := range z.Versions {
		err = z.Versions[za0001].DecodeMsg(dc)
		if err != nil {
			err = msgp.WrapError(err, "Versions", za0001)
			return
		}
	}
	var zb0003 uint32

			}
		case "Transient":
			z.Transient, err = dc.ReadBool()
			if err != nil {
				err = msgp.WrapError(err, "Transient")
				return
			}
		case "Versioned":
			z.Versioned, err = dc.ReadBool()
			if err != nil {
				err = msgp.WrapError(err, "Versioned")
				return
			}
		case "V1":
			z.V1, err = dc.ReadBool()
			if err != nil {
				err = msgp.WrapError(err, "V1")
				return
			}

  private fun hello(
    fromSource: BufferedSource,
    fromSink: BufferedSink,
  ) {
    val version = fromSource.readByte() and 0xff
    val methodCount = fromSource.readByte() and 0xff
    var selectedMethod = METHOD_NONE
    if (version != VERSION_5) {
      throw ProtocolException("unsupported version: $version")
    }
    for (i in 0 until methodCount) {
      val candidateMethod: Int = fromSource.readByte() and 0xff

// It returns true if the listing is non-versioned and the given object is expired.
func triggerExpiryAndRepl(ctx context.Context, o listPathOptions, obj metaCacheEntry) (skip bool) {
	versioned := o.Versioning != nil && o.Versioning.Versioned(obj.name)

	// skip latest object from listing only for regular
	// listObjects calls, versioned based listing cannot
	// filter out between versions 'obj' cannot be truncated

// format version and erasure coding information.
func (m *xlMetaV1Object) valid() bool {
	return isXLMetaFormatValid(m.Version, m.Format) &&
		isXLMetaErasureInfoValid(m.Erasure.DataBlocks, m.Erasure.ParityBlocks)
}

// Verifies if the backend format metadata is sane by validating
// the version string and format style.
func isXLMetaFormatValid(version, format string) bool {

	for i := range versions[:] {
		fis[0].Versions = append(fis[0].Versions, FileInfo{Name: object, Volume: volume, VersionID: versions[i]})
		deleted[i] = true
	}
	errs = xl.DeleteVersions(ctx, volume, fis, DeleteOptions{})
	if errs[0] != nil {
		t.Fatalf("expected nil error, got %v", errs[0])
	}
	checkVerExist(t)

	// Meta should be deleted now...

//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful
// but WITHOUT ANY WARRANTY; without even the implied warranty of

}

// InvalidVersionID invalid version id
type InvalidVersionID GenericError

func (e InvalidVersionID) Error() string {
	return "Invalid version id: " + e.Bucket + "/" + e.Object + "(" + e.VersionID + ")"
}

// VersionNotFound version does not exist.
type VersionNotFound GenericError

func (e VersionNotFound) Error() string {

```

Pero luego si deseas ejecutar `prisoner-of-azkaban`, necesitarás desinstalar `harry` versión `1` e instalar `harry` versión `3` (o simplemente instalar la versión `3` automáticamente desinstalaría la versión `1`).

<div class="termy">

```console
$ pip install "harry==3"
```

</div>

Y entonces terminarías con `harry` versión `3` instalada en tu entorno global de Python.

					fiVersions = fiVersions[vidMarkerIdx+1:]
				}
				afterV = ""
			}

			for _, version := range fiVersions {
				if !version.VersionPurgeStatus().Empty() {
					continue
				}
				versioned := vcfg != nil && vcfg.Versioned(entry.name)
				versions = append(versions, version.ToObjectInfo(bucket, entry.name, versioned))
			}

			continue
		}

		if entry.isDir() {
			if delimiter == "" {