We Keep Coding

Python Class Function not defined

I'm creating a class with function within,
but i keep getting error "name 'direct_report' is not defined"
Basically im tring to make an organization chart, creating a list using the direct_report function to add people under each position
class employee:
def __init__(self, name , title, salary):
self.name = name
self.title = title
self.salary = salary
self.direct_reports_list = direct_report()
def __str__(self):
#otheremp_list = []
print(self.title,'-', self.name)
print('Direct Reports:')
for emp in self.direct_reports_list:
print(emp.title,'-', emp.name)
# otheremp_list.append(emp.direct_reports_list)
#print('other employees:')
#for emp in otheremp_list:
# print(emp.title,'-', emp.name)
# otheremp_list.append(emp.direct_reports_list)
def direct_report(self,value):
print(value)
direct_reports_list = []
direct_reports_list.append(value)
print(direct_reports_list)
return direct_reports_list
ceo = employee("Elon Musk", "CEO",1000000)
devdir = employee("Jeff Bezos","Development Director",500000)
devassoc1 = employee("Beyonce Knowles","Development Associate", 50000)
devassoc2 = employee("Taylor Swift","Development Associate", 50000)
ceo.direct_report(devdir)
ceo.direct_report(devdir2)
devdir.direct_report(devassoc1)
devdir.direct_report(devassoc2)
print(ceo)
The # is my further plan to print the full organization chart, but currently im still stuck at the "direct report" parts

You need to add one indentation level for the classes methods like that:
class employee:
def __init__(self, name , title, salary):
self.name = name
self.title = title
self.salary = salary
self.direct_reports_list = direct_report()
def __str__(self):
#otheremp_list = []
print(self.title,'-', self.name)
print('Direct Reports:')
for emp in self.direct_reports_list:
print(emp.title,'-', emp.name)
# otheremp_list.append(emp.direct_reports_list)
#print('other employees:')
#for emp in otheremp_list:
# print(emp.title,'-', emp.name)
# otheremp_list.append(emp.direct_reports_list)
def direct_report(self,value):
print(value)
direct_reports_list = []
direct_reports_list.append(value)
print(direct_reports_list)
return direct_reports_list
ceo = employee("Elon Musk", "CEO",1000000)
devdir = employee("Jeff Bezos","Development Director",500000)
devassoc1 = employee("Beyonce Knowles","Development Associate", 50000)
devassoc2 = employee("Taylor Swift","Development Associate", 50000)
ceo.direct_report(devdir)
ceo.direct_report(devdir2)
devdir.direct_report(devassoc1)
devdir.direct_report(devassoc2)
print(ceo)

Call the function in this way.
class employee:
def __init__(self, name , title, salary):
self.name = name
self.title = title
self.salary = salary
self.direct_reports_list = self.direct_report()

try self.direct_report() instead as you are calling a method within the class

Try this code.
class employee:
def __init__(self, name , title, salary):
self.name = name
self.title = title
self.salary = salary
self.direct_reports_list = []
def __str__(self):
#otheremp_list = []
print(self.title,'-', self.name)
print('Direct Reports:')
for emp in self.direct_reports_list:
print(emp.title,'-', emp.name)
# otheremp_list.append(emp.direct_reports_list)
#print('other employees:')
#for emp in otheremp_list:
# print(emp.title,'-', emp.name)
# otheremp_list.append(emp.direct_reports_list)
return "Done"
def direct_report(self,value):
self.direct_reports_list.append(value)
ceo = employee("Elon Musk", "CEO",1000000)
devdir = employee("Jeff Bezos","Development Director",500000)
devassoc1 = employee("Beyonce Knowles","Development Associate", 50000)
devassoc2 = employee("Taylor Swift","Development Associate", 50000)
ceo.direct_report(devdir)
devdir.direct_report(devassoc1)
devdir.direct_report(devassoc2)
print(ceo)
print(devdir)
print(devassoc1)
print(devassoc2)

Python Composite Class JSON Serialization

