switch {
		case isSysErrNotDir(err):
			// File path cannot be verified since one of
			// the parents is a file.
			return errFileAccessDenied
		case isSysErrPathNotFound(err):
			// This is a special case should be handled only for
			// windows, because windows API does not return "not a
			// directory" error message. Handle this specifically
			// here.
			return errFileAccessDenied
		}
	}
	return err
}

MC_CONFIG_DIR="{{ .Values.configPathmc }}" MC="/usr/bin/mc --insecure --config-dir ${MC_CONFIG_DIR}" {{- else }} MC="/usr/bin/mc --insecure" {{- end }} # AccessKey and secretkey credentials file are added to prevent shell execution errors caused by special characters. # Special characters for example : ',",<,>,{, MINIO_ACCESSKEY_SECRETKEY_TMP="/tmp/accessKey_and_secretKey_svcacct_tmp" # connectToMinio # Use a check-sleep-check loop to wait for MinIO service to be available connectToMinio() { SCHEME=$1 ATTEMPTS=0...

---> 100%
```

</div>

////

It will install all the dependencies and your local FastAPI in your local environment.

### Using your local FastAPI

If you create a Python file that imports and uses FastAPI, and run it with the Python from your local environment, it will use your cloned local FastAPI source code.

# Dependencies - `Depends()` and `Security()`

## `Depends()`

Dependencies are handled mainly with the special function `Depends()` that takes a callable.

Here is the reference for it and its parameters.

You can import it directly from `fastapi`:

```python
from fastapi import Depends
```

::: fastapi.Depends

## `Security()`

	} else if addr1Local, err = isLocalHost(host1, port1, port1); err != nil {
		// Host not empty, check if it is local
		return false, err
	}

	if host2 == "" {
		// If empty host means it is localhost
		addr2Local = true
	} else if addr2Local, err = isLocalHost(host2, port2, port2); err != nil {
		// Host not empty, check if it is local
		return false, err
	}

	// If both of addresses point to the same machine, check if

    }

    @Test
    @DisplayName("Should get local host name")
    void testGetLocalName() {
        // When
        NetbiosName localName = nameServiceClient.getLocalName();

        // Then
        assertNotNull(localName, "Local name should not be null");
        assertTrue(localName.getName().length() > 0, "Local name should not be empty");
    }

    @Test

                (ThreadGroup) null, finalizer, threadName, defaultStackSize, inheritThreadLocals);
      } catch (Throwable t) {
        logger.log(
            Level.INFO, "Failed to create a thread without inherited thread-local values", t);
      }
    }
    if (thread == null) {
      thread = new Thread((ThreadGroup) null, finalizer, threadName);
    }
    thread.setDaemon(true);

    try {

        return Arrays.asList(repositorySystem.buildArtifactRepository(repository));
    }

    protected ArtifactRepository getLocalRepository() throws Exception {
        File repoDir = new File(getBasedir(), "target/local-repo").getAbsoluteFile();

        return repositorySystem.createLocalRepository(repoDir);
    }

    @Test
    void testThatASystemScopedDependencyIsNotResolvedFromRepositories() throws Exception {
        //

     * This specialized method returns a Map of users and local groups for the
     * target server where keys are SIDs representing an account and each value
     * is an ArrayList of SIDs represents the local groups that the account is
     * a member of.
     *
     * This method is designed to assist with computing access control for a
     * given user when the target object's ACL has local groups. Local groups

				t.Errorf("error: expected = <nil>, got = %v", err)
			}
		}
		remotePeers, local := zendpoints.peers()
		if !reflect.DeepEqual(remotePeers, testCase.expectedResult) {
			t.Errorf("expected: %v, got: %v", testCase.expectedResult, remotePeers)
		}
		if local != testCase.expectedLocal {
			t.Errorf("expected: %v, got: %v", testCase.expectedLocal, local)
		}
	}