如何摆脱_BaseValue

Question

I'm using my own subclasses of ndb properties so I can add my own properties to them. When I retrieve data stored in the ndb, I often (not always) retrieve the data in a _BaseValue wrapper. How can I avoid the returning of _BaseValues?
Currently when I want to use the data I have to pass it to a function to get the b_val first.

Request arguments

INFO     2013-02-01 08:15:05,834 debug.py:24] discount_application          
INFO     2013-02-01 08:15:05,835 debug.py:24] url_name                      10
INFO     2013-02-01 08:15:05,835 debug.py:24] name                          10%
INFO     2013-02-01 08:15:05,835 debug.py:24] discount.amount               10
INFO     2013-02-01 08:15:05,835 debug.py:24] discount_type                 discount
INFO     2013-02-01 08:15:05,836 debug.py:24] free_text_discount            
INFO     2013-02-01 08:15:05,836 debug.py:24] discount.currency             euro

Data received from datastore using printed using custom function

created                       _BaseValue(datetime.datetime(2013, 1, 31, 10, 41, 6, 757020))
updated                       _BaseValue(datetime.datetime(2013, 2, 1, 8, 13, 34, 924218))
name                          _BaseValue('10%')
active                        _BaseValue(True)
name_lower                    _BaseValue('10%')
url_name                      _BaseValue('10_')
discount_type                 _BaseValue('free_text_discount')
discount                      _BaseValue(Discount(amount=0, currency=u'euro'))
free_text_discount            _BaseValue('Krijg nu 10% korting')
discount_application          _BaseValue(' ')

Data after parsing the request arguments

created                       2013-01-31 10:41:06.757020
updated                       2013-02-01 08:13:34.924218
name                          u'10%'
active                        True
name_lower                    u'10%'
url_name                      u'10_'
discount_type                 u'discount'
discount                      Discount(amount=1000, currency=u'euro')
free_text_discount            u''
discount_application          u' '

As far as I can tell the way the data is stored the way I want or not randomly. Data after receiving the same instance after putting is shown below. Also the data after putting is shown as discount.discount.amount and discount.discount.currency instead of just discount.amount and discount.currency

created                       _BaseValue(datetime.datetime(2013, 1, 16, 14, 29, 52, 457230))
updated                       _BaseValue(datetime.datetime(2013, 2, 1, 8, 14, 29, 329138))
name                          _BaseValue('20%')
active                        _BaseValue(True)
name_lower                    _BaseValue('20%')
url_name                      u'20_'
discount_type                 _BaseValue('discount')
discount                      _BaseValue(Discount(discount=Expando(amount=2000L, currency='percent')))
free_text_discount            _BaseValue(' ')
discount_application          _BaseValue('')

Action looks like this

# BaseModel has some default properties and inherits from CleanModel
class Action(BaseModel):
    _verbose_name = _("Action")
    max_create_gid = gid.ADMIN
    max_list_gid = gid.ADMIN
    max_delete_gid = gid.ADMIN

    # And some additional irrelevant properties
    # properties is a module containing custom properties,
    # which have some additional properties and functions
    discount = properties.StructuredProperty(Discount,
            html_input_type="small_structure",
            verbose_name=_("Discount"),
            help_message=_("Set a minimum discount of 10%% or € 1,00"),
            max_edit_gid=gid.ADMIN)

    def validate(self, original=None):
        return {}

And discount looks like this

# CleanModel has some irrelevant functions and inherits from ndb.Model
class Discount(common_models.CleanModel):
    amount = EuroMoney.amount.update(
            verbose_name=_("Discount"))
    currency = EuroMoney.currency.update(
            choice_dict=cp_dict(EuroMoney.currency._choice_dict,
                                            updates={CURRENCY_PERCENT: "%%"}),
            max_edit_gid=gid.ADMIN)

Answer 1

_values should never be used. getattr should be used instead.
An example for looping through properties of a Model:

entity = Model(**kwargs)
for name in entity._properties:
    val = getattr(entity, name)

Answer 2

Don't know if this was the case here, but I had the same problem because I was making local copies of entity properties, editing them, then putting them back in the entity (example below):

# I had wanted to store a list of strings, so I made this class
# (it was intended to store things like ["a", "b", "c"], etc.
class lists(ndb.Model):
        thisList = ndb.StringProperty(repeated=True)

def lets_go():
    with ndbclient.context():
        # Get the entity I want
        entity = ndb.Key(lists, "id").get()
        # Put it's existing data into a variable called 'local_list'
        local_list = entity.thisList
        # Append data to that variable
        local_list.append("d")
        # Assign the updated list back to the entity property
        entity.thisList = local_list 

This will give you a list like this: ["_BaseValue('a')", "_BaseValue('b')"...] instead of ["a", "b"...], which is the problem.

That actually used to work in the old version of Google Cloud Datastore (in about 2018) if I remember correctly. However, it now gives the kind of '_BaseValue' problem mentioned in the question here. This is the way I solved the problem--I edited the ndb entity directly, without making a local copy of the list:

def lets_go():
    with ndbclient.context():
        # Get the entity I want
        entity = ndb.Key(lists, "id").get()
        # And append data to it directly
        entity.localList.append("d")
        

This will put an actual list (like ["a", "b"...]) into the entity.