class Invoice(models.Model): recipient = models.ForeignKey(Recipient, on_delete=models.CASCADE) description = models.TextField(max_length=1000, default='') amount = models.FloatField(default=0) currency = models.CharField(max_length=5, default='CZK') # models.FloatField(default=1) exchange_rate = PickledObjectField(default=get_pickle_default) date = models.DateField(default=datetime.now, blank=True) datedue = models.DateField(default=datetime.now, blank=True) iid = models.IntegerField(default=0, null=True, blank=True) payment = models.CharField(max_length=25, default='bankovním převodem') owner = models.ForeignKey(User, on_delete=models.CASCADE, null=True, blank=True) has_items = models.BooleanField(default=False, null=True) advance = models.ForeignKey(Advance, on_delete=models.CASCADE, null=True, blank=True) paid = models.DateField(blank=True, null=True) paid_exchange_rate = PickledObjectField(null=True, blank=True) def __str__(self): return ', '.join( [str(self.iid), self.recipient.name, str(self.amount), 'CZK'])
class Report(models.Model): # If not group defined, it was ran # on the entire annotations as single massive list group = models.ForeignKey(Group, null=True, blank=True) PAIRWISE = 0 AVERAGE = 1 REPORT_CHOICE = ( (PAIRWISE, 'pairwise'), (AVERAGE, 'average'), ) report_type = models.CharField(max_length=1, choices=REPORT_CHOICE, blank=False) dataframe = PickledObjectField() args = PickledObjectField() created = models.DateTimeField(auto_now_add=True) class Meta: app_label = 'analysis' def __unicode__(self): return u'Report'
class DebugLogRecord(models.Model): """Captures statistics for individual requests.""" timestamp = models.DateTimeField(auto_now_add=True) test_run = models.ForeignKey(TestRun, related_name='records') request_path = models.CharField(max_length=255) settings = PickledObjectField(compress=True, blank=True, null=True) # Timer stats timer_utime = models.FloatField(blank=True, null=True) timer_stime = models.FloatField(blank=True, null=True) timer_cputime = models.FloatField(blank=True, null=True) timer_total = models.FloatField(blank=True, null=True) timer_vcsw = models.IntegerField(blank=True, null=True) timer_ivcsw = models.IntegerField(blank=True, null=True) # Sql stats sql_num_queries = models.IntegerField(blank=True, null=True) sql_time = models.FloatField(blank=True, null=True) sql_queries = PickledObjectField(compress=True, blank=True, null=True) # Cache stats cache_num_calls = models.IntegerField(blank=True, null=True) cache_time = models.FloatField(blank=True, null=True) cache_hits = models.IntegerField(blank=True, null=True) cache_misses = models.IntegerField(blank=True, null=True) cache_sets = models.IntegerField(blank=True, null=True) cache_gets = models.IntegerField(blank=True, null=True) cache_get_many = models.IntegerField(blank=True, null=True) cache_deletes = models.IntegerField(blank=True, null=True) cache_calls = PickledObjectField(compress=True, blank=True, null=True) def __unicode__(self): return u'DebugLogRecord from %s' % self.timestamp
class SearchSubscription(models.Model): user = models.ForeignKey(User, related_name="search_subscriptions", on_delete=models.CASCADE) keyword_args = PickledObjectField(default=dict) search_params = PickledObjectField(default=dict) filter_class_module = models.CharField(max_length=254) filter_class_name = models.CharField(max_length=254) oftenity = models.DurationField( help_text=_(u"Cada cuanto te notificamos?")) created = models.DateTimeField(auto_now_add=True, blank=True, null=True) updated = models.DateTimeField(auto_now=True, blank=True, null=True) last_run = models.DateTimeField(blank=True, null=True) token = models.UUIDField(default=uuid.uuid4) def unsubscribe_url(self): return reverse('proposal_subscriptions:unsubscribe', kwargs={'token': self.token}) def base_queryset(self): mod = __import__(self.filter_class_module, fromlist=[self.filter_class_name]) filter_klass = getattr(mod, self.filter_class_name) filter_ = filter_klass(data=self.search_params, **self.keyword_args) return filter_.qs def queryset(self): qs = self.base_queryset() since_when = timezone.now() - self.oftenity return qs.filter(created__gt=since_when)
class DyField(models.Model): """ Dynamic field """ name = models.CharField(max_length=200) label = models.CharField(max_length=200) type = models.CharField(max_length=200) model = models.ForeignKey(DyModel, related_name='dyfields') args = PickledObjectField() kwargs = PickledObjectField() def get_field_name(self): return slugify(self.name).replace("-", "_") def get_field(self): field_type = getattr(models, self.type) field = field_type(*self.args, **self.kwargs) return field @property def is_geo_field(self): return self.type in utils.GEOM_FIELDS @property def is_datetime_field(self): return self.type in utils.DATETIME_FIELDS def save(self, *args, **kwargs): if not self.label: self.label = self.name return super(DyField, self).save(*args, **kwargs)
class Session(models.Model): session_date = models.DateField() encounter = models.ForeignKey('Encounter', blank=True, null=True) pcs = models.ManyToManyField('PC', blank=True) tracker = PickledObjectField(null=True) delay = PickledObjectField(null=True) def __str__(self): return str(self.session_date) def extract_npcs(self, monsters): list = [] for monster in monsters: for i in range(0, monster.number): list.append(monster.npc) return list def first_pickle_list(self): monster_list = [monster for monster in self.encounter.monsters.all()] npc_list = self.extract_npcs(monster_list) players_list = [p for p in self.pcs.all()] tracker = Tracker() result_list = sorted( chain(npc_list, players_list), key=attrgetter('initiative'), reverse=True) for x in result_list: tracker.add_player(x) self.tracker = pickle.dumps(tracker)
class ProjectionIn2D(models.Model): url = models.CharField(max_length=30, default="URL") plot = PickledObjectField() data = PickledObjectField(default="SOME STRING") kmeans = PickledObjectField(default="SOME STRING", null=True, blank=True) base_data = models.ForeignKey(BaseData, on_delete=models.CASCADE, related_name="ProjectionIn2D")
class Descripcionecg(models.Model): senal = models.ForeignKey(Signal, on_delete=models.CASCADE, null=True) filtrada = PickledObjectField(default=0) hrv = PickledObjectField(default=0) bpm = models.IntegerField(default=0) def __str__(self): return self.senal.nombre
class Division(models.Model): """a Division is a set of rules (Queryset) that defines the eligibility of Persons, Teams and specific Rosters to compete at a related tournament. A tournament can have more than one Divsion. Example: TournamentDivision Mixed EUCF. Eligible are all players who have not played at any EUCR in another Division and all Teams that have qualified through eucr and whose roster for this tournament does not contain more than 3 new players compared to the EUCR roster """ name = models.CharField(max_length=300, unique=True) description = models.TextField(blank=True) def default_eligible_person_query(): return dbsafe_encode(Person.objects.all().query) eligible_person_query = PickledObjectField(default=default_eligible_person_query) def default_eligible_team_query(): return dbsafe_encode(Team.objects.all().query) eligible_team_query = PickledObjectField(default=default_eligible_team_query) tournaments = models.ManyToManyField("Tournament", through="TournamentDivision") def eligible_persons(self) -> models.QuerySet: queryset = Person.objects.all() queryset.query = self.eligible_person_query return queryset # would be nice to have the AND clauses that caused the object to not be selected. def is_eligible(self, person: Person) -> bool: queryset = Person.objects.all() queryset.query = self.eligible_person_query def eligible_teams(self) -> models.QuerySet: queryset = Team.objects.all() queryset.query = self.eligible_team_query return queryset # TODO: if not elegible return lookups that caused it # self.query.where.children reutrns an iterable over all lookups def is_eligible(self, team: Team) -> bool: return self.eligible_Teams.filter(pk=team.pk).exists() def eligible_Rosters(self) -> models.QuerySet: queryset = Roster.objects.all() queryset.query = self.eligible_team_query return queryset def is_eligible(self, roster: Roster) -> bool: return self.eligible_Rosters.filter(pk=roster.pk).exists() def __str__(self): return f"{self.name} (id= {self.id})"
class ItemMapping(models.Model): objects = BridgeManager() # a part of the compound key to identify the bridge integration = models.ForeignKey('core.Integration') bridge_name = models.CharField(max_length=512) # item requisites left_id = models.CharField(u'"Left system" item id', max_length=512, null=True, db_index=True) left_hash = models.CharField(u'Last seen hash of the item', max_length=64, default='!') left_extra = PickledObjectField(u'Extra data of the "left side"', default={}) right_id = models.CharField(u'"Right system" item id', max_length=512, null=True, db_index=True) right_hash = models.CharField(u'Last seen hash of the item', max_length=64, default='!') right_extra = PickledObjectField(u'Extra data of the "right side"', default={}) def side(self, side_name): return SideProxy(self, side_name) class Meta: index_together = [ ['integration', 'bridge_name', 'left_id'], ['integration', 'bridge_name', 'right_id'], ] def __log__(self): """ Logging utils use this information to convert object to a log record """ return { 'id': self.id, 'integration_id': self.integration_id, 'bridge_name': self.bridge_name, 'left_id': self.left_id, 'left_hash': hash_and_extra(self.left_hash, self.left_extra), 'right_id': self.right_id, 'right_hash': hash_and_extra(self.right_hash, self.right_extra), } def __str__(self): return '%s: %s (%s) -> %s (%s)' % ( self.bridge_name, self.left_id, hash_and_extra(self.left_hash, self.left_extra), self.right_id, hash_and_extra(self.right_hash, self.right_extra))
class Feature(models.Model): created = models.DateTimeField(auto_now_add=True, blank=True, null=True) modified = models.DateTimeField(auto_now=True, blank=True, null=True) item = models.ForeignKey(Item) name = models.CharField(max_length=255, blank=True, null=True) description = PickledObjectField() feature = PickledObjectField() def __unicode__(self): return str(self.pk)
class UserProfile(models.Model): user_name = models.OneToOneField(User, on_delete = models.CASCADE) Score = models.IntegerField(blank=True, default = 0) result=PickledObjectField(null=True) num = models.IntegerField(blank = True, default = 1) prefs = PickledObjectField(null=True) form_submit = models.BooleanField(blank = True,default = False) def __str__(self): return self.user_name.name
class SiteStats(models.Model): last_modified = models.DateTimeField(auto_now=True) replays = models.IntegerField() tags = models.CharField(max_length=1000) maps = models.CharField(max_length=1000) active_players = models.CharField(max_length=1000) all_players = PickledObjectField() comments = models.CharField(max_length=1000) games = models.CharField(max_length=1000) bawards = PickledObjectField()
class ChecklistScore(models.Model): date_created = models.DateTimeField(default=timezone.now, null=True) score = models.PositiveIntegerField(null = True) checked = PickledObjectField(default = dict) unchecked = PickledObjectField(default = dict) tenant = models.ForeignKey(settings.AUTH_USER_MODEL, null=True, on_delete = models.CASCADE, related_name='tenant_checklist') def __str__(self): return str(self.date_created)[:10] + "; Score: " + str(self.score) + " (" + str(self.tenant.username) + ")"
class TestingModel(models.Model): pickle_field = PickledObjectField() compressed_pickle_field = PickledObjectField(compress=True) default_pickle_field = PickledObjectField(default=({ 1: 1, 2: 4, 3: 6, 4: 8, 5: 10 }, 'Hello World', (1, 2, 3, 4, 5), [1, 2, 3, 4, 5]))
class PlayerPieces(models.Model): noOfSunkShips = models.IntegerField() # 3 of 1*1, 2 of 2*1, 1 of 4*1, 1 of 3 square L, 1 of 5 square T squares = PickledObjectField() # 0 not filled, 1 filled, 2 clicked iOfSquaresOfType = PickledObjectField( ) # Numbering for 1 and 2 is done from L to R jOfSquaresOfType = PickledObjectField() squaresLeft = PickledObjectField( ) # Each type indexes into squaresLeft. 1 1 1 2 2 3 4 5
class Survey(models.Model): id = models.CharField(max_length=64, primary_key=True) completed = models.BooleanField(default=False) history = PickledObjectField(default=[]) response = PickledObjectField(default={}) skipped = models.BooleanField(default=False) api_data = PickledObjectField(default={}) def field_match(self, fieldname, value): return field_compare(self.__dict__, fieldname, value)
class Bucket(models.Model): name = models.CharField(max_length=100) custom = models.BooleanField(default=False) # TODO: make into ChoiceField type = models.CharField(max_length=10) user = models.ForeignKey('auth.User', related_name='buckets') requirement_obj = PickledObjectField() cells = PickledObjectField() class Meta: unique_together = (('name', 'user'), )
def test_protocol(self): field = PickledObjectField() self.assertNotIn('protocol', field.deconstruct()[3]) with self.settings(PICKLEFIELD_DEFAULT_PROTOCOL=3): field = PickledObjectField(protocol=4) self.assertEqual(field.deconstruct()[3].get('protocol'), 4) field = PickledObjectField(protocol=3) self.assertNotIn('protocol', field.deconstruct()[3])
class Guest(models.Model): ip = PickledObjectField(default="") game = PickledObjectField(default=dill.dumps(Game())) badges = PickledObjectField(default=dill.dumps([])) statistics = PickledObjectField(default=dill.dumps({ "games": 0, "best_days": 0, "avg_days": 0.0, "best_kills": 0, "avg_kills": 0.0, "party": 0 }))
class MarketImageInfo(models.Model): id = models.CharField(max_length=36, primary_key=True, default=make_uuid, editable=True) final_image_id = models.CharField(max_length=36) base_type = models.CharField(max_length=52) creator_id = models.CharField(max_length=36) creator = models.CharField(max_length=36) downloads = models.BigIntegerField(default=0) tags = PickledObjectField() extra_info = PickledObjectField() published = models.BooleanField(default=False)
class Reporter(models.Model): name = models.CharField(max_length=100, db_index=True, blank=False, null=False) stories_coverage = PickledObjectField() stories_trendencies = PickledObjectField() def __unicode__(self): return self.name def __str__(self): return self.__unicode__()
class InstagramUser(models.Model): """ The instagram user accounts """ username = models.CharField(max_length=30) password = models.CharField(max_length=50) fbtoken = models.CharField(max_length=300, blank=True) fbid = models.CharField(max_length=50, blank=True) access_token = models.CharField(max_length=100, blank=True) owner = models.ForeignKey(User, default=None, on_delete=models.CASCADE) fbpageid = models.CharField(max_length=50, blank=True) instagramId = models.CharField(max_length=50, blank=True) # Fields below are intended for persistent logins login_session = PickledObjectField(default=None, null=True, blank=True) username_id = PickledObjectField(default=None, null=True, blank=True)
class ActionTree(models.Model): NEW = "NEW" RUNNING = "RUNNING" FAILED = "FAILED" SUCCESS = "SUCCESS" task = models.ForeignKey(Task, on_delete=models.CASCADE, default=None) root = PickledObjectField() trees = PickledObjectField() state = models.CharField( max_length=64, default="NEW") # default = 'NEW', RUNNING, FAILED, SUCCESS
class SVMModels(models.Model): model_pickle = PickledObjectField() training_data_X = PickledObjectField() training_data_y = PickledObjectField() test_data_X = PickledObjectField() test_data_y = PickledObjectField() score = models.FloatField() random_state_int = models.IntegerField() test_size = models.FloatField() model_function_source = models.TextField() scikit_version = models.CharField(max_length=200) numpy_version = models.CharField(max_length=200) scipy_version = models.CharField(max_length=200) run_date = models.DateTimeField()
def forwards(self, orm): if VALUE_PICKLEFIELD: from picklefield.fields import PickledObjectField tmp_data = PickledObjectField(null=True, blank=True) else: tmp_data = models.TextField(null=True, blank=True) tmp_data.contribute_to_class(orm['form_designer.FormLog'], 'tmp_data') for log in orm['form_designer.FormLog'].objects.all(): log.set_data(log.tmp_data) log.save() # Deleting field 'FormLog.data' db.delete_column('form_designer_formlog', 'tmp_data')
class ProfileIPData(models.Model): id = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False) relation = models.ForeignKey('ProfileIP', on_delete=models.CASCADE, related_name='data_versions') data = models.JSONField(default=dict) version = models.IntegerField(default=0) user = models.ForeignKey(settings.AUTH_USER_MODEL, on_delete=models.CASCADE) created = models.DateTimeField(auto_now_add=True) parsed_files = PickledObjectField(default=list) extra_paths_to_parse = PickledObjectField(default=list) class Meta: ordering = ['version'] permissions = ( ('profile_management', 'Can manage profiles'), )
class Categorie(models.Model): name = models.CharField('Nom', max_length=100) tickets = PickledObjectField() supports = PickledObjectField() date = models.DateTimeField(default=timezone.now) description = models.CharField('Description', max_length=300) class Meta: ordering = [ "-date", ] unique_together = ("name", ) def __str__(self): return "{}".format(self.name)
class Export(models.Model): STATUS_CHOICES = ( ("completed", _(u"Completed")), ("pending", _(u"Pending")), ("failed", _(u"Failed")), ) app_label = models.CharField(max_length=50) model_name = models.CharField(max_length=50) status = models.CharField(_(u"status"), max_length=50, default="pending", choices=STATUS_CHOICES) result = PickledObjectField(null=True, default=None) date_created = models.DateTimeField(auto_now_add=True) date_done = models.DateTimeField(auto_now=True) #memb_app = models.ForeignKey(App, blank=True, null=True, on_delete=models.CASCADE) class Meta: app_label = 'exports' def get_absolute_url(self): return reverse('export.status', args=[self.app_label, self.model_name]) def __str__(self): return "Export for %s %s" % (self.app_label, self.model_name)
class TaskMeta(models.Model): """Task result/status.""" task_id = models.CharField(_(u"task id"), max_length=255, unique=True) status = models.CharField(_(u"task status"), max_length=50, default=states.PENDING, choices=TASK_STATE_CHOICES) result = PickledObjectField(null=True, default=None) date_done = models.DateTimeField(_(u"done at"), auto_now=True) traceback = models.TextField(_(u"traceback"), blank=True, null=True) objects = managers.TaskManager() class Meta: """Model meta-data.""" verbose_name = _(u"task meta") verbose_name_plural = _(u"task meta") db_table = "celery_taskmeta" def to_dict(self): return { "task_id": self.task_id, "status": self.status, "result": self.result, "date_done": self.date_done, "traceback": self.traceback } def __unicode__(self): return u"<Task: %s state->%s>" % (self.task_id, self.status)