class StreamingModel(Model):
DEEZER = 'https://www.deezer.com/'
SPOTIFY = 'https://open.spotify.com/'
APPLE = 'https://music.apple.com/'
YOUTUBE = 'https://music.youtube.com/'
deezer_id = SlugField('deezer id',
max_length=512,
blank=True,
null=True,
unique=True)
itunes_id = SlugField('apple id',
max_length=512,
blank=True,
null=True,
unique=True)
play_id = SlugField('play id',
max_length=512,
blank=True,
null=True,
unique=True)
spotify_id = SlugField('spotify id',
max_length=512,
blank=True,
null=True,
unique=True)
musicstory_id = SlugField('musicstory id',
max_length=512,
blank=True,
null=True,
unique=True)
class Meta:
abstract = True
def get_deezer_url(self) -> str:
return ''
def get_itunes_url(self) -> str:
return ''
def get_play_url(self) -> str:
return ''
def get_spotify_url(self) -> str:
return ''
def get_musicstory_url(self) -> str:
return ''
class Traffic(TimeStampedModel):
title = CharField(_('Post Title'), blank=False, null=True, max_length=500)
slug = SlugField(unique=True, null=True, blank=True, max_length=600)
image = FileField(_("Upload Info"),
upload_to=blog_file_path,
null=True,
blank=True)
pub_date = DateField(_('Post Published Date'),
auto_now=False,
auto_now_add=False,
null=True,
blank=False)
draft = BooleanField(default=False)
content = RichTextUploadingField()
def __str__(self):
return self.title
class Meta:
managed = True
verbose_name = 'Traffic'
verbose_name_plural = 'Traffics'
ordering = ['title', '-created']
def get_absolute_url(self):
return f"/traffic/{self.slug}"
def get_update_url(self):
return f"{self.get_absolute_url}/update"
def get_delete_url(self):
return f"{self.get_absolute_url}/delete"
class MenuItem(BaseModel, OrderableModel, WithImageField):
slug = SlugField(max_length=300, db_index=True, blank=True, default=None)
is_long = BooleanField(default=False)
description = TextField(default=None, blank=True, null=True)
link = CharField(max_length=200, default=None, blank=True)
type = CharField(max_length=12,
choices=MenuItemType.choices,
default=MenuItemType.INTERNAL_LINK)
parent = ForeignKey('self',
on_delete=SET_NULL,
null=True,
blank=True,
related_name='children')
is_published = BooleanField(default=False)
# https://medium.com/@tnesztler/recursive-queries-as-querysets-for-parent-child-relationships-self-manytomany-in-django-671696dfe47
def get_children(self, include_self=True):
return MenuItem.objects.filter(self.get_children_filter(include_self))
def get_children_filter(self, include_self=True):
filters = Q(pk=0)
if include_self:
filters |= Q(pk=self.pk)
for item in MenuItem.objects.filter(parent=self):
if children_filter := item.get_children_filter(include_self=True):
filters |= children_filter
return filters
class Place(models.Model):
"""
Modelo para as localidades em Portugal
"""
slug = SlugField()
name = CharField(max_length=50)
county = ForeignKey(County, models.DO_NOTHING, related_name='places')
class Category(Model):
class Meta:
verbose_name = 'Category'
verbose_name_plural = 'Categories'
name = CharField(max_length=30)
image = ImageField(null=True, blank=True)
slug = SlugField(null=False, unique=True)
def __str__(self):
return self.name
@property
def imageURL(self):
if self.image:
url = self.image.url
else:
url = ''
return url
def get_absolute_url(self):
return reverse('store:category', kwargs={'slug': self.slug})
def save(self, *args, **kwargs):
if not self.slug:
self.slug = slugify(self.name)
return super().save(*args, **kwargs)
class Post(Model):
slug = SlugField(max_length=512)
title = CharField(max_length=512)
category = ForeignKey('blog.category', CASCADE, related_name='posts')
content = TextField(blank=True)
excerpt = CharField(max_length=1024)
thumbnail = ImageField(
upload_to='photos/%Y/%m/%d',
null=True,
blank=True
)
caption = CharField(max_length=512, blank=True)
image_showing = BooleanField(default=True)
created = DateTimeField()
modified = DateTimeField()
class Meta:
ordering = ['-created']
def __str__(self):
return self.title
def save(self, *args, **kwargs):
if not self.id:
self.created = timezone.now()
self.modified = timezone.now()
if not self.slug:
self.slug = unique_slugify(Post, self.title)
return super(Post, self).save(*args, **kwargs)
class TestModelFields(Model):
big_int = BigIntegerField()
yesno = BooleanField()
title = CharField(max_length=150)
csv_data = CommaSeparatedIntegerField(max_length=255)
when = DateField()
when_accurate = DateTimeField()
amount = DecimalField(max_digits=8, decimal_places=4)
email = EmailField()
upload = FileField(upload_to='test')
path = FilePathField(path=d.APP_DIR, recursive=False, match=".json$")
inaccurate = FloatField()
img = ImageField(upload_to='test')
ip = IPAddressField()
better_ip = GenericIPAddressField(protocol='both')
yesnomaybe = NullBooleanField(default=None)
posint = PositiveIntegerField()
small_posint = PositiveSmallIntegerField()
slug = SlugField()
small_int = SmallIntegerField()
content = TextField()
when_time = TimeField()
web_address = URLField()
user = ForeignKey('auth.User')
groups = ManyToManyField('auth.Group')
one_to_one = OneToOneField('auth.Permission')
class Meta:
verbose_name = 'test model fields'
verbose_name_plural = 'test model fields'
class Suggestion(TimeStampedModel):
title = CharField(_("Post Title"), blank=False, null=True, max_length=255)
email = EmailField(_("Your Email"), blank=False, null=True, max_length=255)
slug = SlugField(unique=True, null=True, blank=True, max_length=500)
pub_date = DateField(
_("Suggestion Published Date"),
auto_now=False,
auto_now_add=False,
null=True,
blank=False,
)
draft = BooleanField(default=False)
featured = BooleanField(default=False)
content = TextField()
objects = SuggestionManager()
def __str__(self):
return self.title
class Meta:
managed = True
verbose_name = "Suggestion"
verbose_name_plural = "Suggestions"
ordering = ["title", "-pub_date"]
def get_absolute_url(self):
return f"/suggestion/{self.slug}"
def get_update_url(self):
return f"{self.get_absolute_url}/update"
def get_delete_url(self):
return f"{self.get_absolute_url}/delete"
class StaticContent(Model):
title = CharField(verbose_name=_('Title'),
max_length=255,
help_text=_("Title of HTML content"),
blank=False)
slug = SlugField(verbose_name=_('Slug'),
max_length=255,
help_text=_("Slug of HTML content"),
blank=False)
body = TextField(verbose_name=_('HTML Body'),
help_text=_("Static HTML content for placement in pages"),
blank=False)
panels = [
FieldPanel('title'),
FieldPanel('slug'),
FieldPanel('body'),
]
class Meta:
verbose_name = _("Static content")
verbose_name_plural = _("Static contents")
def __str__(self): # __unicode__ on Python 2
return self.title
search_fields = [
index.SearchField('body', partial_match=True),
]
class Auctioneer(models.Model):
name = CharField(max_length=255, verbose_name='Name', unique=True)
slug = SlugField(max_length=255, unique=True, db_index=True)
motto = CharField(max_length=255, blank=True, null=True)
activated = models.BooleanField(default=False, verbose_name='Activated')
created_date = models.DateTimeField(auto_now_add=True)
modified_date = models.DateTimeField(auto_now=True)
# address = models.ForeignKey("Address", on_delete=models.CASCADE, verbose_name='Address', blank=True, null=True,
# related_name="auctioneer_address")
# user = models.ForeignKey(User, on_delete=models.CASCADE, blank=True, null=True, verbose_name='User')
# user = models.ManyToManyField(User)
# def user_display(self):
# display_list = list(self.user.all())
# return display_list
# user_display.short_description = 'Users'
def __str__(self):
return self.name
def save(self, *args, **kwargs):
self.slug = uuslug(self.name, instance=self)
super(Auctioneer, self).save(*args, **kwargs)
class Meta:
ordering = ('name', )
class Product(models.Model):
name = CharField(_("Product Name"), max_length=300)
slug = SlugField(_("Slug"), max_length=100, allow_unicode=True)
description = TextField(_("Description"), blank=True)
small_image = ImageField(_("Small Image"), upload_to="products")
price = MoneyField(max_digits=10,
decimal_places=2,
default=Money(10, "EUR"),
null=True,
default_currency="EUR")
class Meta:
verbose_name = _("Product")
verbose_name_plural = _("Products")
def __str__(self):
return "Product %s" % self.slug
def get_absolute_url(self):
"""Get url for the product's detail view.
Returns:
str: URL for product detail.
"""
return reverse("shop:product-detail", kwargs={"slug": self.slug})
class MapDisplay(Model):
"""A displayed map of the given data"""
slug = SlugField(max_length=32)
name = CharField(max_length=32)
description = CharField(max_length=128, null=True, blank=True)
data = ForeignKey(MapDataSource, related_name='maps', on_delete=CASCADE)
fill_column = CharField(
max_length=48,
default='count',
help_text="The value used to decide what color the fill should be.")
fill_max = DecimalField(
default=-1.0,
decimal_places=4,
max_digits=20,
help_text=
"The maximum value this field will be, if set to -1 the value will be automaticly the maximum value in the set."
)
fill_ranges = TextField(
max_length=255,
default='1/8,1/4,1/2,3/4',
help_text="A comma seperated list of color ranges.")
fill_colors = TextField(
max_length=255,
default='#FFFFDD,#C7E9B4,#7FCDBB,#41B6C4,#1D91C0',
help_text=
"A comma seperated list of colours which the ranges relate to.")
default_drug = ForeignKey(Drug, null=True, blank=True, on_delete=SET_NULL)
def natural_key(self):
return (self.slug, )
def __str__(self):
return self.name
def get_max(self, values):
fill_max = float(self.fill_max)
if fill_max < 0.0:
fill_max = max(values)
return fill_max
def get_ranges(self, fill_max):
ret = []
for item in self.fill_ranges.split(','):
if '/' in item:
a, b = [int(c) for c in item.split('/', 1)]
item = str(float(a) / float(b))
if '.' in item and float(item) <= 1.0:
item = float(float(fill_max) * float(item))
else:
item = int(item)
ret.append(item)
return ret
def get_colors(self):
return self.fill_colors.split(',')
def get_absolute_url(self):
return reverse('maps:data.marginalplaces', kwargs={'slug': self.slug})
class MapDisplayFilter(Model):
parent_map = ForeignKey(MapDisplay,
related_name='data_filters',
on_delete=CASCADE)
key = SlugField(max_length=32, default="")
kind = CharField(max_length=32, choices=FILTER_TYPES, default="")
column = CharField(max_length=48)
label = CharField(max_length=128)
options = TextField(
help_text="A json formatted definition of the map filter options")
def __str__(self):
return self.label
def get_options(self):
try:
return json.loads(self.options)
except Exception as err:
self.options = json.dumps({
'error': str(err),
'data': self.options,
})
self.save()
return []
class Resource(Model):
def __str__(self):
return self.slug
slug = SlugField(unique=True)
type = CharField(max_length=255)
name = CharField(max_length=255, null=True, blank=True)
class Team(Model):
link = SlugField(unique=True) # team url name
links = ManyToManyField('link.Link', null=True,
blank=True) # team social media links
name = CharField(max_length=1024, unique=True)
country = CountryField()
members = ManyToManyField(Account,
null=True,
blank=True,
related_name="teams")
logo = ProcessedImageField(upload_to=_upload_to,
processors=[ResizeToFill(525, 100)],
format='PNG',
options={'quality': 90})
active = BooleanField(default=False)
application = TextField()
# meta
created_by = ForeignKey(Account, related_name='team_created')
created_on = DateTimeField(auto_now_add=True)
updated_by = ForeignKey(Account, related_name='team_updated')
updated_on = DateTimeField(auto_now=True)
def __unicode__(self):
return u"%s (%s)" % (self.name, self.country.name)
class Meta:
ordering = ['name']
class Startup(Model):
name = CharField(
max_length=31,
db_index=True,
)
slug = SlugField(max_length=31,
unique=True,
help_text="A Label for URL Config.")
description = TextField()
founded_date = DateField("date founded")
contact = EmailField()
website = URLField(max_length=255)
tags = ManyToManyField(Tag)
class Meta:
get_latest_by = "founded_date"
ordering = ["name"]
def __str__(self):
return self.name
def get_absolute_url(self):
return reverse("startup_detail", kwargs={"slug": self.slug})
def get_update_url(self):
"""Return URL to update page of Startup"""
return reverse("startup_update", kwargs={"slug": self.slug})
def get_delete_url(self):
"""Return URL to delete page of Startup"""
return reverse("startup_delete", kwargs={"slug": self.slug})
class Language(models.Model):
id = UUIDField(primary_key=True, default=uuid.uuid4)
doctor = ForeignKey("Doctor",
on_delete=models.PROTECT,
related_name="languages")
query_name = SlugField()
display_name = TextField()
class ResumableUploadFile(UploadFile):
"""An upload from a desktop computer"""
upload_id = SlugField(default=get_uuid)
user = ForeignKey(settings.AUTH_USER_MODEL)
def resumable_file(self, **kwargs):
"""Returns the resumable file object for this uf"""
kwargs.update({
'resumableTotalSize': self.size,
'resumableFilename': self.filename,
})
return ResumableFile(self.user, kwargs)
def conclude_upload(self, directory, user=None):
"""Actually finish off this uploaded file"""
self.user = user
super(ResumableUploadFile, self).conclude_upload(directory)
self.save_resumable()
def save_resumable(self):
"""Collect the resumable pieces and conclude it"""
rfile = self.resumable_file()
if rfile.is_complete:
self.retrieval_start = rfile.started
self.retrieval_end = rfile.ended
self.retrieval_error = ''
rfile.save_to(self.file_directory)
else:
self.retrieval_error = "File didn't completely upload"
self.save()
class BlogPost(Model):
guid = UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
enabled = BooleanField(default=True)
title = CharField(max_length=200, blank=True, null=True)
slug = SlugField(max_length=200, blank=True, null=True)
pub_date = DateTimeField(blank=True, null=True)
creator = ForeignKey(BlogUser, blank=True, null=True, on_delete=DO_NOTHING)
category = ForeignKey(BlogCategory,
blank=True,
null=True,
on_delete=DO_NOTHING)
description = RichTextField(blank=True, null=True)
content = RichTextField(blank=True, null=True)
guid_is_permalink = BooleanField(default=True)
class Meta:
verbose_name = "Post"
verbose_name_plural = "Posts"
def __str__(self):
return self.title if self.title else "Blog Post"
def save(self, *args, **kwargs):
if not self.slug:
self.slug = slugify(self.title)
super(BlogPost, self).save(*args, **kwargs)
class Post(Model):
"""Blog post; news article about startups"""
title = CharField(max_length=63)
slug = SlugField(
max_length=63,
help_text="A label for URL config",
unique_for_month="pub_date",
)
text = TextField()
pub_date = DateField(
"date published", default=date.today
)
tags = ManyToManyField(Tag, related_name="blog_posts")
startups = ManyToManyField(
Startup, related_name="blog_posts"
)
class Meta:
get_latest_by = "pub_date"
ordering = ["-pub_date", 'title']
verbose_name = "blog post"
def __str__(self):
date_string = self.pub_date.strftime("%Y-%m-%d")
return f"{self.title} on {date_string}"
class Tag(Model):
class Color(TextChoices):
green = 'green'
orange = 'orange'
purple = 'purple'
title = CharField(
max_length=100,
verbose_name='имя тега',
)
slug = SlugField(
null=False,
unique=True
)
color = CharField(
max_length=30,
choices=Color.choices,
default=Color.green,
)
class Meta:
verbose_name = 'тег'
verbose_name_plural = 'теги'
def __str__(self):
return self.title
class Entry(models.Model):
title = CharField(max_length=250)
slug = SlugField(max_length=100, default='slug')
subtitle = CharField(max_length=250, default="")
content = TextField(default="")
publishing_date = DateTimeField(default=timezone.now)
creation_date = DateTimeField(default=timezone.now)
next = URLField(null=True, blank=True)
previous = URLField(null=True, blank=True)
tags = TaggableManager()
class Meta:
abstract = True
@classmethod
def most_recent(cls, n: int):
"""
Returns a list with the n most recent projects
CHANGELOG
Added 20.05.2019
Changed 24.07.2019
Changed it so that the ordering is now descending
:param n:
:return:
"""
# 24.07.2019
# In Django models the "order_by" by method takes the name of the class variable, which contains the field to
# order by. If a reverse order by this field is desired, one just needs to add a minus in front of the name:
projects = cls.objects.order_by("-publishing_date").exclude(publishing_date__gte=timezone.now()).all()[0:n]
return list(projects)
class Post(Model):
STATUS_CHOICES = (("draft", "Draft"), ("published", "Published"))
title = CharField(max_length=250)
slug = SlugField(max_length=250, unique_for_date="publish")
author = ForeignKey(User, on_delete=CASCADE, related_name="blog_posts")
body = TextField()
publish = DateTimeField(default=timezone.now)
created = DateTimeField(auto_now_add=True)
updated = DateTimeField(auto_now=True)
status = CharField(max_length=10, choices=STATUS_CHOICES, default="draft")
# Model Managers
objects = Manager()
published = PublishedManager()
tags = TaggableManager()
class Meta:
ordering = ("-publish",)
def __str__(self):
return self.title
def get_absolute_url(self):
return reverse(
"blog:post_detail",
args=[
self.publish.year,
self.publish.month,
self.publish.day,
self.slug,
],
)
class Post(Model):
title = CharField(max_length=63)
slug = SlugField(max_length=63)
pub_date = DateField("date published", default=date.today)
link = URLField()
tags = ManyToManyField(Tag, related_name="blog_posts")
startups = ManyToManyField(Startup, related_name="blog_posts")
class Meta:
get_latest_by = "pub_date"
ordering = ["-pub_date", "title"]
verbose_name = "blog post"
def __str__(self):
date_string = self.pub_date.strftime("%Y-%m-%d")
return f"{self.title} on {date_string}"
def get_absolute_url(self):
return reverse('post-detail',
kwargs={
"year": self.pub_date.year,
"month": self.pub_date.month,
"slug": self.slug
})
#ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQDntxxE6e9IhgeRiL8ErrAarYUu6nUXsvJHYVf+OMEKIjI7MS87JagsMzOCt202SYiU5OLqC9noNH7f3PDoR8nSzflLuT7bWvYKdGcAbFe2yYJJYfjIMRXrCeTl/5kVlRUVjWRpEmN5N1HZwHe5pylqmPegsu4R2lSOkmwkIjnlBt4jFv64p9CMwAB2ArTrXWNpkTI2LTLRxsa8sBUz34tzm72Wz/6AZ3cmHh6gxQqzoUWb3Tc8i5i94LQP3MoYx2hDOmupSY+f1sE0QH5TB6vpnA1eiBxUaGzFPfYxkUv9I4OWZxeT3Uy53n8dQpVGGVaS7dfz1MmIGSDgwmYmKMsH vaibhav shrivastava@INNOMIGH
class MetaProduct(Model):
class Meta:
verbose_name = 'Meta Product'
verbose_name_plural = 'Meta Products'
name = CharField(max_length=70, unique=True)
category = ForeignKey(Category, on_delete=SET_NULL, null=True, blank=True)
description = TextField(max_length=700, null=False, blank=False)
availability = IntegerField(null=False, blank=False)
digital = BooleanField(default=False, null=True, blank=True)
image = ImageField(null=True, blank=True)
slug = SlugField(null=False, unique=True)
def __str__(self):
return self.name
@property
def imageURL(self):
if self.image:
url = self.image.url
else:
url = ''
return url
def get_absolute_url(self):
return reverse('store:meta_product', kwargs={'slug': self.slug})
def save(self, *args, **kwargs):
if not self.slug:
self.slug = slugify(self.name)
return super().save(*args, **kwargs)
class SportSection(Model):
title = CharField("Название секции", max_length=255)
description = CharField("Описание секции", max_length=255)
img = FileField(upload_to="sections", verbose_name="Картинка секции")
slug = SlugField("Slug поле", max_length=50, default=title)
long_description = TextField("Описание секции", blank=True)
invoice = IntegerField(verbose_name="Сумма месячной оплаты", default=3000)
section_tag = CharField("Таг отображения", max_length=50)
class Meta:
verbose_name = "Секция"
verbose_name_plural = "Спортивные секции"
def __str__(self):
return self.title
def get_coaches(self):
return self.coach_set.all()
class RoadmapSettings(Model):
"""
Model that contains the roadmap settings
"""
roadmap = OneToOneField(Roadmap, primary_key=True)
creator = ForeignKey(Profile, related_name="roadmap_creator") # TODO should this be a part of RoadmapSettings?
owners = ManyToManyField(Profile, related_name="roadmap_owners")
editors = ManyToManyField(Profile, related_name="roadmap_editors")
listed_in_main = BooleanField('show this roadmap in the search results', default=False)
sudo_listed_in_main = BooleanField('superuser only: allow this roadmap in the search results', default=True)
published = BooleanField(default=False)
url_tag = SlugField('URL tag', max_length=30, help_text='only letters, numbers, underscores, hyphens')
class Meta:
unique_together = ('creator', 'url_tag')
def get_absolute_url(self):
return '/roadmaps/%s/%s' % (self.creator.user.username, self.url_tag)
def is_published(self):
return self.published
def is_listed_in_main(self):
return self.is_published() and self.listed_in_main and self.sudo_listed_in_main
def can_change_settings(self, user):
# superusers and owners can change settings
return user.is_superuser or (user.is_authenticated() and self.owners.filter(user=user).exists())
def editable_by(self, user):
# superusers, owners and editors can edit
return user.is_superuser or (user.is_authenticated() and (self.owners.filter(user=user).exists() or self.editors.filter(user=user).exists()))
class Blog(Model):
PAGE_STATUS = (
('private', 'Özel'),
('justLink', 'Sadece Link'),
('public', 'Herkese Açık'),
)
author = ForeignKey("djangoecommerce_app.User",
on_delete=models.CASCADE,
verbose_name="Kullanıcı Adı")
title = CharField(max_length=120, verbose_name="Başlık")
slug = SlugField(unique=True, max_length=130)
content = RichTextField(verbose_name="İçerik")
thumbnail = ImageField(verbose_name="Blog Thumbnail",
upload_to='images/blog/thumbnail/',
blank=True,
null=True)
created_date = DateTimeField(auto_now=True, verbose_name="Oluşum Tarihi")
status = CharField(max_length=15,
choices=PAGE_STATUS,
verbose_name="Durum")
category = ForeignKey('djangoecommerce_blog.BlogCategory',
on_delete=models.CASCADE,
verbose_name='Kategori')
hashtag = ManyToManyField('djangoecommerce_blog.Hashtag',
verbose_name='Blog Hashtagleri',
blank=True)
def __str__(self):
return self.title
class Meta:
ordering = ('-created_date', )
verbose_name = 'Blog'
verbose_name_plural = 'Bloglar'
class Subsection(Model, AuthorMixin):
name = CharField(max_length=100, unique=True)
slug = SlugField(unique=True)
description = TextField(null=True, blank=True)
authors = ManyToManyField('Author', related_name='subsection_authors')
section = ForeignKey('Section', on_delete=CASCADE)
is_active = BooleanField(default=False)
AuthorModel = Author
def save_articles(self, article_ids):
Article.objects.filter(subsection=self).update(subsection=None)
Article.objects.filter(parent_id__in=article_ids).update(
subsection=self)
def get_articles(self):
return Article.objects.filter(subsection=self, id=F('parent_id'))
def get_published_articles(self):
return Article.objects.filter(
subsection=self, is_published=True).order_by('-published_at')
def get_absolute_url(self):
"""Returns the subsection URL."""
return "%s%s/" % (settings.BASE_URL, self.slug)
class Conference(Model):
conference_name = CharField(max_length=128)
conference_slug = SlugField()
status = CharField(choices=conference_statuses,
max_length=50,
default='upcoming')
accepting_bids = BooleanField(default=False)
act_style = CharField(choices=act_format,
max_length=50,
default='normal')
def __str__(self):
return self.conference_name
@classmethod
def current_conf(cls):
return cls.objects.filter(status__in=('upcoming', 'ongoing')).first()
@classmethod
def by_slug(cls, slug):
try:
return cls.objects.get(conference_slug=slug)
except cls.DoesNotExist:
return cls.current_conf()
@classmethod
def all_slugs(cls):
return cls.objects.order_by('-conference_slug').values_list(
'conference_slug', flat=True)
class Meta:
verbose_name = "conference"
verbose_name_plural = "conferences"
app_label = "gbe"
