Failure with float inputs

is_multiple_of(1.0, 1/3) wrongly returns True. The value of y is 0.333333333333333314829616256247390992939472198486328125, and 1.0 is no multiple of that.

The easiest fix of that case is to remove the false advertising. As Chris said, declare the parameters int. That seems what you had in mind anyway, since your later "if it's not a multiple of 2, then it's odd" is only valid for integers. And if you declare them int, then the above failure example isn't your fault but mine, for using the function with invalid arguments.

Failure with int inputs

But even with int inputs, it still fails for example is_multiple_of(10000000000000001, 2), returning True. Because it unsafely calculates with float values. Better use just int and check whether dividing x by y leaves no remainder:

def is_multiple_of(x: int, y: int) -> bool:
    """Return whether x is a multiple of y."""
    if not y:
        return not x
    return not x % y

Docstring conventions

Note I also rewrote the docstring according to PEP 257 – Docstring Conventions:

prescribes the function or method’s effect as a command (“Do this”, “Return that”), not as a description; e.g. don’t write “Returns the pathname …”

The one-line docstring should NOT be a “signature” reiterating the function/method parameters (which can be obtained by introspection).

Strictly speaking, the latter is about docstrings like """function(a, b) -> list""", and shows """Do X and return a list.""" as a good docstring. But I think that's because the PEP is old and doesn't have type annotations in mind. If you declare -> bool, then I'd say in the spirit of the PEP's guideline, the docstring shouldn't reiterate that.

Properly supporting float inputs

But we can also support float arguments properly. The simplest way is to use Fraction, which gives us exact calculations:

from fractions import Fraction

def is_multiple_of(x: float, y: float) -> bool:
    """Return whether x is a multiple of y."""
    try:
        x = Fraction(x)
        y = Fraction(y)
    except (OverflowError, ValueError):
        return False
    if not y:
        return not x
    return not x % y

The OverflowError and ValueError are for infinite and "not a number" floats.

A few more ways:

def is_multiple_of(x: float, y: float) -> bool:
    """Return whether x is a multiple of y."""
    try:
        return not Fraction(x) % Fraction(y)
    except ZeroDivisionError:
        return not x
    except (OverflowError, ValueError):
        return False

import math

def is_multiple_of(x: float, y: float) -> bool:
    """Return whether x is a multiple of y."""
    if not math.isfinite(x) or not math.isfinite(y):
        return False
    if not y:
        return not x
    a, b = x.as_integer_ratio()
    c, d = y.as_integer_ratio()
    # Checking whether a/b is a multiple of c/d is equivalent 
    # to checking whether ad is a multiple of cb.
    return not (a*d) % (c*b)

def is_multiple_of(x: float, y: float) -> bool:
    """Return whether x is a multiple of y."""
    if not math.isfinite(x) or not math.isfinite(y):
        return False
    if not y:
        return not x
    a, b = x.as_integer_ratio()
    c, d = y.as_integer_ratio()
    if b > d:
        return False
    return not a % c

The last one uses that the denominators are powers of 2.

Setting aside issues with your is_multiple_of function, consider your get_even function.

def get_even(iterable, is_sorted: bool, return_tuple: bool):
    """Gets all the even numbers in a list/tuple and returns another list/tuple."""
    even_list = []
    for obj in iterable:
        even_list.append(obj)
        if not is_multiple_of(obj, 2):
            even_list.remove(obj)
    even_list = sorted(even_list) if is_sorted else even_list
    return even_list if not return_tuple else tuple(even_list)

Unnecessary work

Appending a value from iterable to even_list and then immediately removing it again if it is not a multiple of 2 is unnecessary work when we can just conditionally append in the first place.

def get_even(iterable, is_sorted: bool, return_tuple: bool):
    """Gets all the even numbers in a list/tuple and returns another list/tuple."""
    even_list = []
    for obj in iterable:
        if is_multiple_of(obj, 2):
            even_list.append(obj)
    even_list = sorted(even_list) if is_sorted else even_list
    return even_list if not return_tuple else tuple(even_list)

List comprehensions

But this can really be expressed as a list comprehension.

def get_even(iterable, is_sorted: bool, return_tuple: bool):
    """Gets all the even numbers in a list/tuple and returns another list/tuple."""
    even_list = [obj for obj in iterable if is_multiple_of(obj, 2)]
    even_list = sorted(even_list) if is_sorted else even_list
    return even_list if not return_tuple else tuple(even_list)

Conditional expressions vs. statements

Your use of conditional expressions also feels unnecessarily complex vs just using conditional statements. And at the same time, some whitespace doesn't go amiss.

def get_even(iterable, is_sorted: bool, return_tuple: bool):
    """Gets all the even numbers in a list/tuple and returns another list/tuple."""

    even_list = [obj for obj in iterable if is_multiple_of(obj, 2)]

    if is_sorted: 
        even_list.sort()

    if return_tuple:
        return tuple(even_list)
    else:
        return even_list

The same critique would go towards get_odd.

Why float at all?

Your is_mutliple_of function is specifically annotated to work on float values, but you never show these being used, and in the context of get_even and get_odd it makes no sense. What is an "odd" or "even" floating point number?

I would recommend replacing this function call with a much simpler test of the remainder using %:

def get_even(iterable, is_sorted: bool, return_tuple: bool):
    """Gets all the even numbers in a list/tuple and returns another list/tuple."""

    even_list = [obj for obj in iterable if obj % 2 == 0]

    if is_sorted: 
        even_list.sort()

    if return_tuple:
        return tuple(even_list)
    else:
        return even_list

Returning an iterable and keeping your functions focussed

Your get_even and get_odd functions take an iterable value, so maybe have them return an iterable. Having arguments to decide whether to sort the output or return it as a tuple is asking this function to do a lot. Instead let the caller decide how to use the returned values.

def get_even(iterable):
    for obj in iterable:
        if obj % 2 == 0:
            yield obj

A function should do one thing, and do it well. These functions pile on additional responsibility, as evidenced by their signatures:

def get_even(iterable, is_sorted: bool, return_tuple: bool):
def get_odd(iterable, is_sorted: bool, return_tuple: bool):
def get_uniques(iterable, is_sorted: bool, return_tuple: bool):

And we've duplicated the is_sorted and return_tuple logic in each function.

If we remove those arguments, then we can let the callers compose the operations they need (e.g. sorted(get_even(…)) or tuple(sorted(get_uniques(…))).

The first two functions simply filter an input list, and there's a built-in filter function to do that. We just need to provide suitable predicates:

def is_even(n: int) -> bool
    return n % 2 == 0

def is_odd(n: int) -> bool
    return n % 2 != 0

Then get_even(input) goes away, because it's just filter(is_even, input).

get_uniques is badly named - it seems to just eliminate duplicates (i.e. it returns the distinct values, not "unique variables"). Which we can do by simply constructing a set from the inputs.

If we really did want to find unique values - meaning those which appear exactly once in the input - then we could construct a collections.Counter and select items from that:

from collections import Counter
def uniques(values):
    return [x for x,n in Counter(values).items() if n == 1]

Certainly, the code in get_uniques() scales badly, as the linear obj in uniques test will get slower and slower as that list grows.

Input checking

It would be helpful to check for the common "divide-by-0" error in the is_multiple_of function. One way is to use try/except to gracefully handle the case where the y input is 0.

There is a built-in ZeroDivisionError exception.

Type hints

You added a helpful type hint for the function inputs. You could also add type hints for the return value of is_multiple_of:

def is_multiple_of(x: float, y: float) -> bool: