def get_file(self, md5_digest, file_size, cls): row = self._db_query(self.SentFile, self.SentFile.md5_digest == md5_digest, self.SentFile.file_size == file_size, self.SentFile.type == _SentFileType.from_type( cls).value).one_or_none() return (row.id, row.hash) if row else None
def get_file(self, md5_digest: str, file_size: int, cls: Any) -> Optional[Tuple[int, int]]: row = self._db_query(self.SentFile, self.SentFile.md5_digest == md5_digest, self.SentFile.file_size == file_size, self.SentFile.type == _SentFileType.from_type( cls).value).one_or_none() return (row.id, row.hash) if row else None
def get_file(self, md5_digest, file_size, cls): sentfile_container = self.get_sent_file_container() query = "SELECT * FROM c WHERE c.md5_digest='{}' AND c.file_size={} AND c.type='{}'".format( md5_digest, file_size, _SentFileType.from_type(cls).value ) for item in sentfile_container.query_items(query, enable_cross_partition_query=True): return item['id'], item['hash']
def get_file(self, md5_digest, file_size, cls): with switch_db(SentFile, self.database) as _SentFile: row = _SentFile.objects( md5_digest=md5_digest, file_size=file_size, type=_SentFileType.from_type(cls).value).first() if row: return cls(row.id, row.hash)
def cache_file(self, md5_digest, file_size, instance): if not isinstance(instance, (InputDocument, InputPhoto)): raise TypeError("Cannot cache %s instance" % type(instance)) self.db.merge( self.SentFile(session_id=self.session_id, md5_digest=md5_digest, type=_SentFileType.from_type(type(instance)).value, id=instance.id, hash=instance.access_hash)) self.save()
def cache_file(self, md5_digest, file_size, instance): with switch_db(SentFile, self.database) as _SentFile: if not isinstance(instance, (InputDocument, InputPhoto)): raise TypeError('Cannot cache %s instance' % type(instance)) _SentFile(md5_digest=md5_digest, file_size=file_size, type=_SentFileType.from_type(type(instance)).value, id=instance.id, hash=instance.access_hash).save()
def cache_file(self, md5_digest: str, file_size: int, instance: Union[InputDocument, InputPhoto]) -> None: if not isinstance(instance, (InputDocument, InputPhoto)): raise TypeError("Cannot cache {} instance".format(type(instance))) self.db.merge( self.SentFile(session_id=self.session_id, md5_digest=md5_digest, file_size=file_size, type=_SentFileType.from_type(type(instance)).value, id=instance.id, hash=instance.access_hash)) self.save()
def cache_file(self, md5_digest, file_size, instance): if not isinstance(instance, (InputDocument, InputPhoto)): raise TypeError("Cannot cache {} instance".format(type(instance))) senf_file = models.SentFile(session_id=self.session_id, md5_digest=md5_digest, type=_SentFileType.from_type( type(instance)).value, id=instance.id, hash=instance.access_hash) senf_file.save() self.save()
def get_file(self, md5_digest, file_size, cls): key = "{}:sent_files:{}".format(self.sess_prefix, md5_digest) s = self.redis_connection.get(key) if s: try: s = self._unpack(s) return md5_digest, file_size \ if s["file_size"] == file_size and s["type"] == _SentFileType.from_type(cls).value \ else None except Exception as ex: __log__.exception(ex.args) return None
def get_file(self, md5_digest: str, file_size: int, cls: Any) -> Optional[Tuple[int, int]]: t = self.SentFile.__table__ rows = (self.engine.execute( select([t.c.id, t.c.hash]).where( and_(t.c.session_id == self.session_id, t.c.md5_digest == md5_digest, t.c.file_size == file_size, t.c.type == _SentFileType.from_type(cls).value)))) try: return next(rows) except StopIteration: return None
def cache_file(self, md5_digest: str, file_size: int, instance: Union[InputDocument, InputPhoto]) -> None: if not isinstance(instance, (InputDocument, InputPhoto)): raise TypeError("Cannot cache {} instance".format(type(instance))) t = self.SentFile.__table__ values = dict(id=instance.id, hash=instance.access_hash) with self.engine.begin() as conn: conn.execute("INSERT OR REPLACE INTO {} ".format(self.SentFile.__tablename__) + "VALUES (:session_id, :md5_digest, :type, :file_size)", dict(session_id=self.session_id, md5_digest=md5_digest, type=_SentFileType.from_type(type(instance)).value, file_size=file_size, **values))
def cache_file(self, md5_digest: str, file_size: int, instance: Union[InputDocument, InputPhoto]) -> None: if not isinstance(instance, (InputDocument, InputPhoto)): raise TypeError("Cannot cache {} instance".format(type(instance))) t = self.SentFile.__table__ values = dict(id=instance.id, hash=instance.access_hash) with self.engine.begin() as conn: conn.execute(insert(t) .values(session_id=self.session_id, md5_digest=md5_digest, type=_SentFileType.from_type(type(instance)).value, file_size=file_size, **values) .on_duplicate_key_update(**values))
def cache_file(self, md5_digest: str, file_size: int, instance: Union[InputDocument, InputPhoto]) -> None: if not isinstance(instance, (InputDocument, InputPhoto)): raise TypeError("Cannot cache {} instance".format(type(instance))) t = self.SentFile.__table__ values = dict(id=instance.id, hash=instance.access_hash) self.engine.execute( insert(t).values( session_id=self.session_id, md5_digest=md5_digest, type=_SentFileType.from_type(type(instance)).value, file_size=file_size, **values).on_conflict_do_update(constraint=t.primary_key, set_=values))
def cache_file(self, md5_digest, file_size, instance): if not isinstance(instance, (InputDocument, InputPhoto)): raise TypeError('Cannot cache %s instance' % type(instance)) sentfile_container = self.get_sent_file_container() item = { 'md5_digest': md5_digest, 'file_size': file_size, 'type': _SentFileType.from_type(type(instance)).value, 'id': str(instance.id), 'hash': instance.access_hash } sentfile_container.upsert_item(json.loads(json.dumps(item)))
def cache_file(self, md5_digest: str, file_size: int, instance: Union[InputDocument, InputPhoto]) -> None: if not isinstance(instance, (InputDocument, InputPhoto)): raise TypeError("Cannot cache {} instance".format(type(instance))) t = self.SentFile.__table__ file_type = _SentFileType.from_type(type(instance)).value with self.engine.begin() as conn: conn.execute(t.delete().where(session_id=self.session_id, md5_digest=md5_digest, type=file_type, file_size=file_size)) conn.execute(t.insert().values(session_id=self.session_id, md5_digest=md5_digest, type=file_type, file_size=file_size, id=instance.id, hash=instance.access_hash))
def cache_file(self, md5_digest, file_size, instance): if not isinstance(instance, (InputDocument, InputPhoto)): raise TypeError('Cannot cache {} instance'.format(type(instance))) key = "{}:sent_files:{}".format(self.sess_prefix, md5_digest) s = { "md5_digest": md5_digest, "file_size": file_size, "type": _SentFileType.from_type(type(instance)).value, "id": instance.id, "hash": instance.access_hash, } if self.add_timestamps: s.update({ "ts_ts": time.time(), "ts_str": time.strftime(DEFAULT_TS_STR_FORMAT, time.localtime()), }) try: self.redis_connection.set(key, self._pack(s)) except Exception as ex: __log__.exception(ex.args)
def get_file(self, md5_digest, file_size, cls): row = models.SentFile.objects.filter( md5_digest=md5_digest, file_size=file_size, type=_SentFileType.from_type(cls).value).first() return (row.id, row.hash) if row else None