Chatbot not updating/filling slots

i am creating a chatbot for ordering pizza in rasa 0.14.5, python 3.6.4, linux ubuntu. the user has to input the size, type, toppings(optional) and the number of pizzas they want. however during training, i can succesfully update the size slot, but i cant seem to update the pizzatype slot as it shows null value, and it loops at that point.

i have the following datasets stories.md (2.2 KB) domain.yml (3.2 KB) nlu.md (5.2 KB)

actions.py file is

# -*- coding: utf-8 -*-
from typing import Dict, Text, Any, List, Union

from rasa_core_sdk import ActionExecutionRejection
from rasa_core_sdk import Tracker
from rasa_core_sdk.events import SlotSet
from rasa_core_sdk.executor import CollectingDispatcher
from rasa_core_sdk.forms import FormAction, REQUESTED_SLOT


class PizzaForm(FormAction):
    #Example of a custom form action

    def name(self):
        # type: () -> Text
        #Unique identifier of the form

        return "pizza_form"

    @staticmethod
    def required_slots(tracker: Tracker) -> List[Text]:
        #A list of required slots that the form has to fill

        return ["size", "pizzatype", "ask_toppings", "toppings","num_pizza"]

    def slot_mappings(self):
        # type: () -> Dict[Text: Union[Dict, List[Dict]]]
       # A dictionary to map required slots to
        #    - an extracted entity
        #    - intent: value pairs
          #  - a whole message
         #   or a list of them, where a first match will be picked

        return {"size": self.from_entity(entity="size",
                                         intent="informsize"),
                "pizzatype": self.from_entity(entity="pizzatype",
                                              intent="informtype"),
                "ask_toppings": [self.from_entity(entity="toppings"),
                                    self.from_intent(intent='affirm',
                                                     value=True),
                                    self.from_intent(intent='deny',
                                                     value=False)],
                "toppings": self.from_entity(entity="toppings",
                                             intent="informtoppings"),
                "num_pizza": self.from_entity(entity="number"),
                "feedback": [self.from_entity(entity="feedback"),
                             self.from_text()]}

    @staticmethod
    def size_db():
        # type: () -> List[Text]
        #Database of supported sizes
        return ["large",
                "extra large",
                "medium",
                "small"]
                
    @staticmethod
    def pizzatype_db():
        # type: () -> List[Text]
        # Database of supported pizzatypes
        return ["BBQ",
                "Buffalo chicken",
                "Hawaiian",
                "cheese"]
    
    @staticmethod
    def toppings_db():
        # type: () -> List[Text]
        #Database of supported toppings
        return ["onions",
                "mushrooms",
                "extra cheese",
                "sausage",
                "green peppers"]
    
    
    
    
    

    @staticmethod
    def is_int(string: Text) -> bool:
        # Check if a string is an integer
        try:
            int(string)
            return True
        except ValueError:
            return False

    def validate(self,
                 dispatcher: CollectingDispatcher,
                 tracker: Tracker,
                 domain: Dict[Text, Any]) -> List[Dict]:
        # Validate extracted requested slot
         #   else reject the execution of the form action
    
        # extract other slots that were not requested
        # but set by corresponding entity
        slot_values = self.extract_other_slots(dispatcher, tracker, domain)

        # extract requested slot
        slot_to_fill = tracker.get_slot(REQUESTED_SLOT)
        if slot_to_fill:
            slot_values.update(self.extract_requested_slot(dispatcher,
                                                           tracker, domain))
            if not slot_values:
                # reject form action execution
                # if some slot was requested but nothing was extracted
                # it will allow other policies to predict another action
                raise ActionExecutionRejection(self.name(),
                                               "Failed to validate slot {0} "
                                               "with action {1}"
                                               "".format(slot_to_fill,
                                                         self.name()))

        # we'll check when validation failed in order
        # to add appropriate utterances
        for slot, value in slot_values.items():
            if slot == 'size':
                if value.lower() not in self.size_db():
                    dispatcher.utter_template('utter_wrong_size', tracker)
                    # validation failed, set slot to None
                    slot_values[slot] = None
            
            elif slot == 'pizzatype':
                if value.lower() not in self.pizzatype_db():
                    dispatcher.utter_template('utter_wrong_pizzatype', tracker)
                    # validation failed, set slot to None
                    slot_values[slot] = None
                    
            elif slot == 'ask_toppings':
                if isinstance(value, str):
                    if 'yes' in value:
                        # convert "out..." to True
                        slot_values[slot] = True
                    elif 'no' in value:
                        # convert "in..." to False
                        slot_values[slot] = False
                    else:
                        dispatcher.utter_template('utter_wrong_toppings1',
                                                  tracker)
                        # validation failed, set slot to None
                        slot_values[slot] = None
                    
            elif slot == 'toppings':
                if value.lower() not in self.toppings_db():
                    dispatcher.utter_template('utter_wrong_toppings2', tracker)
                    # validation failed, set slot to None
                    slot_values[slot] = None

            elif slot == 'num_pizza':
                if not self.is_int(value) or int(value) <= 0:
                    dispatcher.utter_template('utter_wrong_num_pizza',
                                              tracker)
                    # validation failed, set slot to None
                    slot_values[slot] = None

           

        # validation succeed, set the slots values to the extracted values
        return [SlotSet(slot, value) for slot, value in slot_values.items()]

    def submit(self,
               dispatcher: CollectingDispatcher,
               tracker: Tracker,
               domain: Dict[Text, Any]) -> List[Dict]:
        # Define what the form has to do
           # after all required slots are filled

        # utter submit template
        dispatcher.utter_template('utter_affirm', tracker)
        return []

I have the same problem, have you solved it?