Based on my testing, this is because threads can only be started once, and as the timer relies on a thread, the timer can only be started once. This means that the only way to re-start the timer would be to do:

def newTimer():
    global t
    t = Timer(10.0,api_call)
newTimer()

instead of the t = Timer part, and do

t.cancel()
newTimer()
t.start()

instead of the current re-start code.

This makes your full code:

from threading import Timer

def api_call():
    print("Call that there api")

def newTimer():
    global t
    t = Timer(10.0,api_call)
newTimer()


def my_callback(channel):

    if something_true:
        print('reset timer and start again')
        t.cancel()
        newTimer()
        t.start()
        print("\n timer started")
    elif something_else_true:
        t.cancel()
        print("timer canceled")
    else:
       t.cancel()
       print('cancel timer for sure')

try:
    if outside_input_that_can_happen_a_lot:
        my_callback()

finally:
    #cleanup objects

Hope this helps.

The threading.Timer() class is likely what you're looking for:

from __future__ import print_function
from time import sleep
from random import random
from threading import Timer

def timeout():
    print("Alarm!")

t = Timer(10.0, timeout)
t.start()              # After 10 seconds, "Alarm!" will be printed

sleep(5.0)
if random() < 0.5:     # But half of the time
     t.cancel()        # We might just cancel the timer
     print('Canceling')

You could probably accomplish it with threading really elegantly but if you need a quick fix you could try

import time
timer = 15 * 60 # 60 seconds times 15 mins
while timer > 0:
    time.sleep(0.985) # don't sleep for a full second or else you'll be off
    timer -= 1
    if someCondition:
          timer = 15 * 60
executeCode() # called when time is zero and while loop is exited

Here is a corrected version:

from __future__ import print_function


from threading import Timer


def hello():
    print("Hello World!")


class RepeatingTimer(object):

    def __init__(self, interval, f, *args, **kwargs):
        self.interval = interval
        self.f = f
        self.args = args
        self.kwargs = kwargs

        self.timer = None

    def callback(self):
        self.f(*self.args, **self.kwargs)
        self.start()

    def cancel(self):
        self.timer.cancel()

    def start(self):
        self.timer = Timer(self.interval, self.callback)
        self.timer.start()


t = RepeatingTimer(3, hello)
t.start()

Example Run:

$ python -i foo.py
>>> Hello World!

>>> Hello World!

>>> t.cancel()

I think you may misunderstand how the "timer" works

what we usually do is intitializing a variable with time.time() wich represents the number of seconds elapsed since 01/01/1970 and then when we want to mesure the time like a timer, we substract a second instance of time.time() with the previous one, which give us the mesured time between the two.

Using time.sleep(n) simply waits n seconds before going to the next line, so it won't reset your timer

you need to rethink your code around these notions

Try this:

import time
import keyboard
x=60
while True:
    try:
        if keyboard.is_pressed('space'):
            x=60
            print(f"Timer reset to {x}")
        elif keyboard.is_pressed('space'):
            break
        else:
            print(f"{x} seconds left")
            time.sleep(1)
            x-=1
    except Exception:
        pass

from Tkinter import *
import time

class App():
    def __init__(self):
        self.window = Tk()
        self.root = Frame(self.window, height=200,width=200)
        self.root.pack()
        self.root.pack_propagate(0)
        self.window.title('Timer')
        self.label = Label(text="")
        self.label.pack()
        self.sec = 11
        self.timerupdate()
        self.root.mainloop()
    def timerupdate(self):
        if self.sec!=0:
            self.sec-=1
            self.label.configure(text=self.sec)
            self.root.after(1000, self.timerupdate)
        if self.sec == 0:
          self.sec = 11

app=App()
app.mainloop()

Just set it so that your self.sec variable resets to 11 when your timer hits 0.

You would call the cancel method after you start the timer:

import time
import threading

def hello():
    print "hello, world"
    time.sleep(2)

t = threading.Timer(3.0, hello)
t.start()
var = 'something'
if var == 'something':
    t.cancel()

You might consider using a while-loop on a Thread, instead of using a Timer.
Here is an example appropriated from Nikolaus Gradwohl's answer to another question:

import threading
import time

class TimerClass(threading.Thread):
    def __init__(self):
        threading.Thread.__init__(self)
        self.event = threading.Event()
        self.count = 10

    def run(self):
        while self.count > 0 and not self.event.is_set():
            print self.count
            self.count -= 1
            self.event.wait(1)

    def stop(self):
        self.event.set()

tmr = TimerClass()
tmr.start()

time.sleep(3)

tmr.stop()

Here's an example that implements a reset method to "extend" the timer by the original interval. It uses an internal Timer object rather than subclassing threading.Timer.

from threading import Timer
import time


class ResettableTimer(object):
    def __init__(self, interval, function):
        self.interval = interval
        self.function = function
        self.timer = Timer(self.interval, self.function)

    def run(self):
        self.timer.start()

    def reset(self):
        self.timer.cancel()
        self.timer = Timer(self.interval, self.function)
        self.timer.start()


if __name__ == '__main__':
    t = time.time()
    tim = ResettableTimer(5, lambda: print("Time's Up! Took ", time.time() - t, "seconds"))
    time.sleep(3)
    tim.reset()

Output:

Time's Up! Took 8.011203289031982 seconds