class Message(Base):
__tablename__ = 'message'
id = Column(Integer, primary_key=True)
sender_id = Column(Integer)
sender_name = Column(LargeBinary(300))
sender_username = Column(LargeBinary(200))
sender_ip = Column(String(50))
recipient_id = Column(Integer, ForeignKey('user.id'))
title = Column(LargeBinary(300))
content = Column(LargeBinary(2000))
creation_time = Column(TIMESTAMP)
user = relationship(User)
@property
def serialize(self):
#Return object data in easily serializeable format
return {
'id' : self.id,
'sender_id' : self.sender_id,
'sender_name' : self.sender_name,
'sender_username' : self.sender_username,
'sender_ip' : self.sender_ip,
'recipient_id' : self.recipient_id,
'title' : self.title,
'content' : self.content,
'creation_time' : self.creation_time
}
class Picture(Base):
__tablename__ = 'pictures'
id = Column(String(16), primary_key=True, unique=True)
name = Column(String(64), nullable=False)
path = Column(String(64), server_default="", nullable=False)
caption = Column(String(255))
uid = Column(ForeignKey(u'people.id'), nullable=False)
size = Column(BIGINT)
sha1 = Column(LargeBinary(length=20))
sha256 = Column(LargeBinary(length=32))
thumbnail50x50 = Column(BLOB)
format_original = Column(
Enum('gif', 'heic', 'heif', 'ico', 'jpeg', 'mov', 'mp4', 'png', 'wmv'))
is_encrypted = Column(BOOLEAN, nullable=False, server_default="False")
duration = Column(Float)
# selected EXIF fields
compression = Column(String(16))
datetime_original = Column(TIMESTAMP)
gps_altitude = Column(Float)
geolat = Column(INTEGER)
geolong = Column(INTEGER)
height = Column(INTEGER)
make = Column(String(16))
model = Column(String(32))
orientation = Column(SMALLINT)
# Enum(u'Horizontal', u'Mirrored-h', u'Rotated-180',
# u'Mirrored-v', u'Mirrored-h-rot-270',
# u'Rotated-90', u'Mirrored-h-rot-90', u'Rotated-270')
width = Column(INTEGER)
privacy = Column(String(8), nullable=False, server_default=u'invitee')
category_id = Column(ForeignKey(u'categories.id'), nullable=False)
storage_id = Column(ForeignKey(u'storageitems.id'), nullable=False)
created = Column(TIMESTAMP, nullable=False, server_default=func.now())
modified = Column(TIMESTAMP)
status = Column(Enum('active', u'disabled'), nullable=False)
geo = [geolong / 1.0e7, geolat / 1.0e7]
owner = relationship('Person',
foreign_keys=[uid],
backref=backref('picture_uid',
cascade='all, delete-orphan'))
storage = relationship('Storage')
category = relationship('Category')
def as_dict(self):
retval = {
col.name: getattr(self, col.name)
for col in self.__table__.columns
}
if retval.get('sha1'):
retval['sha1'] = retval['sha1'].hex()
if retval.get('sha256'):
retval['sha256'] = retval['sha256'].hex()
if retval.get('thumbnail50x50'):
retval['thumbnail50x50'] = (
'data:image/%s;base64,' % retval['format_original'] +
base64.b64encode(retval['thumbnail50x50']).decode('ascii'))
return retval
def __init__(self, client, **kwargs):
'''
Initialize the sql backend after timeseries has processed the configuration.
'''
self._metadata = MetaData()
self._str_length = kwargs.get('string_length', 255)
self._txt_length = kwargs.get('text_length', 32 * 1024)
vtype = kwargs.get('value_type', float)
if vtype in TYPE_MAP:
self._value_type = TYPE_MAP[vtype]
if self._value_type == String:
self._value_type = String(self._str_length)
elif self._value_type == Text:
self._value_type = Text(self._txt_length)
elif self._value_type == LargeBinary:
self._value_type = LargeBinary(self._txt_length)
elif issubclass(vtype, TypeEngine):
if vtype == String:
self._value_type = String(self._str_length)
elif vtype == Text:
self._value_type = Text(self._txt_length)
elif vtype == LargeBinary:
self._value_type = LargeBinary(self._txt_length)
elif isinstance(vtype, TypeEngine):
self._value_type = vtype
else:
raise ValueError("Unsupported type '%s'" % (vtype))
self._table_name = kwargs.get('table_name', self._table_name)
super(SqlBackend, self).__init__(client, **kwargs)
class BlockTransaction(Base):
query = Session.query_property()
__tablename__ = "blocktransaction"
__table_args__ = (
Index(
"ix_blocktransaction_idx_block_header_hash",
"idx",
"block_header_hash",
unique=True,
),
Index(
"ix_block_header_hash_transaction_hash",
"block_header_hash",
"transaction_hash",
unique=True,
),
)
idx = Column(Integer, nullable=False)
block_header_hash = Column(LargeBinary(32),
ForeignKey("block.header_hash"),
primary_key=True)
transaction_hash = Column(LargeBinary(32),
ForeignKey("transaction.hash"),
primary_key=True)
block = relationship("Block")
transaction = relationship("Transaction")
class DbCacheTransactionNode(Base):
"""
Link table for cache transactions and addresses
"""
__tablename__ = 'cache_transactions_node'
txid = Column(LargeBinary(32), ForeignKey('cache_transactions.txid'), primary_key=True)
transaction = relationship("DbCacheTransaction", back_populates='nodes', doc="Related transaction object")
index_n = Column(Integer, primary_key=True, doc="Order of input/output in this transaction")
value = Column(BigInteger, default=0, doc="Value of transaction input")
address = Column(String(255), index=True, doc="Address string base32 or base58 encoded")
script = Column(LargeBinary, doc="Locking or unlocking script")
witnesses = Column(LargeBinary, doc="Witnesses (signatures) used in Segwit transaction inputs")
sequence = Column(BigInteger, default=0xffffffff,
doc="Transaction sequence number. Used for timelock transaction inputs")
is_input = Column(Boolean, primary_key=True, doc="True if input, False if output")
spent = Column(Boolean, default=None, doc="Is output spent?")
ref_txid = Column(LargeBinary(32), index=True, doc="Transaction hash of input which spends this output")
ref_index_n = Column(BigInteger, doc="Index number of transaction input which spends this output")
def prev_txid(self):
if self.is_input:
return self.ref_txid
def output_n(self):
if self.is_input:
return self.ref_index_n
def spending_txid(self):
if not self.is_input:
return self.ref_txid
def spending_index_n(self):
if not self.is_input:
return self.ref_index_n
class Account(Base):
__tablename__ = "account"
uid = Column(Integer, primary_key=True)
username = Column(String(32), nullable=False, unique=True)
email_address = Column(String(128), nullable=False, unique=True)
password_hash = Column(LargeBinary(128), nullable=False)
password_salt = Column(LargeBinary(16), nullable=False)
student = relationship("Student", backref="account", uselist=False)
faculty = relationship("Faculty", backref="account", uselist=False)
@property
def pw_hash(self):
h = None
try:
h = self.password_hash.tobytes()
except AttributeError:
h = self.password_hash
return h
@property
def pw_salt(self):
s = None
try:
s = self.password_salt.tobytes()
except AttributeError:
s = self.password_salt
return s
class DbCacheBlock(Base):
"""
Block Cache Table
Stores block headers
"""
__tablename__ = 'cache_blocks'
height = Column(Integer,
primary_key=True,
doc="Height or sequence number for this block")
block_hash = Column(LargeBinary(32), index=True, doc="Hash of this block")
network_name = Column(String(20), doc="Blockchain network name")
version = Column(
BigInteger,
doc="Block version to specify which features are used (hex)")
prev_block = Column(LargeBinary(32), doc="Block hash of previous block")
merkle_root = Column(
LargeBinary(32),
doc="Merkle root used to validate transaction in block")
time = Column(BigInteger,
doc="Timestamp to indicated when block was created")
bits = Column(
BigInteger,
doc=
"Encoding for proof-of-work, used to determine target and difficulty")
nonce = Column(
BigInteger,
doc=
"Nonce (number used only once or n-once) is used to create different block hashes"
)
tx_count = Column(Integer,
doc="Number of transactions included in this block")
class BlockUncle(Base):
query = Session.query_property()
__tablename__ = "blockuncle"
__table_args__ = (
Index(
"ix_blockuncle_idx_block_header_hash",
"idx",
"block_header_hash",
unique=True,
),
Index(
"ix_block_header_hash_uncle_hash",
"block_header_hash",
"uncle_hash",
unique=True,
),
)
idx = Column(Integer, nullable=False)
block_header_hash = Column(LargeBinary(32),
ForeignKey("block.header_hash"),
primary_key=True)
uncle_hash = Column(LargeBinary(32),
ForeignKey("header.hash"),
primary_key=True)
block = relationship("Block")
uncle = relationship("Header")
class Usuario(Base):
def __init__(self, nombre, email, contrasenia):
self.nombre = nombre
self.email = email
self.__clave = Fernet.generate_key()
self.__clave.decode()
self.__token = self.__encrypt(contrasenia.encode(), self.__clave)
def get_contrasenia(self):
contrasenia_desencriptada = self.__decrypt(self.__token, self.__clave)
contrasenia_desencriptada = contrasenia_desencriptada.decode("utf-8")
return contrasenia_desencriptada
def __encrypt(self, message: bytes, key: bytes) -> bytes:
return Fernet(key).encrypt(message)
def __decrypt(self, token: bytes, key: bytes) -> bytes:
return Fernet(key).decrypt(token)
__tablename__ = 'usuario'
id = Column(Integer, primary_key=True, index=True, nullable=False)
nombre = Column(String(15), index=True, nullable=False)
email = Column(EmailType)
__clave = Column(LargeBinary(2048), nullable=False)
__token = Column(LargeBinary(2048), nullable=False)
class Receipt(Base):
query = Session.query_property()
__tablename__ = "receipt"
transaction_hash = Column(LargeBinary(32),
ForeignKey("transaction.hash"),
primary_key=True)
transaction = relationship("Transaction", back_populates="receipt")
state_root = Column(LargeBinary(32), nullable=False)
gas_used = Column(BigInteger, nullable=False)
_bloom = Column(LargeBinary(1024), nullable=False)
logs = relationship("Log", back_populates="receipt", order_by="Log.idx")
@property
def bloom(self) -> int:
return big_endian_to_int(self._bloom)
@bloom.setter
def bloom(self, value: int) -> None:
self._bloom = int_to_big_endian(value)
@classmethod
def from_ir(cls, receipt_ir: ReceiptIR,
transaction_hash: Hash32) -> "Receipt":
return cls(
transaction_hash=transaction_hash,
state_root=receipt_ir.state_root,
gas_used=receipt_ir.gas_used,
_bloom=receipt_ir.bloom,
)
class LogTopic(Base):
query = Session.query_property()
__tablename__ = "logtopic"
__table_args__ = (
UniqueConstraint("idx",
"log_receipt_hash",
"log_idx",
name="ix_idx_log_receipt_hash_log_idx"),
Index(
"ix_idx_topic_topic_log_receipt_hash_log_idx",
"idx",
"topic_topic",
"log_receipt_hash",
"log_idx",
),
ForeignKeyConstraint(("log_idx", "log_receipt_hash"),
("log.idx", "log.receipt_hash")),
)
__mapper_args__ = {"confirm_deleted_rows": False}
id = Column(Integer, primary_key=True)
idx = Column(Integer, nullable=False)
topic_topic = Column(LargeBinary(32),
ForeignKey("topic.topic"),
index=True,
nullable=False)
log_idx = Column(Integer, nullable=False)
log_receipt_hash = Column(LargeBinary(32), nullable=False)
topic = relationship("Topic")
log = relationship("Log", foreign_keys=[log_idx, log_receipt_hash])
class Thing(base):
__tablename__ = 'things'
thing_key = Column(String(255), primary_key=True)
owner_id = Column(Integer(), ForeignKey('users.user_id'))
thing_data = Column(LargeBinary(65535))
thing_data_checksum = Column(LargeBinary(65535))
encrypted = Column(Boolean())
class User(Base):
#Table
__tablename__ = 'user'
#Mapper
id = Column(Integer, primary_key=True)
name = Column(LargeBinary(300))
username = Column(LargeBinary(200))
password_hash = Column(String(120))
security_question = Column(LargeBinary(300))
security_question_answer_hash = Column(String(120))
def hash_password(self, password):
self.password_hash = pwd_context.encrypt(password)
def verify_password(self, password):
return pwd_context.verify(password, self.password_hash)
def hash_passw_phrase_answer(self, security_question_answer):
self.security_question_answer_hash = pwd_context.encrypt(security_question_answer)
def verify_passw_phrase_answer(self, security_question_answer):
return pwd_context.verify(security_question_answer, self.security_question_answer_hash)
@property
def serialize(self):
#Return object data in easily serializeable format
return {
'id' : self.id,
'name' : self.name,
'username' : self.username,
'password_hash' : self.password_hash,
'security_question' : self.security_question,
'security_question_answer_hash' : self.security_question_answer_hash
}
class JCDFLOWSAVE(Base):
__tablename__ = 'jcdflowsave'
id = Column(Integer, primary_key=True)
now_time = Column(String(40))
request = Column(LargeBinary())
response = Column(LargeBinary())
path = Column(String(100))
status = Column(Boolean)
class Parameters(Base):
__tablename__ = 'parameters'
id = Column(Integer, primary_key=True)
parameters_id = Column(Integer, ForeignKey('training_data.id'))
layer = Column(String(30))
arr_param = Column(LargeBinary(length=(2 ** 32) - 1))
arr_grad = Column(LargeBinary(length=(2 ** 32) - 1))
class PerfProfile(Model):
__tablename__ = "perf_profiles"
__table_args__ = (Index("perf_trace_created_on_idx", "created_on"), )
uuid = Column(String(length=36), primary_key=True)
plop_input = Column(LargeBinary(length=1000000), nullable=False)
flamegraph_input = Column(LargeBinary(length=1000000), nullable=False)
created_on = Column(DateTime, default=datetime.utcnow, nullable=False)
class UsbDevice(base):
id = Column(Integer, primary_key=True)
base_id = Column(Integer, ForeignKey('device.id'))
vendor_id = Column(LargeBinary(length=2))
product_id = Column(LargeBinary(length=2))
base_device = relationship(
"Device", back_populates="usb", single_parent=True)
class Word(Module):
__tablename__ = "word"
id = Column(BigInteger, primary_key=True, comment="单词ID")
english = Column(String(256), unique=True, nullable=False, comment="英文")
chinese = Column(String(256), nullable=False, comment="中文")
phonetic_symbol = Column(String(256), comment="英标")
img = Column(LargeBinary(length=2**16), comment="图片，二进制存储")
audio = Column(LargeBinary(length=2**16), comment="音频，二进制存储")
class User(db.Model):
__tablename__ = "user"
id = Column(Integer, primary_key=True, autoincrement=True)
email = Column(String(50), unique=True, nullable=False)
password_hash = Column(LargeBinary(128), unique=True, nullable=False)
password_salt = Column(LargeBinary(128), unique=True, nullable=False)
auth_token = Column(String(50), unique=True, nullable=True)
@property
def password(self):
raise AttributeError("password not readable")
@password.setter
def password(self, password: str):
salt = bcrypt.gensalt()
password_bytes = bytes(password, "utf-8")
self.password_salt = salt
self.password_hash = bcrypt.hashpw(password_bytes, salt)
def validate_password(self, password: str) -> bool:
password_bytes = bytes(password, "utf-8")
password_hash = bcrypt.hashpw(password_bytes, self.password_salt)
is_valid = safe_str_cmp(password_hash, self.password_hash)
return is_valid
def messages(
self,
status: MessageFetchRequestStatus,
inbox_outbox: Literal["inbox", "outbox"],
) -> Query:
query: Query = MessagesUsers.query.join(MessagesUsers.message).filter(
MessagesUsers.viewer_id == self.id
)
if inbox_outbox == "inbox":
query = query.filter(Message.receiver_id == self.id)
elif inbox_outbox == "outbox":
query = query.filter(Message.sender_id == self.id)
else:
raise ValueError(f"Wrong value for {inbox_outbox=}")
if status == MessageFetchRequestStatus.all_read:
query = query.filter(Message.is_read == True)
elif status == MessageFetchRequestStatus.all_unread:
query = query.filter(Message.is_read == False)
return query
@classmethod
def get_by_id(cls, user_id: str) -> Optional["User"]:
return cls.query.filter(User.id == user_id).first()
@classmethod
def get_by_email(cls, email: str) -> Optional["User"]:
return cls.query.filter(User.email == email).first()
@classmethod
def get_by_token(cls, auth_token: str) -> Optional["User"]:
return cls.query.filter(auth_token == User.auth_token).first()
class ExampleSentence(Module):
__tablename__ = "example_sentence"
id = Column(BigInteger, primary_key=True, comment="单词例句ID")
word_id = Column(BigInteger, ForeignKey("word.id", ondelete="CASCADE"), index=True, nullable=False, comment="单词ID")
word = relationship("Word", backref="*example_sentence_from_word*")
english = Column(Text, comment="例句英文")
chinese = Column(Text, comment="例句中文")
img = Column(LargeBinary(length=2**16), comment="图片，二进制存储")
audio = Column(LargeBinary(length=(2**32)-1), comment="音频，二进制存储")
class Log(Base):
query = Session.query_property()
__tablename__ = "log"
__table_args__ = (UniqueConstraint("idx",
"receipt_hash",
name="ix_idx_receipt_hash"), )
id = Column(Integer, primary_key=True)
idx = Column(Integer, nullable=False)
receipt_hash = Column(
LargeBinary(32),
ForeignKey("receipt.transaction_hash"),
index=True,
nullable=False,
)
receipt = relationship("Receipt", back_populates="logs")
address = Column(LargeBinary(20), index=True, nullable=False)
topics = relationship("Topic", secondary="logtopic", order_by=LogTopic.idx)
data = Column(LargeBinary, nullable=False)
def __repr__(self) -> str:
return (f"Log("
f"idx={self.idx!r}, "
f"receipt_hash={self.receipt_hash!r}, "
f"address={self.address!r}, "
f"data={self.data!r}, "
f"topics={self.topics!r}"
f")")
def __str__(self) -> str:
# TODO: use eth_utils.humanize_bytes once it is released
if len(self.data) > 4:
pretty_data = humanize_hash(Hash32(self.data))
else:
pretty_data = self.data.hex()
if len(self.topics) == 0: # type: ignore
pretty_topics = "(anonymous)"
else:
pretty_topics = "|".join((
humanize_hash(Hash32(topic.topic))
for topic in self.topics # type: ignore
))
return f"Log[#{self.idx} A={humanize_hash(self.address)} D={pretty_data}/T={pretty_topics}]" # type: ignore # noqa: E501
@classmethod
def from_ir(cls, log_ir: LogIR, idx: int, receipt_hash: Hash32) -> "Log":
return cls(idx=idx,
receipt_hash=receipt_hash,
address=log_ir.address,
data=log_ir.data)
class User(Base, _Exportable):
__tablename__ = 'users'
__summary_keys__ = ['id', 'name', 'created', 'admin']
id = Column(String, primary_key=True)
name = Column(String, nullable=False)
salt = Column(LargeBinary(32), nullable=False)
password = Column(LargeBinary(32), nullable=False)
admin = Column(Boolean, server_default='False')
created = Column(DateTime(timezone=True),
server_default=func.now(),
nullable=False)
class User(BASE):
'''
AraoSecret user.
'''
__tablename__ = 'user'
id = Column('id', Integer, primary_key=True)
alias = Column(String(32), nullable=False, unique=True)
email = Column(String(128), nullable=False)
email_validated = Column(Boolean, default=False)
pass_hash = Column(LargeBinary(64), nullable=False)
rsa_key = Column(LargeBinary(3310), nullable=False)
rsa_key_pub = Column(LargeBinary(799), nullable=False)
def __init__(self, alias, email, password):
self.alias = alias
self.email = email
self.pass_hash = arao_secret.helper.get_pass_hash(password)
# RSA
rsa_key = RSA.generate(4096)
self.rsa_key = rsa_key.exportKey(passphrase=password)
self.rsa_key_pub = rsa_key.publickey().exportKey()
# TODO : Clean rsa_key from memory
def __repr__(self):
return '{}, {}'.format(self.id, self.alias)
def decrypt(self, password, text_enc):
rsa_key = RSA.importKey(self.rsa_key, passphrase=password)
text = rsa_key.decrypt(text_enc)
# TODO : Clean rsa_key from memory
return text
def encrypt(self, text):
rsa_key = RSA.importKey(self.rsa_key_pub)
text_enc = rsa_key.encrypt(text, None)[0]
SecureString.clearmem(text)
return text_enc
def get_group(self, id):
'''
Get Group, Group key tuple.
'''
for group_key in self.group_keys:
if group_key.group.id == id:
return group_key.group, group_key
return None
def get_groups(self):
groups = list()
for group_key in self.group_keys:
groups.append(group_key.group)
# TODO : Sort by name
return groups
class User(base):
__tablename__ = 'users'
user_id = Column(Integer(), primary_key=True)
user_name = Column(String(32), unique=True)
password_hash = Column(LargeBinary(64))
password_salt = Column(LargeBinary(64))
encryption_salt = Column(LargeBinary(64))
email = Column(
String(254)
) # Apparently the maximum usable email address length, see https://7php.com/the-maximum-length-limit-of-an-email-address-is-254-not-320/#:~:text=there%20is%20a%20length%20limit,total%20length%20of%20320%20characters.
things = backref("Thing", back_populates="owner")
def test_binary_types(self):
specs = [
(LargeBinary(3), mysql.TINYBLOB()),
(LargeBinary(), mysql.BLOB()),
(mysql.MSBinary(3), mysql.MSBinary(3)),
(mysql.MSVarBinary(3), mysql.MSVarBinary(3)),
(mysql.MSTinyBlob(), mysql.MSTinyBlob()),
(mysql.MSBlob(), mysql.MSBlob()),
(mysql.MSBlob(1234), mysql.MSBlob()),
(mysql.MSMediumBlob(), mysql.MSMediumBlob()),
(mysql.MSLongBlob(), mysql.MSLongBlob()),
]
self._run_test(specs, [])
class Frame(Base):
__tablename__ = "local_features_frame"
id = Column('id', Integer, primary_key=True)
video_id = Column('video_id',
Integer,
ForeignKey(Video.id),
nullable=False)
frame_number = Column('frame_number', Integer, nullable=False)
key_points = Column('key_points', LargeBinary((2**32) - 1), nullable=False)
descriptors = Column('descriptors',
LargeBinary((2**32) - 1),
nullable=False)
video = relationship(Video)
class LogTopic(Base):
query = Session.query_property()
__tablename__ = "logtopic"
__table_args__ = (
UniqueConstraint(
"idx",
"log_idx",
"log_transaction_hash",
"log_block_header_hash",
name="ix_idx_log_idx_log_transaction_hash_log_block_header_hash",
),
Index(
"ix_idx_topic_topic_log_idx_log_transaction_hash_log_block_header_hash",
"idx",
"topic_topic",
"log_idx",
"log_transaction_hash",
"log_block_header_hash",
),
ForeignKeyConstraint(
("log_idx", "log_transaction_hash", "log_block_header_hash"),
("log.idx", "log.transaction_hash", "log.block_header_hash"),
),
CheckConstraint("idx >= 0 AND idx <= 3",
name="_limit_4_topics_per_log"),
)
__mapper_args__ = {"confirm_deleted_rows": False}
idx = Column(Integer, nullable=False, primary_key=True)
topic_topic = Column(LargeBinary(32),
ForeignKey("topic.topic"),
index=True,
nullable=False)
log_idx = Column(Integer, nullable=False, primary_key=True)
log_transaction_hash = Column(LargeBinary(32),
nullable=False,
index=True,
primary_key=True)
log_block_header_hash = Column(LargeBinary(32),
nullable=False,
index=True,
primary_key=True)
topic = relationship("Topic")
log = relationship(
"Log",
foreign_keys=[log_idx, log_transaction_hash, log_block_header_hash])
class Variable(Base):
__tablename__ = "pyri_variables"
__table_args__ = (UniqueConstraint('name', 'device', name='_unique_var'), )
id = Column(Integer(), primary_key=True)
name = Column(String(512), index=True)
device = Column(String(128))
datatype = Column(String(128))
value = Column(LargeBinary())
reset_value = Column(LargeBinary(), default=None)
persistence = Column(Integer(), default=VariablePersistence.TEMPORARY)
default_protection = Column(Integer(),
default=VariableProtectionLevel.READ_WRITE)
doc = Column(Text())
created_on = Column(LargeBinary()) # com.robotraconteur.datetime.TimeSpec2
updated_on = Column(LargeBinary()) # com.robotraconteur.datetime.TimeSpec2
class TimestampSequencedWithIDRecord(Base):
__tablename__ = "timestamp_sequenced_items"
# Record ID.
id = Column(
BigInteger().with_variant(Integer, "sqlite"),
primary_key=True,
index=True,
unique=True,
autoincrement=True,
)
# Sequence ID (e.g. an entity or aggregate ID).
sequence_id = Column(UUIDType(), nullable=False)
# Position (timestamp) of item in sequence.
position = Column(DECIMAL(24, 6, 6), nullable=False, unique=False)
# Topic of the item (e.g. path to domain event class).
topic = Column(Text(), nullable=False)
# State of the item (serialized dict, possibly encrypted).
state = Column(LargeBinary())
__table_args__ = (
Index(
"timestamp_sequenced_items_sequence_id_position_index",
"sequence_id",
"position",
unique=True,
),
Index("timestamp_sequenced_items_position_index", "position", unique=False),
)
class Resource(Base, ColumnPrinterMixin):
__tablename__ = 'resources'
resource_id = Column(Integer,
Sequence('resource_id_seq'),
primary_key=True,
unique=True) # type: ResourceID
resource_name = Column(String(255), unique=True,
nullable=False) # type: ResourceName
resource_size = Column(BigInteger) # type: ResourceSize
resource_payloadsize = Column(BigInteger) # type: ResourcePayloadSize
resource_hash = Column(LargeBinary(64), unique=True) # type: ResourceHash
wrapping_type = Column(String(255)) # type: ResourceWrappingType
compression_type = Column(String(255)) # type: ResourceCompressionType
__table_args__ = (UniqueConstraint('resource_name', 'resource_hash'), )
def __init__(self, resource_name, resource_size, resource_payloadsize,
resource_hash, wrapping_type, compression_type):
# type: (ResourceName, ResourceSize, ResourcePayloadSize, ResourceHash, ResourceWrappingType, ResourceCompressionType) -> None
self.resource_name = resource_name # name of uploaded file/image/...
self.resource_size = resource_size # the size of the uploaded resource
self.resource_payloadsize = resource_payloadsize # the size of the uploaded resource, without encapsulation
self.resource_hash = resource_hash # the hash of the uploaded resource, for checking correct download
self.wrapping_type = wrapping_type # used for extraction of block payload from resource
self.compression_type = compression_type # used for extraction of block payload from resource
@classmethod
def makeResourceHash(cls, resource_data):
# type: (bytes) -> ResourceHash
return ResourceHash(hashlib.sha256(resource_data).digest())