# Sub-dependencies { #sub-dependencies }

You can create dependencies that have **sub-dependencies**.

They can be as **deep** as you need them to be.

**FastAPI** will take care of solving them.

## First dependency "dependable" { #first-dependency-dependable }

You could create a first dependency ("dependable") like:

{* ../../docs_src/dependencies/tutorial005_an_py310.py hl[8:9] *}

     * @param loader
     *            The class loader. Must not be {@literal null}.
     * @param className
     *            The binary name of the class. Must not be {@literal null} or an empty string.
     * @return The resulting <code>Class</code> object.
     * @throws ClassNotFoundRuntimeException
     *             If the class could not be found.
     * @see java.lang.ClassLoader#loadClass(String)
     */

			// if we cannot compact ourself, we are done.
			break
		}
		removing := d.totalChildrenRec(candidate.Key())
		flat := d.sizeRecursive(candidate.Key())
		if flat == nil {
			leaves = leaves[1:]
			continue
		}
		// Appears to be printed with _MINIO_SERVER_DEBUG=off
		// console.Debugf("compacting %v, removing %d children\n", candidate, removing)

		flat.Compacted = true
		d.deleteRecursive(candidate)

  /**
   * Returns the value associated with {@code key} in this cache, or {@code null} if there is no
   * cached value for {@code key}.
   *
   * @since 11.0
   */
  @CanIgnoreReturnValue // TODO(b/27479612): consider removing this?
  @Nullable V getIfPresent(@CompatibleWith("K") Object key);

  /**
   * Returns the value associated with {@code key} in this cache, obtaining that value from {@code

improvements made in alternate versions of the program, if they
receive widespread use, become available for other developers to
incorporate.  Many developers of free software are heartened and
encouraged by the resulting cooperation.  However, in the case of
software used on network servers, this result may fail to come about.
The GNU General Public License permits making a modified version and

   * specifier that is not already known to be valid.
   *
   * @throws ParseException if the specifier is not valid.
   */
  @CanIgnoreReturnValue // TODO(b/219820829): consider removing
  public static HostSpecifier from(String specifier) throws ParseException {
    try {
      return fromValid(specifier);
    } catch (IllegalArgumentException e) {

 *
 * <p>For example, an XML escaper would convert the literal string {@code "Foo<Bar>"} into {@code
 * "Foo&lt;Bar&gt;"} to prevent {@code "<Bar>"} from being confused with an XML tag. When the
 * resulting XML document is parsed, the parser API will return this text as the original literal
 * string {@code "Foo<Bar>"}.
 *
 * <p><b>Note:</b> This class is similar to {@link CharEscaper} but with one very important

 *
 * <p>For example, an XML escaper would convert the literal string {@code "Foo<Bar>"} into {@code
 * "Foo&lt;Bar&gt;"} to prevent {@code "<Bar>"} from being confused with an XML tag. When the
 * resulting XML document is parsed, the parser API will return this text as the original literal
 * string {@code "Foo<Bar>"}.
 *
 * <p><b>Note:</b> This class is similar to {@link CharEscaper} but with one very important

```kotlin
cache.delete()
```
 
## Pruning the Cache

Pruning the entire Cache to clear space temporarily can be done using evictAll.

```kotlin
cache.evictAll()
```

Removing individual items can be done using the urls iterator.
This would be typical after a user initiates a force refresh by a pull to refresh type action.

```java
    val urlIterator = cache.urls()

        .build()
        .encodedPath,
    ).isEqualTo("/a/b/c/")
  }

  @Test
  fun addPathSegments() {
    val base = parse("http://host/a/b/c")

    // Add a string with zero slashes: resulting URL gains one slash.
    assertThat(
      base
        .newBuilder()
        .addPathSegments("")
        .build()
        .encodedPath,
    ).isEqualTo("/a/b/c/")
    assertThat(