That sleep(0) just causes the process to idle there while waiting for switch interrupts. Since nothing in there programmatically ends the process, doing a Ctl-C will stop it.

use this === GPIO.add_event_detect(25, GPIO.RISING, callback=my_callback)

you are using GPIO.BOTH thats why you are getting the "Rising edge detected" message on both the push and release.

You can handle high speed interrupts on the R'Pi using Python easily if you make some configuration changes:

1. Constrain operation to cpu 0,1,2 for the 'Pi
2. Never do prints in the interrupt routines
3. Set syscheckinterval to a large value to reduce overhead
4. When you start your Python app, remap to cpu 3 and set the priority to realtime (-20)

This will allow you to get quite good response out to 5+kHz interrupt rates with no delays.

Here's some sample code:

#! /usr/bin/python2

##Interupt driven x1, x2 up/down encoder counter
##Jack Creasey

from RPi import GPIO
import os
import sys

##*********************************
#Define pin usage for encoder
#**********************************
phase_a = 21   
phase_a_dash= 16
phase_b = 20

##*********************************
#Define pin usage for PWM 
#**********************************
pwm_out = 12                #connect pin 12 to pin 24 to create a pwm timer interrupt
pwm_in = 24

#**********************************
#Setup GPIO
#**********************************

GPIO.setwarnings(False)
GPIO.cleanup()
GPIO.setmode(GPIO.BCM)
GPIO.setup(phase_a, GPIO.IN, pull_up_down=GPIO.PUD_UP)
GPIO.setup(phase_a_dash, GPIO.IN, pull_up_down=GPIO.PUD_UP)
GPIO.setup(phase_b, GPIO.IN, pull_up_down=GPIO.PUD_UP)
GPIO.setup(pwm_in, GPIO.IN, pull_up_down=GPIO.PUD_UP)

GPIO.setup(pwm_out, GPIO.OUT)  # Set GPIO pin 12 to output mode.
pwm = GPIO.PWM(pwm_out, 200)   # Initialize PWM pin and frequency
pwm.start(5)                   # Start PWM with 5% duty cycle


#**********************************
#Global variables
#**********************************
global counter
global lastcounter
global pwmticks
global lastpwmticks



def setup():

    #Find out our pid so we can remap to cpu 3
    mypid=os.getpid()
    myppid=os.getppid()

    print("My pid is "), mypid

    print('Setting cpu affinity to cpu 3')
    select_cpu="sudo taskset  -cp 3 "
    print('Setting priority to -20')
    set_priority="sudo renice -n -20 -p "

    #Call out to the os to remap the cpu and set priority high
    ret=os.system(set_priority+str(mypid))
    ret=os.system(select_cpu+str(mypid))

    sys.setcheckinterval(1000); ##no Python threading so just let Python run for a long time




def my_callback(channel):       #x1 sensing

    global counter

    if GPIO.input(phase_b):
            counter += 1
    else:
            counter -= 1

def my_callback1(channel):      #x2 sensing

    global counter

    if GPIO.input(phase_b):
            counter -= 1
    else:
            counter += 1

def my_callback2(channel):      #PWM interrupt 

    global pwmticks

    pwmticks += 1


setup()
counter = 0
lastcounter=counter

pwmticks=0
lastpwmticks=pwmticks

GPIO.add_event_detect(phase_a, GPIO.FALLING  , callback=my_callback)        #x1
GPIO.add_event_detect(phase_a_dash, GPIO.RISING  , callback=my_callback1)   #x2
GPIO.add_event_detect(pwm_in, GPIO.RISING  , callback=my_callback2)



try:

    while True:                             #busy work for Python main loop to do
        if counter != lastcounter:
            lastcounter=counter
            sys.stdout.write("\r" + str(counter) + "   \r")
            sys.stdout.flush()

        if pwmticks >= (lastpwmticks + 1000):
            lastpwmticks=pwmticks
            sys.stdout.write("\n Ticks= " + str(lastpwmticks) + "   \n")
            sys.stdout.flush()

except KeyboardInterrupt:
      print("Ctl C pressed - ending program") 

wiringPi uses interrupts, e.g. with the wiringPiISR function.

pigpio uses interrupts, e.g. with the gpioSetISRFunc function.

lgpio uses interrupts. e.g. with the gGpioSetAlertsFunc function.

None of the above use polling or busy waits. I can only assume you are confused because at a low level they use a Linux function called poll. But this function does not poll the GPIO in the sense you mean.

Linux handles interrupts. As part of its interrupt handling it will eventually schedule one of the above functions.

pigpio can additionally use GPIO polling via DMA which happens to be more accurate and reliable for short (few µs) level changes.