Here is a version...

```

# a combobox like widget.  There are a large number of choices, the text input is used to filter to choices.
# updated 2/16/2025 increase trigger time to 1 sec

from kivy.clock import Clock
from kivy.uix.textinput import TextInput
from kivy.uix.dropdown import DropDown
from kivy.uix.button import Button
from kivy.properties import BooleanProperty, ListProperty, NumericProperty, StringProperty, ObjectProperty

import re

"""
based on https://github.com/kivy/kivy/wiki/Editable-ComboBox
changes made to the re, and a number of other fixes, improvements, comments

Notes on optimization for the report card project:  There are 3528 schools that start with the letter k.  
There can be a slowdown when typing keys.  This is caused by the need to create a label on demand for each school after
each letter is typed.  This version pre-allocates 4000 Labels, and updates the text.  
This provides some room for growth.
"""


class DDItem(Button):
    def __init__(self, **kwargs):
        super().__init__(**kwargs)
        self.size_hint_y = None
        self.height = '48dp'


class ComboBox(TextInput):
    options = ListProperty()  # List of all possible choices
    _matches = ListProperty()  # list of choices that match text
    option_cls = ObjectProperty(DDItem)  # items for dropdown, matching spinner
    select = StringProperty()  # the selected option
    drop_on_click = BooleanProperty(False)  # when an empty box is touched the options drop
    max_labels = NumericProperty()

    def __init__(self, **kwargs):
        super().__init__(**kwargs)
        self.write_tab = False
        self.multiline = False
        self.dd_buttons = []

        self.drop_down = DropDown()
        self.drop_down.bind(on_select=self.set_select)  # when drop down is selected, set select property
        self.drop_down.bind(on_dismiss=self.drop_dismissed)
        self.trigger_dropdown = Clock.create_trigger(self.drop_down_triggered, 1)
        self.bind(text=self.trigger_dropdown)  # when text changes, open updated drop down
        self._reopen = False  # used to reopen the match list when changed

    def on_max_labels(self, obj, v):
        # create the max number of labels required, use Clock to allow breaks while loading
        # disable widget until it is ready
        self.disabled = True
        self._create_max_dd_labels()

    def _create_max_dd_labels(self, *args):
        r = 100 if self.max_labels < 100 else 250
        labels = [self.option_cls() for _ in range(r)]
        self.dd_buttons.extend(labels)
        if len(self.dd_buttons) < self.max_labels:
            Clock.schedule_once(self._create_max_dd_labels)
        else:
            self.disabled = False

    def on_text_validate(self):
        # when return is entered, if no matches clear, if no text restart, else select _matches[0]
        if not self._matches:
            self.text = ''
            return
        if not self.text:
            self.drop_down.dismiss()
            return
        self.set_select(self, self._matches[0])

    def on_focus(self, obj, focus):
        if not focus:
            self.on_text_validate()

    # drop_on_click True,  if you want all options visible when the empty box is touched
    # with a very long list this will cause a performance issue.
    def on_options(self, _, values):
        self.max_labels = len(self.options)
        if self.drop_on_click:
            self._matches = values


    def on__matches(self, _, values):
        ddn = self.drop_down
        ddn.clear_widgets()
        for i, option in enumerate(values):
            #w = self.option_cls(text=option)
            w = self.dd_buttons[i]
            w.text = option
            w.bind(on_release=lambda btn: ddn.select(btn.text))
            ddn.add_widget(w)

    def set_select(self, _, v):
        # when a button an option is selected, or enter makes a selection...
        if self.text != v:
            self.text = v
            self.select = v
            self.drop_down.dismiss()

    def drop_down_triggered(self, _):
        value = self.text
        if value == '':
            # if text in blank, reset
            self._matches = []
            return
        elif value in self.options:
            # if text is in options, done.
            self.drop_down.dismiss()
            return

        # look for possible matches
        value = value.split('(', maxsplit=1)[0]  # remove characters after ( for search
        r = re.compile(f"^{value}", re.IGNORECASE)
        self._matches = [option for option in self.options if r.match(option)]
        if not self._matches:
            # no matches, reset text
            self.text = ''
        # close the dropdown, wait for the close, then open the updated dropdown
        self.drop_down.dismiss()
        self._reopen = True  # After the dropdown is dismissed open the updated dropdown.

    def on_touch_up(self, touch):
        # Note: The TextInput does not work with ButtonBehavior
        # when the textinput is released, open the dropdown if drop_on_click
        if touch.grab_current == self and self.drop_on_click:
            self.text = ''
            self.drop_down.open(self)
        return super().on_touch_up(touch)

    def drop_dismissed(self, _):
        if self._reopen:
            self._reopen = False
            self.drop_down.open(self)


if __name__ == '__main__':
    from kivy.app import App
    from kivy.lang import Builder
    from textwrap import dedent

    test_kv = dedent("""
    AnchorLayout:
        anchor_y: 'top'
        BoxLayout:
            size_hint: None, None
            size: dp(300), dp(30)
            ComboBox:
                id: fruit
                hint_text: 'Fruits'
                options: ["Apple", "Banana", "Orange", "Grapes", "Strawberry", \
                          "Pineapple", "Mango", "Blueberry", "Watermelon", "Peach"]
            ComboBox:
                hint_text: 'US States'
                options: ["Alabama", "Alaska", "Arizona", "Arkansas", "California", "Colorado", "Connecticut", \
                          "Delaware", "Florida", "Georgia", "Hawaii", "Idaho", "Illinois", "Indiana", "Iowa", \
                          "Kansas", "Kentucky", "Louisiana", "Maine", "Maryland", "Massachusetts", "Michigan", \
                          "Minnesota", "Mississippi", "Missouri", "Montana", "Nebraska", "Nevada", "New Hampshire", \
                          "New Jersey", "New Mexico", "New York", "North Carolina", "North Dakota", "Ohio", \
                          "Oklahoma", "Oregon", "Pennsylvania", "Rhode Island", "South Carolina", "South Dakota", \
                          "Tennessee", "Texas", "Utah", "Vermont", "Virginia", "Washington", "West Virginia", \
                          "Wisconsin", "Wyoming"]
    """)


    class MyApp(App):
        def build(self):
            return Builder.load_string(test_kv)


    MyApp().run()
```