def test_resize_antialiasing():
"""
Test that the Resize processor antialiases.
The Resize processor is used by all of the Resize* variants, so this should
cover all of resize processors. Basically, this is to test that it converts
to RGBA mode before resizing.
Related: jdriscoll/django-imagekit#192
"""
# Create a palette image and draw a circle into it.
img = Image.new('P', (500, 500), 1)
img.putpalette([
0,
0,
0,
255,
255,
255,
0,
0,
255,
])
d = ImageDraw.ImageDraw(img)
d.ellipse((100, 100, 400, 400), fill=2)
# Resize the image using the Resize processor
img = Resize(100, 100).process(img)
# Count the number of colors
color_count = len(list(filter(None, img.histogram())))
assert_true(color_count > 2)
def test_resize_antialiasing():
"""
Test that the Resize processor antialiases.
The Resize processor is used by all of the Resize* variants, so this should
cover all of resize processors. Basically, this is to test that it converts
to RGBA mode before resizing.
Related: jdriscoll/django-imagekit#192
"""
# Create a palette image and draw a circle into it.
img = Image.new('P', (500, 500), 1)
img.putpalette([
0, 0, 0,
255, 255, 255,
0, 0, 255,
])
d = ImageDraw.ImageDraw(img)
d.ellipse((100, 100, 400, 400), fill=2)
# Resize the image using the Resize processor
img = Resize(100, 100).process(img)
# Count the number of colors
color_count = len(list(filter(None, img.histogram())))
assert_true(color_count > 2)
def process(self, img): original_width, original_height = img.size ratio = min(float(self.width) / original_width, float(self.height) / original_height) new_width, new_height = (int(round(original_width * ratio)), int(round(original_height * ratio))) img = Resize(new_width, new_height, upscale=self.upscale).process(img) return img
class Contract(models.Model): # Known contract addresses by the service
objects = ContractManager.from_queryset(ContractQuerySet)()
address = EthereumAddressV2Field(primary_key=True)
name = models.CharField(max_length=200, blank=True, default="")
display_name = models.CharField(max_length=200, blank=True, default="")
logo = ProcessedImageField(
blank=True,
default="",
upload_to=get_contract_logo_path,
storage=get_file_storage,
format="PNG",
processors=[Resize(256, 256, upscale=False)],
)
contract_abi = models.ForeignKey(
ContractAbi,
on_delete=models.SET_NULL,
null=True,
default=None,
blank=True,
related_name="contracts",
)
# Trusted for doing delegate calls, as it's very dangerous doing delegate calls to other contracts
trusted_for_delegate_call = models.BooleanField(default=False)
def __str__(self):
has_abi = self.contract_abi_id is not None
logo = " with logo" if self.logo else " without logo"
return f"Contract {self.address} - {self.name} - with abi {has_abi}{logo}"
def sync_abi_from_api(self,
network: Optional[EthereumNetwork] = None) -> bool:
"""
Sync ABI from Sourcify, then from Etherscan and blockscout if available
:param network: Can be provided to save requests to the node
:return: True if updated, False otherwise
"""
ethereum_client = EthereumClientProvider()
network = network or ethereum_client.get_network()
sourcify = Sourcify(network)
try:
etherscan_client = EtherscanClient(
network, api_key=settings.ETHERSCAN_API_KEY)
except EtherscanClientConfigurationProblem:
logger.info(
"Etherscan client is not available for current network %s",
network)
etherscan_client = None
try:
blockscout_client = BlockscoutClient(network)
except BlockScoutConfigurationProblem:
logger.info(
"Blockscout client is not available for current network %s",
network)
blockscout_client = None
contract_abi: Optional[ContractAbi] = None
for client in (sourcify, etherscan_client, blockscout_client):
if not client:
continue
try:
contract_metadata = client.get_contract_metadata(self.address)
if contract_metadata:
name = contract_metadata.name or ""
contract_abi, _ = ContractAbi.objects.get_or_create(
abi=contract_metadata.abi,
defaults={"description": name})
if name:
if not contract_abi.description:
contract_abi.description = name
contract_abi.save(update_fields=["description"])
if not self.name:
self.name = name
self.contract_abi = contract_abi
self.save(update_fields=["name", "contract_abi"])
break
except IOError:
pass
return bool(contract_abi)
class Token(models.Model):
objects = TokenManager.from_queryset(TokenQuerySet)()
pool_tokens = PoolTokenManager()
address = EthereumAddressV2Field(primary_key=True)
name = models.CharField(max_length=60)
symbol = models.CharField(max_length=60)
decimals = models.PositiveSmallIntegerField(
db_index=True,
null=True,
blank=True,
help_text=
"Number of decimals. For ERC721 tokens decimals must be `None`",
)
logo = ProcessedImageField(
blank=True,
default="",
upload_to=get_token_logo_path,
storage=get_file_storage,
format="PNG",
processors=[Resize(256, 256, upscale=False)],
)
events_bugged = models.BooleanField(
default=False,
help_text=
"Set `True` if token does not send `Transfer` event sometimes (e.g. WETH on minting)",
)
spam = models.BooleanField(
default=False, help_text="Spam and trusted cannot be both True")
trusted = models.BooleanField(
default=False, help_text="Spam and trusted cannot be both True")
copy_price = EthereumAddressV2Field(
null=True,
blank=True,
help_text="If provided, copy the price from the token")
class Meta:
indexes = [
models.Index(name="token_trusted_idx",
fields=["trusted"],
condition=Q(trusted=True)),
models.Index(
name="token_events_bugged_idx",
fields=["events_bugged"],
condition=Q(events_bugged=True),
),
]
def __str__(self):
spam_text = "SPAM " if self.spam else ""
if self.decimals is None:
return f"{spam_text}ERC721 - {self.name} - {self.address}"
else:
return f"{spam_text}ERC20 - {self.name} - {self.address}"
def clean(self):
if self.trusted and self.spam:
raise ValidationError("Spam and trusted cannot be both `True`")
def is_erc20(self):
return self.decimals is not None
def is_erc721(self):
return not self.is_erc20()
def set_trusted(self) -> None:
self.trusted = True
return self.save(update_fields=["trusted"])
def set_spam(self) -> None:
self.spam = True
return self.save(update_fields=["spam"])
def get_full_logo_uri(self) -> str:
if self.logo:
return self.logo.url
elif settings.AWS_S3_PUBLIC_URL:
return urljoin(
settings.AWS_S3_PUBLIC_URL,
get_token_logo_path(
self, self.address + settings.TOKENS_LOGO_EXTENSION),
)
else:
# Old behaviour
return urljoin(
settings.TOKENS_LOGO_BASE_URI,
get_token_logo_path(
self, self.address + settings.TOKENS_LOGO_EXTENSION),
)
def get_price_address(self) -> ChecksumAddress:
"""
:return: Address to use to retrieve the token price
"""
return self.copy_price or self.address
def get(self, request, req_img_path):
#TODO: catch type conversion errors
print "Debug log: image render view"
# store request data
req_img_w = int(request.GET.get('w', '-1'))
req_img_h = int(request.GET.get('h', '-1'))
req_img_priority = request.GET.get('priority', 'w')
req_img_border_pc = request.GET.get('pad', None)
print "Debug log: image size requested : %sx%s, Image Priority : %s,\
Image border Color %s, req_img_path : %s" % \
(req_img_w, req_img_h, req_img_priority, req_img_border_pc, req_img_path)
#req_directory = os.path.join(settings.BASE_DIR, "static", "images")
#req_img_name = os.path.basename(req_img_path)
req_directory = os.path.join(settings.MEDIA_ROOT, os.path.dirname(req_img_path))
req_img_name = os.path.basename(req_img_path)
# create img path dict
img_path_dict = create_img_paths(req_directory, req_img_name)
#choose image file path
resp_img_path = get_image_path(img_path_dict, req_img_priority)
#pixel calculation
img_path_dict['c_img'] = os.path.join(req_directory, 'resized', \
os.path.splitext(req_img_name)[0]+'_%sx%s' % (req_img_w, req_img_h)+ os.path.splitext(req_img_name)[1])
if os.path.exists(img_path_dict['c_img']):
resp_img_path = img_path_dict['c_img']
resize_flag = False
else:
#resizing required
im = Image.open(resp_img_path)
w,h = im.size
resize_flag, new_w, new_h = pixel_calculation(req_img_w, req_img_h, w, h, img_path_dict['c_img'])
print "Debug Log : Response Image path: %s" % resp_img_path
if resize_flag:
print "Debug Log : Resizing required, new_w X new_h %sx%s" % (new_w, new_h)
img = Image.open(resp_img_path)
processor = Resize(new_w, new_h)
m_img = processor.process(img)
#update path to render
resp_img_path = img_path_dict['c_img']
if not os.path.exists(os.path.join(req_directory, "resized")):
os.makedirs(os.path.join(req_directory, "resized"))
if req_img_border_pc is not None:
border_w = (req_img_w - new_w)/2
border_h = (req_img_h - new_h)/2
print "Debug Log: border_w X border_h %sx%s" % (border_w, border_h)
ImageOps.expand(m_img, border=(border_w, border_h), fill=req_img_border_pc).save(resp_img_path, quality=95)
else:
m_img.save(resp_img_path, quality=95)
relative_path = os.path.relpath(resp_img_path, settings.MEDIA_ROOT)
#context_dict = {'relative_path':relative_path}
#return render_to_response('images/image_render.html', context_dict, RequestContext(request))
print "Debug Log: relative path: %s" % relative_path
img = Image.open(resp_img_path)
response = HttpResponse(content_type="image/jpeg")
img.save(response, "jpeg")
return response
class Tool(models.Model):
class Meta:
app_label = 'app'
def toolPictureName(instance, filename):
ext = filename.split('.')[-1]
return 'toolpics/{}.{}'.format(instance.name, ext)
name = models.CharField(max_length=25)
picture = ProcessedImageField(processors=[Resize(500, 500)],
format='JPEG',
upload_to=toolPictureName)
description = models.TextField(max_length=500)
status = models.CharField(max_length=1, choices=app.constants.TOOL_STATUS)
category = models.CharField(max_length=2,
choices=app.constants.TOOL_CATEGORY)
location = models.CharField(max_length=1,
choices=app.constants.TOOL_LOCATION,
blank=False,
default='H')
models.CharField()
shed = models.ForeignKey(Shed, null=True, on_delete=models.SET_NULL)
owner = models.ForeignKey(settings.AUTH_USER_MODEL)
pickupArrangement = models.TextField(max_length=500)
def __str__(self):
return self.name
def get_all_reservations(self):
reservations = self.reservation_set.all()
return reservations
# returns a query of reservations on the tool based on the reservation_status arg (A, O, AC, R, C, etc.)
def get_reservations(self, reservation_status):
reservations = self.reservation_set.filter(status=reservation_status)
return reservations
# Checks if tool has unresolved future reservations that prevent it from moving
# Returns true if no unresolved future reservations on it, false otherwise
def is_ready_to_move(self):
if self.location == "S":
return False
# Keeps a count of all reservations that might be interfering with moving a tool.
blockingReservations = 0
# Checks tool for any active reservations
activeReservations = self.get_reservations('AC')
blockingReservations = blockingReservations + len(activeReservations)
# Checks tool for approved future reservations
approvedReservations = self.get_reservations('A')
blockingReservations = blockingReservations + len(approvedReservations)
# Add additional reservations that might block tool from moving here
user = self.owner
ownReservations = app.models.Reservation.objects.filter(user=user)
ownReservations = ownReservations.filter(status="AC").filter(
status="A")
blockingReservations = blockingReservations + len(ownReservations)
# Check the sum of the lengths of the reservation lists described above.
# If sum is zero (no blocking reservations), return ready_to_move = True. Else, return ready_to_move = False
if blockingReservations == 0:
return True
else:
return False
def get_next_available_date(self):
reservations = self.reservation_set.exclude(status='C').exclude(status='CL').exclude(status='O'). \
exclude(status='P').exclude(status='R')
blackoutdates = self.blackoutdate_set.all()
availableDate = datetime.date.today()
addOneDay = datetime.timedelta(days=1)
setOfDates = set()
for res in reservations:
setOfDates = setOfDates.union(res.get_dates_covered())
for bd in blackoutdates:
setOfDates = setOfDates.union(bd.get_dates_covered())
unavailableDates = sorted(setOfDates)
for date in unavailableDates:
while availableDate == date:
availableDate = date + addOneDay
return availableDate
def get_days_until_available(self):
today = datetime.date.today()
delta = (self.get_next_available_date() - today).days
return delta
def get_status_label_owner(self):
label = "Active"
if self.status == "D":
label = "Deactivated"
else:
reservations = self.get_all_reservations()
for reservation in reservations:
if reservation.status == "RI":
label = "Return Initiated"
elif reservation.status == "O":
label = "Overdue"
elif reservation.status == "AC":
label = "Lent Out"
return label
def get_label_type_owner(self):
type = "label-success"
if self.get_status_label_owner() == "Deactivated":
type = "label-danger"
if self.get_status_label_owner() == "Return Initiated":
type = "label-warning"
if self.get_status_label_owner() == "Overdue":
type = "label-danger"
if self.get_status_label_owner() == "Lent Out":
type = "label-warning"
return type
def get_status_label_borrower(self):
label = "Available"
daysOnRes = self.get_days_until_available()
if daysOnRes > 0:
label = self.get_next_available_date()
return label
def get_label_type_borrower(self):
type = "label-warning"
if self.get_status_label_borrower() == "Available":
type = "label-success"
return type
def get_init_return_reservation(self):
reservations = self.get_reservations('RI')
if len(reservations) > 0:
return reservations[0]
return reservations
@property
def address(self):
if self.location == 'S':
return self.shed.address
return self.owner.address