Timer convenience class to time code execution for user output
Your Timer class contains two timers.

The entire duration timer.
The timer for tracking pauses.

I'd move the core timer code out into a separate class.
And we can see you're starting to repeat yourself.

Initializing a timer shouldn't start the timer.
If I open my timer app should the timer start running straight away?
If I want to create some timers but I don't want the timer to be started your class gives me no options.
However just not calling start_timer in __init__ will allow everyone to use your class however is desired.
If you really really want to start the timer when building the object, you can write a class method.
class Timer:
    @classmethod
    def run(cls, *args, **kwargs):
        self = cls(*args, **kwargs)
        self.start_timer()
        return self

# option 1
timer = Timer()
timer.start_timer()

# option 2
timer = Timer.run()


start_timer restarts the timers.
You should rename the method or make the method do what is expected.

If you call pause_timer twice without calling resume_timer your code acts as if the timer was never paused the first time.

I don't really see the point of making elapsed_seconds a property.

get_timer is doing way too much and violates the SRP principle.

Rounds elapsed timings to a specified amount of decimal places.
Prints the elapsed timings.
Restarts the timer.
Returns the elapsed timings.

You should make a function to round the elapsed timings.
Then leave printing and restarting to the user.

I'd a couple more methods from functionality I'd expect from a timer.


from time import perf_counter


class CoreTimer:
    def __init__(self):
        self.stop()

    def __bool__(self):
        return bool(self.start_time)

    def start(self):
        self.start_time = perf_counter()

    def stop(self):
        self.start_time = 0

    def time_taken(self, now):
        return now - self.start_time

    def elapsed(self):
        return self.time_taken(perf_counter())


class Timer:
    def __init__(self, decimal_places=5):
        self._decimal_places = decimal_places
        self._timer = CoreTimer()
        self._pause = CoreTimer()
        self._pause_length = 0

    def __str__(self):
        state = &quot;Paused&quot; if self._pause else &quot;Running&quot;
        return f&quot;{state} Timer at {self.elapsed_rounded()} seconds&quot;

    @classmethod
    def run(cls, *args, **kwargs):
        self = cls(*args, **kwargs)
        self.start()
        return self

    def start(self):
        if not self._timer:
            self._timer.start()

    def stop(self):
        self._timer.stop()
        self._pause.stop()
        self._pause_length = 0

    def restart(self):
        self.stop()
        self.start()

    def pause(self):
        if not self._pause:
            self._pause.start()

    def resume(self):
        if self._pause:
            self._pause_length += self._pause.elapsed()
            self._pause.stop()

    def elapsed(self):
        if self._pause:
            duration = self._timer.time_taken(self._pause.start_time)
        else:
            duration = self._timer.elapsed()
        return duration - self._pause_length

    def elapsed_rounded(self, decimal_places=None):
        if decimal_places is None:
            decimal_places = self.decimal_places
        return round(self.elapsed(), ndigits=decimal_places)