I have what I would term a composite class
Whereby the class LegoSet is constructed from an instantiation of the class LegoSetVariant and inturn the class LegoSetVariant is constructed from a number of different class instantiations.
This is fine and I can successfully initialize the class. However, I then want to serialize the class object into JSON. This is proving a bit tricky as the composite classes are erroring as non-serializable.
class LegoSet:
def __init__(
self,
typename,
id,
productCode,
name,
slug,
primaryImage,
baseImgUrl,
overrideUrl,
variant,
):
self.__typename = typename
self.__id = id
self.__productCode = productCode
self.__name = name
self.__slug = slug
self.__primaryImage = primaryImage
self.__baseImgUrl = baseImgUrl
self.__overrideUrl = overrideUrl
self.__variant = variant
class LegoSetVariant:
def __init__(self, id, sku, salePercentage, attributes, price, listPrice):
self.__id = id
self.__sku = sku
self.__salePercentage = salePercentage
self.__atributes = attributes
self.__price = price
self.__listPrice = listPrice
class LegoSetVariantAttributes:
def __init__(
self,
rating,
maxOrderQuantity,
availabilityStatus,
availabilityText,
vipAvailabilityStatus,
vipAvailabilityText,
canAddToBag,
canAddToWishlist,
vipCanAddToBag,
onSale,
isNew,
featuredFlags,
):
self.__rating = rating
self.__maxOrderQuantity = maxOrderQuantity
self.__availabilityStatus = availabilityStatus
self.__availabilityText = availabilityText
self.__vipAvailabilityStatus = vipAvailabilityStatus
self.__vipAvailabilityText = vipAvailabilityText
self.__canAddToBag = canAddToBag
self.__canAddToWishlist = canAddToWishlist
self.__vipCanAddToBag = vipCanAddToBag
self.__onSale = onSale
self.__isNew = isNew
self.__featuredFlags = featuredFlags
class LegoSetVariantAttributesFeaturedFlags:
def __init__(self, key, label):
self.__key = key
self.__label = label
class LegoSetVariantPrice:
def __init__(self, formattedAmount, centAmount, currencyCode, formattedValue):
self.__formattedAmount = formattedAmount
self.__centAmount = centAmount
self.__currencyCode = currencyCode
self.__formattedValue = formattedValue
class LegoSetVariantListPrice:
def __init__(self, formattedAmount, centAmount):
self.__formattedAmount = formattedAmount
self.__centAmount = centAmount

Try this:
def unpack_into_dict(object):
res = {}
for key, val in object.__dict__.items():
if hasattr(val, '__dict__'):
res[key] = unpack_into_dict(val)
else:
res[key] = val
return res

How to filter Django object to get top X number of objects with highest property value

So I have a class called Hero with 150 objects. Each object has a property Winrate. I want to get the top 12 heros based on winrate.
class Hero(models.Model):
hero_name = models.CharField(max_length=20, default = 'Dota 2 Hero')
hero_id = models.IntegerField()
def __str__(self):
return str(self.hero_id)
def get_winrate(self):
wins = len(Match.objects.filter(heros_won = Hero.objects.get(hero_id = self.hero_id)))
losses = len(Match.objects.filter(heros_lost = Hero.objects.get(hero_id = self.hero_id)))
if wins + losses != 0:
return round((wins / (wins + losses)),2)
else:
return 0
winrate = property(get_winrate)
I tried alot of filters but couldn't get it to work.

I would make winrate an attribute of your Hero class as following.
class Hero(models.Model):
hero_name = models.CharField(max_length=20, default = 'Dota 2 Hero')
hero_id = models.IntegerField()
winrate = models.IntegerField()
def _get_winrate(self):
wins = len(Match.objects.filter(heros_won = Hero.objects.get(hero_id = self.hero_id)))
losses = len(Match.objects.filter(heros_lost = Hero.objects.get(hero_id = self.hero_id)))
if wins + losses != 0:
return round((wins / (wins + losses)),2)
else:
return 0
def save(*args, **kwargs):
self.winrate = self._getwinrate()
return super().save(*args, **kwargs)
Then you'll be able to order your request.
super_heroes = Hero.objects.order_by('-winrate')[:12]
EDIT: you shouldn't use len() on a queryset but count() like this:
wins = Match.objects.filter(heros_won=self.pk).count()
Why don't you use the natural primary key instead of this hero_id?

