Configuration

def auth_settings(self) -> AuthSettings:
    """Gets Auth Settings dict for api client.

    :return: The Auth Settings information dict.
    """
    auth: AuthSettings = {}
    if self.access_token is not None:
        auth["bearer"] = {
            "type": "bearer",
            "in": "header",
            "format": "JWT",
            "key": "Authorization",
            "value": "Bearer " + self.access_token,
        }
    if "cookie" in self.api_key:
        auth["cookie"] = {
            "type": "api_key",
            "in": "cookie",
            "key": "immich_access_token",
            "value": self.get_api_key_with_prefix(
                "cookie",
            ),
        }
    if "api_key" in self.api_key:
        auth["api_key"] = {
            "type": "api_key",
            "in": "header",
            "key": "x-api-key",
            "value": self.get_api_key_with_prefix(
                "api_key",
            ),
        }
    return auth

def get_api_key_with_prefix(
    self, identifier: str, alias: Optional[str] = None
) -> Optional[str]:
    """Gets API key (with prefix if set).

    :param identifier: The identifier of apiKey.
    :param alias: The alternative identifier of apiKey.
    :return: The token for api key authentication.
    """
    if self.refresh_api_key_hook is not None:
        self.refresh_api_key_hook(self)
    key = self.api_key.get(
        identifier, self.api_key.get(alias) if alias is not None else None
    )
    if key:
        prefix = self.api_key_prefix.get(identifier)
        if prefix:
            return "%s %s" % (prefix, key)
        else:
            return key

    return None

def get_basic_auth_token(self) -> Optional[str]:
    """Gets HTTP basic authentication header (string).

    :return: The token for basic HTTP authentication.
    """
    username = ""
    if self.username is not None:
        username = self.username
    password = ""
    if self.password is not None:
        password = self.password

    return "Basic " + base64.b64encode(
        (username + ":" + password).encode("utf-8")
    ).decode("utf-8")

@classmethod
def get_default(cls) -> Self:
    """Return the default configuration.

    This method returns newly created, based on default constructor,
    object of Configuration class or returns a copy of default
    configuration.

    :return: The configuration object.
    """
    if cls._default is None:
        cls._default = cls()
    return cls._default

@classmethod
def get_default_copy(cls) -> Self:
    """Deprecated. Please use `get_default` instead.

    Deprecated. Please use `get_default` instead.

    :return: The configuration object.
    """
    return cls.get_default()

def get_host_from_settings(
    self,
    index: Optional[int],
    variables: Optional[ServerVariablesT] = None,
    servers: Optional[List[HostSetting]] = None,
) -> str:
    """Gets host URL based on the index and variables
    :param index: array index of the host settings
    :param variables: hash of variable and the corresponding value
    :param servers: an array of host settings or None
    :return: URL based on host settings
    """
    if index is None:
        return self._base_path

    variables = {} if variables is None else variables
    servers = self.get_host_settings() if servers is None else servers

    try:
        server = servers[index]
    except IndexError:
        raise ValueError(
            "Invalid index {0} when selecting the host settings. "
            "Must be less than {1}".format(index, len(servers))
        )

    url = server["url"]

    # go through variables and replace placeholders
    for variable_name, variable in server.get("variables", {}).items():
        used_value = variables.get(variable_name, variable["default_value"])

        if (
            "enum_values" in variable
            and variable["enum_values"]
            and used_value not in variable["enum_values"]
        ):
            raise ValueError(
                "The variable `{0}` in the host URL has invalid value "
                "{1}. Must be {2}.".format(
                    variable_name, variables[variable_name], variable["enum_values"]
                )
            )

        url = url.replace("{" + variable_name + "}", used_value)

    return url

def get_host_settings(self) -> List[HostSetting]:
    """Gets an array of host settings

    :return: An array of host settings
    """
    return [
        {
            "url": "https://raw.githubusercontent.com/api",
            "description": "No description provided",
        }
    ]

@classmethod
def set_default(cls, default: Optional[Self]) -> None:
    """Set default instance of configuration.

    It stores default configuration, which can be
    returned by get_default_copy method.

    :param default: object of Configuration
    """
    cls._default = default

def to_debug_report(self) -> str:
    """Gets the essential information for debugging.

    :return: The report for debugging.
    """
    return (
        "Python SDK Debug Report:\n"
        "OS: {env}\n"
        "Python Version: {pyversion}\n"
        "Version of the API: 2.7.5\n"
        "SDK Package Version: 1.0.0".format(env=sys.platform, pyversion=sys.version)
    )