class Provider(models.Base):
id = fields.IntField()
endpoint = fields.StringField(required=True)
type = fields.StringField(required=True)
available = fields.BoolField(required=True)
available_at = fields.DateTimeField(required=True)
available_expires_at = fields.DateTimeField(required=True)
created_at = fields.DateTimeField(required=True)
tasks = fields.EmbeddedField(ProviderMetrics, required=True)
open_tasks = fields.EmbeddedField(ProviderOpenMetrics, required=True)
sent_tasks = fields.EmbeddedField(ProviderMetrics, required=True)
stats = fields.EmbeddedField(ProviderStats, required=True)
@staticmethod
def build(json):
return Provider(
id = json["id"],
endpoint = json["endpoint"],
type = json["type"],
available = json["available"],
available_at = json["available_at"],
available_expires_at = json["available_expires_at"],
created_at = json["created_at"],
tasks = ProviderMetrics.build(json["tasks"]),
open_tasks = ProviderOpenMetrics.build(json["open_tasks"]),
sent_tasks = ProviderMetrics.build(json["sent_tasks"]),
stats = ProviderStats.build(json["stats"])
)
class BaseModel(Model):
__tablename__ = "BaseModel"
last_update = fields.DateTimeField(required=True)
created_at = fields.DateTimeField(required=True)
def __init__(self, eid=0, *args, **kwargs):
self.eid = eid
self.last_update = datetime.utcnow()
self.created_at = datetime.utcnow()
super(BaseModel, self).__init__(*args, **kwargs)
@property
def location(self):
return "Earth"
@property
def id(self):
return self.eid
def created_at_datetime(self):
return self.created_at
def save(self):
table = self.Meta.database.table(self.__tablename__)
print("UPDATE: ", table.update(self.to_struct(), eids=[self.eid]))
def insert(self):
table = self.Meta.database.table(self.__tablename__)
newid = table.insert(self.to_struct())
if newid > 0:
print("EID: ", newid)
self.eid = newid
else:
print("Failed to get eid for the new insert record")
class Instantiated(object):
id = fields.IntField(required=True)
created_at = fields.DateTimeField()
# Creation time. This field is read only.
updated_at = fields.DateTimeField()
# Time of last update. This field is read only.
def __str__(self):
return "id='{}'".format(self.id)
class Grouping(models.Base):
groupKey = fields.EmbeddedField(GroupKey, required=True)
groupKeyShortLabel = fields.EmbeddedField(GroupKeyShortLabel,
required=True)
explanation = fields.ListField([fields.StringField()], required=True)
debug = fields.EmbeddedField([fields.StringField()], required=True)
dateTime = fields.DateTimeField(required=True)
def test_datetime_field_to_struct():
field = fields.DateTimeField()
assert field.str_format is None
tt = datetime.datetime(2014, 5, 7, 12, 45, 56)
assert '2014-05-07T12:45:56' == field.to_struct(tt)
class Person(models.Base):
name = fields.StringField(default=default_name)
age = fields.IntField(default=default_age)
height = fields.FloatField(default=default_height)
job = fields.EmbeddedField(Job, default=default_job)
hobbies = fields.ListField(items_types=str, default=default_hobbies)
last_ate = fields.TimeField(default=default_last_ate)
birthday = fields.DateField(default=default_birthday)
time_of_death = fields.DateTimeField(default=default_time_of_death)
def test_datetime_field_to_struct_with_tz():
field = fields.DateTimeField()
tt = datetime.datetime(2014, 5, 7, 12, 45, 56, tzinfo=_TestCet())
assert '2014-05-07T12:45:56+02:00' == field.to_struct(tt)
tt = datetime.datetime(2014, 5, 7, 12, 45, 56, tzinfo=_TestUtc())
assert '2014-05-07T12:45:56+00:00' == field.to_struct(tt)
class User(models.Base):
name = fields.StringField()
email = fields.StringField(required=True)
wallet = fields.StringField(required=True)
created_at = fields.DateTimeField(required=True)
@staticmethod
def build(json):
return User(name=json["name"],
email=json["email"],
wallet=json["wallet"],
created_at=json["created_at"])
def test_datetime_field_parse_value():
field = fields.DateTimeField()
assert (datetime.datetime(2014, 4, 21, 12, 45,
56) == field.parse_value('2014-04-21T12:45:56'))
assert (datetime.datetime(
2014, 4, 21, 12, 45, 56, tzinfo=tzoffset(
None, 7200)) == field.parse_value('2014-04-21T12:45:56+02:00'))
with pytest.raises(ValueError):
field.parse_value('not a datetime')
def test_datetime_field():
field = fields.DateTimeField()
class Event(models.Base):
when = field
event = Event()
assert event.when is None
event.when = datetime.datetime(2019, 10, 30, 1, 2, 3)
assert field.toBsonEncodable(event.when) == \
datetime.datetime(2019, 10, 30, 1, 2, 3)
assert event.when == datetime.datetime(2019, 10, 30, 1, 2, 3)
assert field.parse_value("2019-10-30T01:02:03.000000Z") == \
datetime.datetime(2019, 10, 30, 1, 2, 3, tzinfo=timezone.utc)
class App(models.Base):
id = fields.IntField(required=True)
slug = fields.StringField(required=True)
versions = fields.IntField()
name = fields.StringField(required=True)
description = fields.StringField(required=True)
description_short = fields.StringField(required=True)
created_at = fields.DateTimeField(required=True)
tasks = fields.EmbeddedField(AppMetrics, required=True)
@staticmethod
def build(json):
return App(
id = json["id"],
slug = json["slug"],
versions = json["versions"],
name = json["name"],
description = json["description"]["plain"],
description_short = json["description"]["plain"].strip().split(".")[0][0:70] + ".",
created_at = json["created_at"],
tasks = AppMetrics.build(json["tasks"])
)
class Model(models.Base):
app_id = fields.IntField(required=True)
version = fields.IntField(required=True)
input_scheme = None
output_scheme = None
created_at = fields.DateTimeField(required=True)
urls = fields.EmbeddedField(ModelUrls, required=True)
tasks = fields.EmbeddedField(ModelMetrics, required=True)
stats = fields.EmbeddedField(ModelStats, required=True)
@staticmethod
def build(json):
model = Model(
app_id = json["app_id"],
version = json["version"],
urls = ModelUrls.build(json["urls"]),
created_at = json["created_at"],
tasks = ModelMetrics.build(json["tasks"]),
stats = ModelStats.build(json["stats"])
)
model.input_scheme = json["schemes"]["input"]
model.output_scheme = json["schemes"]["output"]
return model
class Event(models.Base):
time = fields.TimeField()
date = fields.DateField()
end = fields.DateTimeField()
def test_datetime_field_is_none():
"""If field nullable, dateutil raises error"""
datetime_field = fields.DateTimeField()
assert datetime_field.parse_value(None) is None
def test_datetime_field_format_has_precedence():
field = fields.DateTimeField(str_format='%H:%M %Y/%m')
tt = datetime.datetime(2014, 5, 7, 12, 45, 56, tzinfo=_TestCet())
assert '12:45 2014/05' == field.to_struct(tt)
class Model(Base):
__metaclass__ = ModelMeta
"""Firestore Models all inherit from jsonmodels.models.Base.\n
This is exposed as `from firestore_orm import model`.
Arguments:
Base {:class:`jsonmodels.models.Base`} -- To create models you need to create class that inherits from :class:`jsonmodels.models.Base`.\n
For more details, refer to https://jsonmodels.readthedocs.io/en/latest/usage.html.\n
__tablename__ {str} -- Collection name of model in firestore
Keyword Arguments:
metaclass {:class:`firestore_orm.models.ModelMeta`} -- (default: {ModelMeta})
Example:
.. code-block:: python
from jsonmodels import fields
from firestorm import model, utils
class Pet(model.Model):
__tablename__ = 'pet'
name = fields.StringField(required=True)
class Person(model.Model):
__tablename__ = 'person'
name = fields.StringField(required=True)
surname = fields.StringField(nullable=False)
age = fields.FloatField()
pet_id = fields.StringField(required=True)
def __init__(self, **kwargs):
super(Person, self).__init__(**kwargs)
self.pet = utils.relationship(self, Pet, 'pet_id')
Usage:
After that you can use it as normal object.\n
You can pass kwargs in constructor or :meth:`jsonmodels.models.PreBase.populate` method.
.. code-block:: python
>>> pet = Pet(name='Katty')
>>> pet.id
'26b353d6-f5a1-4a38-b61a-b9371de5b92f'
>>> pet.save() # save to firestore
>>> person = Person(name='Chuck', pet_id=pet.id)
>>> person.name
'Chuck'
>>> person.surname
None
>>> person.populate(surname='Norris', age=20)
>>> person.surname
'Norris'
>>> person.name
'Chuck'
>>> person.id
'1286f8ae-710f-4fb7-a804-31fbed525390'
>>> person.save() # save to firestore
>>> Person.query.fetch()
[Person(created_at=datetime.datetime(2019, 3, 24, 13, 57, 21, 761746), name='Chuck', surname='Norris', age=20, pet_id='26b353d6-f5a1-4a38-b61a-b9371de5b92f', id='1286f8ae-710f-4fb7-a804-31fbed525390')]
>>> Person.query.get('1286f8ae-710f-4fb7-a804-31fbed525390')
Person(created_at=datetime.datetime(2019, 3, 24, 13, 57, 21, 761746), name='Chuck', surname='Norris', age=20, pet_id='26b353d6-f5a1-4a38-b61a-b9371de5b92f', id='1286f8ae-710f-4fb7-a804-31fbed525390')
>>> person = Person.query.get('1286f8ae-710f-4fb7-a804-31fbed525390')
>>> person.pet
'Pet(created_at=datetime.datetime(2019, 3, 24, 13, 57, 21, 761746), name='Katty', id='26b353d6-f5a1-4a38-b61a-b9371de5b92f')'
Filter
--------
You can filter the results of a query using the following functions
.. code-block:: python
>>> Person.query.fetch(filters=[('name', '==', 'Chuck'), ('age', '<=', 20)])
[Person(created_at=datetime.datetime(2019, 3, 24, 13, 57, 21, 761746), name='Chuck', surname='Norris', age=20, pet_id='26b353d6-f5a1-4a38-b61a-b9371de5b92f', id='1286f8ae-710f-4fb7-a804-31fbed525390')]
Order by
---------
You can also order the results of a query
.. code-block:: python
>>> Person.query.fetch(order_by={"population": 'DESCENDING'}) # orders query by DESCENDING order: set to `ASCENDING` for ascending order
"""
hidden_fields = ['password', 'is_deleted']
show_relationships = []
__tablename__ = None
id = fields.StringField() # type: StringField
created_at = fields.DateTimeField()
def __init__(self, *args, **kwargs):
super(Model, self).__init__(*args, **kwargs)
self.id = uuid.uuid4().__str__() if not self.id else self.id
def save(self):
# type: () -> bool
"""Save model instance to firestore
"""
return self.query.commit(self.id, self)
@classmethod
def __call__(cls, *args, **kw):
constructor = getattr(cls, "__new__")
instance = constructor(
cls) if constructor is object.__new__ else constructor(cls, *args, **kw)
instance.__init__(cls, *args, **kw)
return instance
def to_dict(self, show=None, hide=None):
# type: (list, list) -> dict
""" Return a dictionary representation of this model.
"""
if hide is None:
hide = []
if show is None:
show = []
hidden = []
if hasattr(self, 'hidden_fields'):
hidden = self.hidden_fields
hidden.extend(hide)
resp = {}
for _, name, field in self.iterate_with_name():
value = field.__get__(self)
if name not in show and name in hidden:
continue
if value is None:
resp[name] = None
continue
value = field.to_struct(value)
resp[name] = value
# jsonify relationships
for key in self.show_relationships:
val = getattr(self, key) # type: Model
if not val or not isinstance(val, Base):
continue
resp[key] = val.to_dict()
return resp
def delete(self):
return self.query.delete(self)
class Event(models.Base):
date = fields.DateTimeField()
class Event(models.Base):
start = fields.DateTimeField()