Django: cannot get an Model instance from ForwardManyToOneDescriptor (ForeignKey)

I have the following code in accounts/signals/__init__.py:
from django.db.models.signals import post_save
from django.dispatch import receiver
from orders.models import Order
from accounts.models import Balance
#receiver(post_save, sender=Order)
def update_referral_balance(sender, **kwargs):
if len(sender.user.referrals_set.all()):
# TODO: Add referralTransaction
new_referral_revenue = sender.user.referrals_set.get().revenue
revenue_from_trade = \
new_referral_revenue - sender.old_referral_revenue
balance, created = \
Balance.objects.get(user=sender.user, currency=sender.currency)
balance.balance += revenue_from_trade
balance.save()
Now, when running tests I am getting the following
error:======================================================================
ERROR: test_orders_with_approved_payments (payments.tests.test_views.PaymentReleaseTestCase)
----------------------------------------------------------------------
Traceback (most recent call last):
File "/pipeline/source/payments/tests/test_views.py", line 75, in setUp
self.order.save()
File "/pipeline/source/orders/models.py", line 63, in save
super(Order, self).save(*args, **kwargs)
File "/usr/local/lib/python3.5/site-packages/safedelete/models.py", line 64, in save
super(Model, self).save(**kwargs)
File "/usr/local/lib/python3.5/site-packages/django/db/models/base.py", line 708, in save
force_update=force_update, update_fields=update_fields)
File "/usr/local/lib/python3.5/site-packages/django/db/models/base.py", line 745, in save_base
update_fields=update_fields, raw=raw, using=using)
File "/usr/local/lib/python3.5/site-packages/django/dispatch/dispatcher.py", line 192, in send
response = receiver(signal=self, sender=sender, **named)
File "/pipeline/source/accounts/signals/__init__.py", line 9, in update_referral_balance
if len(sender.user.referral_set.all()):
AttributeError: 'ForwardManyToOneDescriptor' object has no attribute 'referral_set'
And indeed, when running through it in debugger, I see that the sender.user attribute is something of instance ForwardManyToOneDescriptor:
ipdb> pprint(sender.__dict__['user'].__dict__)
{'cache_name': '_user_cache',
'field': <django.db.models.fields.related.ForeignKey: user>}
What am I doing wrong?
EDIT: My Order Model:
class Order(TimeStampedModel, SoftDeletableModel, UniqueFieldMixin):
USD = "USD"
RUB = "RUB"
EUR = "EUR"
BUY = 1
SELL = 0
TYPES = (
(SELL, 'SELL'),
(BUY, 'BUY'),
)
# Todo: inherit from BTC base?, move lengths to settings?
order_type = models.IntegerField(choices=TYPES, default=BUY)
amount_cash = models.DecimalField(max_digits=12, decimal_places=2)
amount_btc = models.DecimalField(max_digits=18, decimal_places=8)
currency = models.ForeignKey(Currency)
payment_window = models.IntegerField(default=settings.PAYMENT_WINDOW)
user = models.ForeignKey(User, related_name='orders')
is_paid = models.BooleanField(default=False)
is_released = models.BooleanField(default=False)
is_completed = models.BooleanField(default=False)
is_failed = models.BooleanField(default=False)
unique_reference = models.CharField(
max_length=settings.UNIQUE_REFERENCE_LENGTH, unique=True)
admin_comment = models.CharField(max_length=200)
payment_preference = models.ForeignKey('payments.PaymentPreference',
default=None,
null=True)
class Meta:
ordering = ['-created_on']
def save(self, *args, **kwargs):
self.unique_reference = \
self.gen_unique_value(
lambda x: get_random_string(x),
lambda x: Order.objects.filter(unique_reference=x).count(),
settings.UNIQUE_REFERENCE_LENGTH
)
self.convert_coin_to_cash()
if 'is_completed' in kwargs and\
kwargs['is_completed'] and\
not self.is_completed:
self.old_referral_revenue = \
self.user.referral_set.get().revenue
super(Order, self).save(*args, **kwargs)
def convert_coin_to_cash(self):
self.amount_btc = Decimal(self.amount_btc)
queryset = Price.objects.filter().order_by('-id')[:2]
price_sell = [price for price in queryset if price.type == Price.SELL]
price_buy = [price for price in queryset if price.type == Price.BUY]
# Below calculation affect real money the client pays
assert all([len(price_sell),
price_sell[0].price_usd,
price_buy[0].price_rub,
price_buy[0].price_eur])
assert all([len(price_buy),
price_buy[0].price_usd,
price_buy[0].price_rub,
price_buy[0].price_eur])
# TODO: Make this logic more generic,
# TODO: migrate to using currency through payment_preference
# SELL
self.amount_cash = Decimal(self.amount_btc)
if self.order_type == Order.SELL and self.currency.code == Order.USD:
self.amount_cash *= price_buy[0].price_usd
elif self.order_type == Order.SELL and self.currency.code == Order.RUB:
self.amount_cash *= price_buy[0].price_rub
elif self.order_type == Order.SELL and self.currency.code == Order.EUR:
self.amount_cash *= price_buy[0].price_eur
# BUY
if self.order_type == Order.BUY and self.currency.code == Order.USD:
self.amount_cash *= price_sell[0].price_usd
elif self.order_type == Order.BUY and self.currency.code == Order.RUB:
self.amount_cash *= price_sell[0].price_rub
elif self.order_type == Order.BUY and self.currency.code == Order.EUR:
self.amount_cash *= price_sell[0].price_eur
self.amount_cash = money_format(self.amount_cash)
#property
def is_buy(self):
return self.order_type
#property
def payment_deadline(self):
"""returns datetime of payment_deadline (creation + payment_window)"""
# TODO: Use this for pay until message on 'order success' screen
return self.created_on + timedelta(minutes=self.payment_window)
#property
def expired(self):
"""Is expired if payment_deadline is exceeded and it's not paid yet"""
# TODO: validate this business rule
# TODO: Refactor, it is unreasonable to have different standards of
# time in the DB
return (timezone.now() > self.payment_deadline) and\
(not self.is_paid) and not self.is_released
#property
def payment_status_frozen(self):
"""return a boolean indicating if order can be updated
Order is frozen if it is expired or has been paid
"""
# TODO: validate this business rule
return self.expired or \
(self.is_paid and
self.payment_set.last() and
self.payment_set.last().
payment_preference.
payment_method.is_internal)
#property
def withdrawal_address_frozen(self):
"""return bool whether the withdraw address can
be changed"""
return self.is_released
#property
def has_withdraw_address(self):
"""return a boolean indicating if order has a withdraw adrress defined
"""
# TODO: Validate this business rule
return len(self.address_set.all()) > 0
#property
def withdraw_address(self):
addr = None
if self.has_withdraw_address:
addr = self.transaction_set.first().address_to.address
return addr
def __str__(self):
return "{} {} {} BTC {} {}".format(self.user.username or
self.user.profile.phone,
self.order_type,
self.amount_btc,
self.amount_cash,
self.currency)

