def extract_followers(self, user_object: tweepy.User) -> Dict[str, str | int]:
    """Extract IDs, names, and screen names from a user's followers.

    Args:
        user_object (tweepy.User): Tweepy User Object.

    Returns:
        Dict[str, str | int]: Dictionary containing IDs, names, and screen names.
    """
    info = {"followers_ids": list(), "followers_names": list(), "followers_screen_names": list()}
    # extract follower IDs
    info["followers_ids"] = user_object.follower_ids()
    # extract names and screen names
    for follower in user_object.followers():
        info["followers_names"].append(follower.name)
        info["followers_screen_names"].append(follower.screen_name)
    return info

def extract_followees(self, user_object: tweepy.User) -> Dict[str, str | int]:
    """Extract IDs, names, and screen names from a user's followees.

    Args:
        user_object (tweepy.User): Tweepy User Object.

    Returns:
        Dict[str, str | int]: Dictionary containing IDs, names, and screen names.
    """
    info = {"followees_ids": list(), "followees_names": list(), "followees_screen_names": list()}
    # extract IDs, names and screen names
    for followee in user_object.friends():
        info["followees_ids"].append(followee.id)
        info["followees_names"].append(followee.name)
        info["followees_screen_names"].append(followee.screen_name)
    return info

def clean_tweet(self, tweet: str) -> str:
    """Utility function to clean tweet text by removing links, special characters using simple regex statements.

    Args:
        tweet (str): Raw text of the Tweet.

    Returns:
        str: Cleaned Tweet
    """
    return " ".join(re.sub(r"(@[A-Za-z0-9]+)|([^0-9A-Za-z \t])|(\w+:\/\/\S+)", " ", tweet).split())

def detect_tweet_sentiment(self, tweet: str) -> dict:
    """Utility function to classify sentiment of passed tweet using textblob's sentiment method. English Tweets only.

    Args:
        tweet (str): The raw text of the Tweet.

    Returns:
        str: the sentiment of the Tweet (either positive, neutral, or negative) and the polarity scores.
    """
    # create VADER instance
    analyser = SentimentIntensityAnalyzer()
    # get polarity scores from cleaned tweet
    polarity_scores = analyser.polarity_scores(self.clean_tweet(tweet))
    # define label
    if polarity_scores["compound"] >= 0.05:
        label = "positive"
    elif polarity_scores["compound"] <= -0.05:
        label = "negative"
    else:
        label = "neutral"
    # return label and polarity scores
    return {"label": label, "polarity_scores": polarity_scores}

def calc_similarity(self, user_objs: List[dict] | None = None, tweet_metrics: List[Dict[int, dict]] | None = None, *, features: List[str]) -> dict:
    """Calculates the euclidean distance of users/tweets based on a feature vector. Either user objects or Tweet objects must be specified, not both.

    Args:
        user_objs (List[dict] | None, optional): List of serialized Twitter user objects from Twitter Search API v1. Defaults to None.
        tweet_metrics (List[Dict[int | dict]] | None, optional): List of public Tweet metrics as dictionaries with Tweet IDs as keys. Defaults to None.
        features (List[str]): Features that should be contained in the feature vector. Features have to be numeric and must belong to the respective object (i.e., user or tweet.)

    Raises:
        ValueError: If either 'user_objs' and 'tweet_objs' or none of them were provided.
        AssertionError: If non-numeric feature was provided in the 'features' list.

    Returns:
        dict: Unique pair of users/tweets containing the respective euclidean distance. Sorted in ascending order.
    """
    # init empty dict to store distances
    distances = dict()
    # if users and tweets were provided
    if user_objs and tweet_metrics:
        raise ValueError("Either 'user_objs' or 'tweet_metrics' must be specified, not both.")
    # if only user_objs were provided
    elif user_objs:
        # iterate over every uniqe pair
        for i in range(len(user_objs)):
            for j in range(i + 1, len(user_objs)):
                # get user objects for each pair
                user_i = user_objs[i]
                user_j = user_objs[j]
                # build feature vector
                vec_i = np.array([user_i[feature] for feature in features])
                vec_j = np.array([user_j[feature] for feature in features])
                # feature vectors have to contain numeric values
                assert all(isinstance(feat, Number) for feat in vec_i), "only numeric features are allowed"
                assert all(isinstance(feat, Number) for feat in vec_j), "only numeric features are allowed"
                # calc euclidean distance
                distances[(user_i["id"], user_j["id"])] = np.linalg.norm(vec_i - vec_j, ord=2)
    elif tweet_metrics:
        # iterate over every uniqe pair
        for i in range(len(tweet_metrics)):
            for j in range(i + 1, len(tweet_metrics)):
                # get Tweet objects for each pair
                tweet_i = list(tweet_metrics.values())[i]
                tweet_j = list(tweet_metrics.values())[j]
                # build feature vector
                vec_i = np.array([tweet_i[feature] for feature in features])
                vec_j = np.array([tweet_j[feature] for feature in features])
                # feature vectors have to contain numeric values
                assert all(isinstance(feat, Number) for feat in vec_i), "only numeric features are allowed"
                assert all(isinstance(feat, Number) for feat in vec_j), "only numeric features are allowed"
                # calc euclidean distance
                distances[(list(tweet_metrics.keys())[i], list(tweet_metrics.keys())[j])] = np.linalg.norm(vec_i - vec_j, ord=2)
    # if none was provided
    else:
        raise ValueError("Either 'user_objs' or 'tweet_metrics' must be provided.")
    # sort dict in ascendin order
    sorted_values = dict(sorted(distances.items(), key=operator.itemgetter(1)))
    return sorted_values