class DataStore(TimeStampedModel):
name = pg_fields.CICharField(max_length=200)
version = models.IntegerField(default=1)
uuid = models.UUIDField(unique=True, db_index=True, default=uuid.uuid4, editable=False)
data = pg_fields.JSONField(default=dict)
cleaned_data = pg_fields.JSONField(default=dict)
fields = pg_fields.ArrayField(models.CharField(max_length=200), default=list)
field_tracker = FieldTracker(fields=['data', 'cleaned_data', 'fields'])
author_type = models.ForeignKey(
ContentType, db_constraint=False, on_delete=models.PROTECT,
related_name="%(app_label)s_%(class)s_authored",
)
author_id = models.CharField(max_length=128)
author = GenericForeignKey('author_type', 'author_id')
objects = DataStoreManager()
all_objects = models.Manager()
class Meta:
abstract = True
def save(self, *args, **kwargs):
request = get_request()
if not self.pk:
if request:
if not request.session.session_key:
request.session.save()
session_object = request.session._get_session_from_db()
self.author_type_id = ContentType.objects.get_for_model(session_object._meta.model).id
self.author_id = session_object.pk
return super().save(*args, **kwargs)
class Profile(models.Model):
"""
This model contains the profile data.
Profiles represents the phisical profile data.
It may be allways related to an user.
"""
id = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
user = models.OneToOneField(
settings.AUTH_USER_MODEL, on_delete=models.CASCADE)
first_name = models.CharField(max_length=150, verbose_name='First Name')
last_name = models.CharField(max_length=150, verbose_name='Last Name')
mothers_name = models.CharField(
max_length=150, verbose_name="Mother's Name", null=True)
fathers_name = models.CharField(
max_length=150, verbose_name="Father's Name", null=True)
phones = pg.JSONField(default=list)
addresses = pg.JSONField(default=list)
documents = pg.JSONField(default=list)
birthdate = models.DateField(null=True)
created_at = models.DateTimeField(auto_now_add=True)
updated_at = models.DateTimeField(auto_now=True)
class Meta:
verbose_name_plural = 'Profiles'
def __str__(self):
return self.first_name
def get_full_name(self):
return "{} {}".format(self.first_name, self.last_name)
def get_age(self):
return timezone.now().year - self.birthdate.year
class Provider(models.Model):
id = models.UUIDField(primary_key=True, default=uuid.uuid4)
name = UnboundedCharField(blank=True, default="")
logo_b64 = UnboundedCharField(null=True, blank=True, default=None)
# The following fields are for us pulling data from the provider
base_api_url = UnboundedCharField(default="",
blank=True,
verbose_name="Base Provider API URL")
oauth2_url = UnboundedCharField(default="",
blank=True,
verbose_name="OAuth2 URL (if different)")
api_authentication = pg_fields.JSONField(
default=provider_api_authentication_default,
blank=True,
verbose_name="Provider API Authentication",
)
api_configuration = pg_fields.JSONField(
default=provider_api_configuration_default,
blank=True,
verbose_name="Provider API Configuration",
)
# We may poll a provider, e.g. LADOT sandbox that replies for many providers
# but has no device itself.
# So we cannot just rely on checking the latest event record saved.
last_start_time_polled = models.DateTimeField(blank=True, null=True)
# The following fields are for the provider pushing data to us
agency_api_authentication = pg_fields.JSONField(
default=agency_api_authentication_default,
blank=True,
verbose_name="Agency API Authentication",
)
agency_api_configuration = pg_fields.JSONField(
default=agency_api_configuration_default,
blank=True,
verbose_name="Agency API Configuration",
)
colors = pg_fields.JSONField(
default=dict,
blank=True,
verbose_name="colors for distinguishing provider icons",
validators=[colors_validator],
)
objects = ProviderQuerySet.as_manager()
def __str__(self):
return "{} ({})".format(self.name or "Provider object",
short_uuid4(self.id))
@property
def device_categories(self):
# This will fail if you didn't call objects.with_device_categories()
device_categories = {}
for category in enums.DEVICE_CATEGORY:
device_categories[category.name] = getattr(
self, "device_category_%s" % category.name)
return device_categories
class CollectionImport(Task):
"""Collection import task info."""
name = models.CharField(max_length=64)
version = models.CharField(max_length=64)
messages = psql_fields.JSONField(default=list)
lint_records = psql_fields.JSONField(default=list)
namespace = models.ForeignKey(Namespace, on_delete=models.CASCADE)
imported_version = models.ForeignKey(CollectionVersion,
null=True,
on_delete=models.SET_NULL,
related_name='import_tasks')
def add_log_record(self, record: logging.LogRecord):
self.messages.append({
'message': record.msg,
'level': record.levelname,
'time': record.created,
})
def add_lint_record(self, lint_record: lintutils.LintRecord) -> None:
self.lint_records.append(attr.asdict(lint_record))
def get_message_stats(self):
"""Returns total number of errors and warnings."""
# TODO(cutwater): Replace with SQL query
errors, warnings = 0, 0
for msg in self.messages:
if msg['level'] == 'ERROR':
errors += 1
elif msg['level'] == 'WARNING':
warnings += 1
return errors, warnings
class CredentialType(Auditable):
schema = models.ForeignKey(Schema,
related_name="credential_types",
on_delete=models.CASCADE)
issuer = models.ForeignKey(Issuer,
related_name="credential_types",
on_delete=models.CASCADE)
description = models.TextField(blank=True, null=True)
processor_config = contrib.JSONField(blank=True, null=True)
credential_def_id = models.TextField(db_index=True, null=True)
logo_b64 = models.TextField(null=True)
visible_fields = models.TextField(null=True)
last_issue_date = models.DateTimeField(null=True)
url = models.TextField(blank=True, null=True)
claim_descriptions = contrib.JSONField(blank=True, null=True)
claim_labels = contrib.JSONField(blank=True, null=True)
category_labels = contrib.JSONField(blank=True, null=True)
class Meta:
db_table = "credential_type"
unique_together = (("schema", "issuer"), )
ordering = ('id', )
def get_has_logo(self):
return bool(self.logo_b64 or (self.issuer and self.issuer.logo_b64))
class ItemPrototype(models.Model):
# TODO: Item should not be in Inventory app
name = models.CharField(max_length=40)
code = models.CharField(primary_key=True, max_length=40)
type = models.IntegerField(default='Item.UNDEFINED', choices=TYPE_OPTIONS)
store_price = models.IntegerField(default=2)
sold_price = models.IntegerField(default=1)
display_fields = postgres_fields.JSONField(null=True, blank=True)
# generator will create and return an item instance accourding to rules
generator = models.CharField(max_length=255, null=True, blank=True)
rules = postgres_fields.JSONField(null=True, blank=True)
def generate_item(self):
# return a Item objects if success, else False
from game.utils import load_class
generator = load_class(self.generator)
if not generator:
from item.libs.item_generator import default_generator
generator = default_generator
if self.rules:
return generator(item_prototype=self, **self.rules)
else:
return generator(item_prototype=self)
class Job(models.Model):
class Meta:
indexes = [
models.Index(fields=[
"md5",
"status",
]),
]
source = models.CharField(max_length=50, blank=False, default="none")
is_sample = models.BooleanField(blank=False, default=False)
md5 = models.CharField(max_length=32, blank=False)
observable_name = models.CharField(max_length=512, blank=True)
observable_classification = models.CharField(max_length=12, blank=True)
file_name = models.CharField(max_length=512, blank=True)
file_mimetype = models.CharField(max_length=80, blank=True)
status = models.CharField(max_length=32,
blank=False,
choices=STATUS,
default="pending")
analyzers_requested = postgres_fields.ArrayField(
models.CharField(max_length=128), blank=True, default=list)
run_all_available_analyzers = models.BooleanField(blank=False,
default=False)
analyzers_to_execute = postgres_fields.ArrayField(
models.CharField(max_length=128), blank=True, default=list)
analysis_reports = postgres_fields.JSONField(default=list,
null=True,
blank=True)
received_request_time = models.DateTimeField(auto_now_add=True)
finished_analysis_time = models.DateTimeField(blank=True, null=True)
force_privacy = models.BooleanField(blank=False, default=False)
disable_external_analyzers = models.BooleanField(blank=False,
default=False)
errors = postgres_fields.ArrayField(models.CharField(max_length=900),
blank=True,
default=list,
null=True)
file = models.FileField(blank=True, upload_to=file_directory_path)
tags = models.ManyToManyField(Tag, related_name="jobs", blank=True)
runtime_configuration = postgres_fields.JSONField(default=dict,
null=True,
blank=True)
@classmethod
def object_by_job_id(cls, job_id, transaction=False):
try:
if transaction:
job_object = cls.objects.select_for_update().get(id=job_id)
else:
job_object = cls.objects.get(id=job_id)
except cls.DoesNotExist:
raise AnalyzerRunException(f"No Job with ID:{job_id} retrieved")
return job_object
def __str__(self):
if self.is_sample:
return f'Job("{self.file_name}")'
return f'Job("{self.observable_name}")'
class RefiningModel(BaseModel):
user = models.EmailField(max_length=255)
tax = models.IntegerField()
type_of = models.CharField(max_length=56)
focus = IntegerRangeField(min_value=0,
max_value=30000,
blank=True,
null=True)
purchased_resources = models.BooleanField(default=False)
resouces_cost = fields.ArrayField(fields.JSONField(),
blank=False,
null=False)
resources_to_refining = fields.ArrayField(fields.JSONField(),
blank=False,
null=False)
refined_total = fields.ArrayField(fields.JSONField(),
blank=False,
null=False)
refining_prices = fields.ArrayField(fields.JSONField(),
blank=False,
null=False)
class CollectionVersion(mixins.TimestampsMixin, pulp_models.Content):
"""
A model representing an Ansible Content Collection version.
:var version: Collection version string in semantic version format.
:var hidden: Indicates if a version should not be displayed and allowed
for installation.
:var metadata: Collection metadata in JSON format.
:var contents: Collection contents in JSON format.
:var collection: A reference to a related collection object.
"""
TYPE = 'collection-version'
# Fields
version = models.CharField(max_length=64)
hidden = models.BooleanField(default=False)
metadata = psql_fields.JSONField(default=dict)
contents = psql_fields.JSONField(default=list)
quality_score = models.FloatField(
null=True,
validators=[MinValueValidator(0.0),
MaxValueValidator(5.0)],
)
readme_mimetype = models.CharField(max_length=32, blank=True)
readme_text = models.TextField(blank=True)
readme_html = models.TextField(blank=True)
# References
collection = models.ForeignKey(Collection,
on_delete=models.CASCADE,
related_name='versions')
_parent_ref = models.OneToOneField(pulp_models.Content,
on_delete=models.CASCADE,
parent_link=True,
db_column='id')
class Meta:
unique_together = (
'collection',
'version',
)
def __str__(self):
return '{}.{}-{}'.format(self.collection.namespace.name,
self.collection.name, self.version)
def get_content_artifact(self) -> pulp_models.ContentArtifact:
"""Returns a ContentArtifact object related to collection version."""
return pulp_models.ContentArtifact.objects.filter(content=self).first()
def get_download_url(self) -> str:
"""Builds artifact download url pointing to Pulp's content app."""
prefix = settings.GALAXY_DOWNLOAD_URL
repository = settings.GALAXY_PULP_REPOSITORY
ca = self.get_content_artifact()
return '/' + '/'.join(
s.strip('/') for s in (prefix, repository, ca.relative_path))
class Log(models.Model):
owner = models.ForeignKey('auth.User',
on_delete=models.CASCADE,
related_name='logs',
help_text='Log owner.')
uuid = models.CharField(primary_key=True,
max_length=22,
editable=False,
help_text='Log\'s UUID.')
created = models.DateTimeField(auto_now_add=True,
help_text='Log creation date.')
expires = models.DateTimeField(null=True, help_text='Log expiration date.')
content = models.TextField(editable=False, help_text='Raw log content.')
type = models.CharField(max_length=40, null=True, help_text='Log type.')
users = fields.JSONField(default=list, help_text='List of users in log.')
privacy = models.CharField(max_length=10, default='public')
guild = models.IntegerField(null=True)
data = fields.JSONField(default=dict, help_text='Extraneous data.')
class Meta:
permissions = [
('api_access', 'Can access the API'),
('extended_expiry', 'Can set an expiry time of up to two weeks'),
('no_expiry', 'Can set an infinite expiry time, or none at all')
]
ordering = ['created']
@classmethod
def generate_uuid(cls, content):
"""Generate short uuid, used to uniquely identify logs based on content."""
return shortuuid.uuid(str(content))
def __str__(self):
return f'Log {self.uuid}'
class KoocookUser(SerialisableModel, models.Model):
user = models.OneToOneField(User, on_delete=models.CASCADE)
# author from Author's OneToOneField
preferences = fields.JSONField(default=_default_preferences)
user_settings = fields.JSONField(default=_default_preferences)
following = models.ManyToManyField('self')
followers = models.ManyToManyField('self')
class Meta:
db_table = "koocook_user"
def follow(self, user: '******'):
pass
def unfollow(self, user: '******'):
pass
@property
def name(self):
if self.user.get_full_name():
return self.user.get_full_name()
else:
return self.user.username
@property
def full_name(self):
return self.user.get_full_name()
class ApiRequest(models.Model):
REQUEST_TYPE = [("GET", "get"), ("POST", "post"), ("PUT", "put"),
("DELETE", "delete")]
request_type = models.CharField(choices=REQUEST_TYPE, max_length=16)
request_url = models.CharField(max_length=1024)
body = pgJson.JSONField(null=True, blank=True)
response = pgJson.JSONField(null=True, blank=True)
created_on = models.DateTimeField(auto_now_add=True)
updated_on = models.DateTimeField(auto_now_add=True)
class KoocookUser(SerialisableModel, models.Model):
"""
Attributes:
author (Author): from OneToOneField in ``Author``
Notes:
Automatically created when ``User`` is created.
"""
exclude = ('user', 'preferences', 'user_settings')
avatar = fields.JSONField(default=dict)
user = models.OneToOneField(User, on_delete=models.CASCADE)
preferences = fields.JSONField(default=_default_preferences)
user_settings = fields.JSONField(default=_default_preferences)
following = models.ManyToManyField('self')
followers = models.ManyToManyField('self')
class Meta:
db_table = 'koocook_auth_user'
default_related_name = 'koocook_user'
@property
def formal_preferences(self):
from koocook_core.support import PreferenceManager
return PreferenceManager.from_koocook_user(self)
def follow(self, user: '******'):
self.following.add(user)
user.followers.add(self)
def unfollow(self, user: '******'):
self.following.remove(user)
user.followers.remove(self)
self.save()
@property
def name(self):
if self.user.get_full_name():
return self.user.get_full_name()
else:
return self.user.username
@classmethod
def from_dj_user(cls, user: User):
return cls.objects.get(user=user)
@property
def full_name(self):
return self.user.get_full_name()
@property
def avatar_url(self):
if 'content' in self.avatar:
return self.avatar['content']
else:
return None
class Riding(models.Model):
riding_id = models.IntegerField(primary_key=True)
name = models.CharField(max_length=100)
results = pgfields.JSONField(default=None)
percents = pgfields.JSONField(default=None)
swings = pgfields.JSONField(default=None)
def __str__(self):
return self.name
class Event(models.Model):
app = models.CharField(max_length=200)
okind = models.CharField(max_length=200, null=True)
oid = models.CharField(max_length=200, null=True)
odata = pg.JSONField(null=True)
ekind = models.CharField(max_length=200, null=True)
edata = pg.JSONField(null=True)
user_id = models.IntegerField(null=True)
tracker = models.CharField(max_length=200, null=True)
ip = models.CharField(max_length=200, null=True)
user_agent = models.CharField(max_length=200, null=True)
visit_id = models.IntegerField(null=True)
class Student(models.Model):
"""Student model: contains information used by the dashboard."""
student_id = models.AutoField(primary_key=True)
name = models.CharField(max_length=20)
email = models.CharField(max_length=29)
avatar = models.CharField(max_length=20000)
reference_number = models.CharField(max_length=12)
tutor = models.CharField(max_length=50)
timetable = fields.JSONField()
attendance = fields.JSONField()
markbook = fields.JSONField()
class Token(models.Model):
""" table to store the tokens associated with different teams """
id = models.UUIDField(primary_key=True, default=uuid4, editable=False)
team = models.CharField(max_length=100)
auth_token_json = fields.JSONField()
access_token_json = fields.JSONField()
created_on = models.DateTimeField(auto_now_add=True)
last_modified_on = models.DateTimeField(auto_now=True)
@property
def access_token(self):
return self.access_token_json.get('access_token')
class HCVStandardCurve(models.Model):
name = models.CharField(max_length=100,
default=datetime.now().strftime('%Y-%m-%d'))
std_curve = fields.JSONField()
r_2 = models.FloatField()
eff = models.FloatField()
slope = models.FloatField()
stds = fields.JSONField()
B = models.FloatField()
factor = models.FloatField()
def __str__(self):
return self.name
class Form(models.Model):
objects = FormManager()
sha1 = models.CharField(max_length=40, db_index=True)
form_spec = pg_fields.JSONField()
form_i18n = pg_fields.JSONField(blank=True, null=True)
class Meta:
abstract = apps.get_containing_app_config(__name__) is None
ordering = ('id',)
verbose_name = _("Form")
verbose_name_plural = _("Forms")
@cached_property
def frozen_spec(self):
return bytefy(self.form_spec)
@cached_property
def frozen_i18n(self):
return bytefy(self.form_i18n)
@cached_property
def form_class(self):
return DynamicForm.get_form_class_by(self)
@cached_property
def form_class_or_dummy(self):
try:
return self.form_class
except ValueError as error:
logger.critical("DB has invalid form_spec with id %d: %s", self.id, error)
return DummyForm
def clean(self):
# try to create a class -> ensures form_spec is readable
try:
self.form_class
except AttributeError as e:
raise ValidationError({
'form_spec': format_lazy(_("Invalid form_spec: {error}"), error=str(e)),
}) from e
def save(self, **kwargs):
if not self.sha1:
self.frozen_spec = frozen_spec = bytefy(self.form_spec)
self.frozen_i18n = frozen_i18n = bytefy(self.form_i18n)
self.sha1 = freeze_digest(frozen_spec, frozen_i18n)
return super().save(**kwargs)
def __str__(self):
return "<Form {}, {} fields, sha1:{}>".format(self.pk, len(self.form_spec), self.sha1)
class Index(models.Model):
content_type = models.ForeignKey(ContentType, on_delete=models.CASCADE)
name = models.TextField()
unique = models.BooleanField()
field = pg.JSONField()
where = pg.JSONField(null=True, blank=True)
def get_structure(self):
return {
"name": self.name,
"fields": set(self.field),
"unique": self.unique,
"where": set(self.where) if self.where else None,
}
class Log(models.Model):
"""
Store requests made against the API for easier debugging
"""
METHODS = ('HEAD', 'OPTIONS', 'GET', 'PATCH', 'POST', 'PUT', 'DELETE')
date = models.DateTimeField(auto_now_add=True)
path = models.CharField(max_length=100)
method = models.CharField(max_length=10)
headers = postgres.JSONField()
body = models.TextField(default="")
get = postgres.JSONField()
post = postgres.JSONField()
objects = LogManager()
class Post(MetaTagBase):
title = models.CharField(max_length=200)
text = FroalaField(image_upload=True)
topic = models.ForeignKey(Topic,
on_delete=models.SET_NULL,
related_name='posts',
null=True,
blank=True)
published_date = models.DateField(blank=True, null=True)
tags = fields.ArrayField(models.CharField(max_length=200),
blank=True,
default=list)
clicks = models.IntegerField(blank=True, default=0)
likes = models.IntegerField(blank=True, default=0)
dislikes = models.IntegerField(blank=True, default=0)
preferences = fields.JSONField(blank=True, default=dict)
objects = models.Manager()
published = PublishedMenager()
class Meta:
ordering = ['-published_date']
indexes = [
models.Index(fields=['-published_date']),
]
def publish(self):
self.published_date = timezone.now()
self.save()
def __str__(self):
return self.title
def get_absolute_url(self):
return reverse('blog:post_detail', kwargs={'pk': self.pk})
class DataProvider(models.Model):
provider_type = models.TextField(default="OAUTH")
path_name = models.CharField(max_length=128, unique=True)
display_name = models.TextField(unique=True, blank=True)
client_id = models.TextField(default=None)
client_secret = models.TextField(default=None)
access_token_url = models.TextField(default=None)
auth_url = models.TextField(default=None)
extra_params = fields.JSONField(default=dict)
@property
def request_headers(self):
basic_header = str(
b64encode(bytes(self.client_id + ":" + self.client_secret,
"utf8")), "utf-8")
return {"Authorization": "basic " + basic_header}
def generate_url(self, base):
scopes = [s.value for s in Scope.objects.filter(provider=self)]
session = OAuth2Session(client_id=self.client_id,
redirect_uri=self.redirect_url(base),
scope=scopes)
extra_params = json.loads(self.extra_params) \
if isinstance(self.extra_params, str) else self.extra_params
auth_url, state = session.authorization_url(self.auth_url,
**extra_params)
return auth_url, state
def redirect_url(self, base):
return parse.urljoin(base, f"/oauth/{self.path_name}/callback")
class Organizer(models.Model):
slug = models.SlugField(max_length=50,unique=True)
name = models.CharField(max_length=50)
description = models.TextField()
config = postgres_fields.JSONField(default=dict)
def __unicode__(self):
return self.name
class UserDefGroupTallyBaseNonStored(UserDefTallyBaseNonStored):
get_group = pg_fields.JSONField(
default=None,
blank=True, null=True,
)
def as_tally(self, **kwargs):
return super().as_tally(get_group=decode(self.get_group), **kwargs)
class UserTally(Group, UserDefTallyBaseNonStored.UserTally):
def __init__(self, get_group=None, **kwargs):
super(Group, self).__init__(**kwargs)
self._get_group = get_group
def get_group(self, value):
return run(
self._get_group,
Env(
env={'value': value},
base_env=self._env,
),
log=True,
)
class Meta:
abstract = True
class CollectionImport(models.Model):
"""A model representing a collection import task details."""
task = models.OneToOneField(Task,
on_delete=models.CASCADE,
editable=False,
related_name="+",
primary_key=True)
messages = psql_fields.JSONField(default=list, editable=False)
class Meta:
ordering = ["task__pulp_created"]
def add_log_record(self, log_record):
"""
Records a single log message but does not save the CollectionImport object.
Args:
log_record(logging.LogRecord): The logging record to record on messages.
"""
self.messages.append({
"message": log_record.msg,
"level": log_record.levelname,
"time": log_record.created
})
class BotSetting(ModelReprMixin, models.Model):
"""A configuration entry for the bot."""
name = models.CharField(primary_key=True,
max_length=50,
validators=(validate_bot_setting_name, ))
data = pgfields.JSONField(help_text="The actual settings of this setting.")
class Run(models.Model):
RUNNING = 'running'
SUCCEEDED = 'succeeded'
FAILED = 'failed'
STATUS_CHOICES = [(x, x) for x in (RUNNING, SUCCEEDED, FAILED)]
workflow = models.ForeignKey(Workflow, models.PROTECT)
submitted_time = models.DateTimeField()
scheduled_time = models.DateTimeField(null=True)
status = models.TextField(default=RUNNING, choices=STATUS_CHOICES)
parameters = fields.JSONField(default=dict)
def update_status(self):
from yawn.task.models import Task
task_statuses = self.task_set.all().values_list('status', flat=True)
if all([status == Task.SUCCEEDED for status in task_statuses]):
self.status = self.SUCCEEDED
elif any([
status in [Task.WAITING, Task.QUEUED, Task.RUNNING]
for status in task_statuses
]):
self.status = self.RUNNING
else:
self.status = self.FAILED
self.save()
def __str__(self):
return 'Workflow {} Run {}'.format(self.workflow_id, self.id)
class PeopleImage(models.Model):
"""이미지."""
url = models.URLField(unique=True, max_length=400)
title = models.TextField(max_length=500)
category = models.ForeignKey(
Category, on_delete=models.SET_NULL, null=True, blank=True
)
page = models.CharField(max_length=60)
selected = models.BooleanField(null=True, blank=True)
user_id = models.CharField(max_length=20)
meta = fields.JSONField(null=True, blank=True)
content_parsed = models.BooleanField(null=True, blank=True, default=None)
def get_user_id(self):
"""URL 의 5번째 항목."""
return self.url.split("/")[5]
def save(
self, force_insert=False, force_update=False, using=None, update_fields=None
):
"""저장시 user_id 세팅."""
self.user_id = self.get_user_id()
super().save(force_insert, force_update, using, update_fields)
def __str__(self):
return str(self.url)
class Stock(models.Model):
"""주식 정보."""
code = models.CharField(max_length=10)
name = models.CharField(max_length=30)
is_etf = models.BooleanField(default=False)
price_list = fields.JSONField(null=True, blank=True)