The sender argument is the model class the signal has connected to. As you can see from the signals docs, in post_save the instance is passed in a separate argument unsurprisingly called instance.
You should write your handler like this:
#receiver(post_save, sender=Order)
def update_referral_balance(sender, instance, **kwargs):
if len(instance.user.referrals_set.all()):
etc, changing sender to instance throughout.

How to render DateField with 3 selects

I'm looking for the simplest and cleanest way to render a basic DateField with 3 select.
<select>day</select><select>month</select><select>year</select>
(and if possible use "format" to choose how to display the final render)

You can take advantage of the fact that DateField will handle multiple-valued inputs and join them together with a space, so you can avoid a secondary form and instead just provide a sequence of inputs:
from wtforms.widgets.core import Select, HTMLString, html_params
class SelectDateWidget(object):
FORMAT_CHOICES = {
'%d': [(x, str(x)) for x in range(1, 32)],
'%m': [(x, str(x)) for x in range(1, 13)],
'%y': [(x, str(x)) for x in range(1950, 2014)],
}
def __call__(self, field, **kwargs):
field_id = kwargs.pop('id', field.id)
html = []
for format in field.format.split():
choices = self.FORMAT_CHOICES[format]
id_suffix = format.replace('%', '-')
params = dict(kwargs, name=field.name, id=field_id + id_suffix)
html.append('<select %s>' % html_params(params))
if field.data:
current_value = int(field.data.strftime(format))
else:
current_value = None
for value, label in choices:
selected = (value == current_value)
html.append(Select.render_option(value, label, selected))
html.append('</select>')
return HTMLString(''.join(html))
# Usage
class MyForm(Form):
american_date = DateField(format='%m %d %y', widget=SelectDateWidget())
european_date = DateField(format='%d %m %y', widget=SelectDateWidget())

Final widget: (Support multiple format not only spaces)
class SelectDateWidget(object):
FORMAT_CHOICES = {
'%d': [(x, str(x)) for x in range(1, 32)],
'%m': [(x, str(x)) for x in range(1, 13)]
}
FORMAT_CLASSES = {
'%d': 'select_date_day',
'%m': 'select_date_month',
'%Y': 'select_date_year'
}
def __init__(self, years=range(1930, 2014)):
super(SelectDateWidget, self).__init__()
self.FORMAT_CHOICES['%Y'] = [(x, str(x)) for x in years]
def __call__(self, field, **kwargs):
field_id = kwargs.pop('id', field.id)
html = []
allowed_format = ['%d', '%m', '%Y']
for format in field.format.split():
if (format in allowed_format):
choices = self.FORMAT_CHOICES[format]
id_suffix = format.replace('%', '-')
id_current = field_id + id_suffix
kwargs['class'] = self.FORMAT_CLASSES[format]
try: del kwargs['placeholder']
except: pass
html.append('<select %s>' % html_params(name=field.name, id=id_current, **kwargs))
if field.data:
current_value = int(field.data.strftime(format))
else:
current_value = None
for value, label in choices:
selected = (value == current_value)
html.append(Select.render_option(value, label, selected))
html.append('</select>')
else:
html.append(format)
html.append('<input type="hidden" value="'+format+'" %s></input>' % html_params(name=field.name, id=id_current, **kwargs))
html.append(' ')
return HTMLString(''.join(html))

I used a custom widget and it's working but it's not perfect yet. Other ideas to do this?
class SelectDateWidget(object):
class SelectDateForm(Form):
days = [(x,x) for x in range(1,32)]
months = [(x,x) for x in range(1,13)]
years = [(x,x) for x in range(1950,2014)]
days_select = SelectField(choices=days)
month_select = SelectField(choices=months)
year_select = SelectField(choices=years)
def __call__(self, field, **kwargs):
kwargs.setdefault('id', field.id)
date_form = self.SelectDateForm(prefix=field.name)
days_html = date_form.days_select(class_="input-mini").__html__()
month_html = date_form.month_select(class_="input-mini").__html__()
year_html = date_form.year_select(class_="input-small").__html__()
widget_html = field.format
widget_html = widget_html.replace('%d', days_html)
widget_html = widget_html.replace('%m', month_html)
widget_html = widget_html.replace('%Y', year_html)
return HTMLString(widget_html)
class SelectDateField(DateField):
widget = SelectDateWidget()
def __init__(self, label=None, validators=None, **kwargs):
super(SelectDateField, self).__init__(label, validators, **kwargs)
def pre_validate(self, extra):
form = SelectDateWidget.SelectDateForm(prefix=self.name)
try:
date = datetime.datetime.strptime(form.days_select.data+'-'+form.month_select.data+'-'+form.year_select.data, '%d-%m-%Y')
self.data = date
except:
raise StopValidation(gettext(u'Invalid date.'))
class MyForm(Form):
date = SelectDateField(u'Date', validators=[Required(message=_(u'This field is required.'))], format='%d / %m / %Y')