def graph_stints(player_stints, team_abbr, save_path):
# graph this as rotation chart
fig, ax = plt.subplots(figsize=(11, 12))
y_ticks = []
y_labels = []
for index, player in enumerate(player_stints, start=1):
y_ax = (200 + 10 - (10 * index), 9)
y_ticks.append(200 + 10 - (10 * index) + 5)
y_labels.append(player['player_name'])
bar_colors = []
for stint, plus_minus in zip(player['stints'], player['plus_minus']):
data = [stint[0], stint[1]]
for qtr_time in [12, 24, 36, 48]:
if data[0] <= qtr_time:
start = 12 * (qtr_time / 12) - data[0]
break
for qtr_time in [12, 24, 36, 48]:
if data[1] + data[0] <= qtr_time:
end = 12 * (qtr_time / 12) - (data[1] + data[0])
break
if data[1] <= 48:
start_sec = math.ceil((start - math.floor(start)) * 60)
end_sec = math.ceil((end - math.floor(end)) * 60)
start_text = f"{math.floor(start)}:{start_sec:02d}"
end_text = f"{math.floor(end)}:{end_sec:02d}"
ax.annotate(start_text,
xy=(stint[0], y_ax[0] + 7), xycoords='data',
xytext=(stint[0], y_ax[0] + 7), textcoords='data')
ax.annotate(end_text,
xy=(stint[0] + stint[1], y_ax[0] + 1.5), xycoords='data',
xytext=(stint[0] + stint[1], y_ax[0] + 1.5), textcoords='data')
if plus_minus > 0:
plus_minus = f"+{plus_minus}"
bar_colors.append('green')
elif plus_minus == 0:
bar_colors.append('gray')
else:
bar_colors.append('red')
ax.annotate(plus_minus,
xy=((2 * stint[0] + stint[1]) / 2, y_ax[0] + 4.25), xycoords='data',
xytext=((2 * stint[0] + stint[1]) / 2, y_ax[0] + 4.25), textcoords='data')
ax.broken_barh(player['stints'], y_ax, color=bar_colors)
ax.set_yticks(y_ticks)
ax.set_yticklabels(y_labels)
ax.axhline(y=160, color='black')
x_ticks = [12, 24, 36, 48]
x_labels = ['End 1', 'Half', 'End 3', 'End 4']
ax.set_xticks(x_ticks)
ax.set_xticklabels(x_labels)
for tick in x_ticks:
ax.axvline(x=tick, color='black')
plt.title(f"{team_abbr} Rotation", loc='left')
save_path = f"{save_path}/{team_abbr}rotation.png"
AWS_ACCESS_KEY_ID = os.environ.get('AWS_ACCESS_KEY')
AWS_SECRET_ACCESS_KEY = os.environ.get('AWS_SECRET_KEY')
AWS_BUCKET_NAME = os.environ.get('AWS_BUCKET_NAME')
# save in a buffer object and upload to S3
buffer = BytesIO()
fig.savefig(buffer, format='png')
buffer.seek(0)
image_png = buffer.getvalue()
buffer.close()
plt.close("all")
s3 = boto3.resource('s3', aws_access_key_id=AWS_ACCESS_KEY_ID, aws_secret_access_key=AWS_SECRET_ACCESS_KEY)
s3.Bucket(AWS_BUCKET_NAME).put_object(Key=save_path, Body=image_png)
return save_path
"block_num": row[2],
"par_num": row[3],
"line_num": row[4],
"word_num": row[5],
"left": row[6],
"top": row[7],
"width": row[8],
"height": row[9]
}
if ocr_key in ocr_json:
ocr_json[ocr_key].append(ocr_value)
else:
ocr_json[ocr_key] = [ocr_value]
image_buffer = BytesIO()
image_reader.save(image_buffer, format="JPEG")
image_str = base64.b64encode(image_buffer.getvalue())
mongo_row = {
'image_name': output_image,
'image_file': image_str,
'ocr_text': ocr_text.encode('utf-8', 'strict'),
'ocr_data': ocr_json
}
# print(mongo_row)
mongo_row_id = collection.insert_one(mongo_row).inserted_id
# print(row_id)
def encode(self, include_path=True):
port = BytesIO()
self.write(port, include_path)
return port.getvalue()
def parameter(dims=None,
name=None,
learning_rate_multiplier=1.0,
init='uniform',
init_value_scale=1,
value=0,
init_from_file_path='',
init_from_literal=None,
random_seed=-1):
'''
creates a parameter tensor node.
'''
# FIXME We need to better manage the context. How can we get hold
# of the overall context without having to always pass it
# explicitly?
# if the parameter is initialized from a literal value
if (init == 'fromLiteral'):
"""
To be as generic as possible, we
- flatten the data
- initialize a ParameterTensor operator with it
- ensure that the graph does not backprob to it.
- Finally we to reshape it.
"""
value = init_from_literal
if not (np.isscalar(value) or is_tensor(value)):
raise ValueError('value type is not supported: %s' % type(value))
if isinstance(value, list) or np.isscalar(value):
value = np.asarray(value)
if sparse.issparse(value):
raise ValueError('only dense data is supported')
param_shape = value.shape if value.shape else (1, )
literal_shape = (param_shape[0], np.multiply.reduce(param_shape[1:]))
literal_array = np.reshape(value, literal_shape)
from io import BytesIO
s = BytesIO()
np.savetxt(s, literal_array, '%.4f')
return cntk1_ops.ParameterTensor(
dims=param_shape,
learningRateMultiplier=learning_rate_multiplier,
init='fromLiteral',
initFromLiteral=s.getvalue().decode())
return cntk1_ops.ParameterTensor(dims,
learning_rate_multiplier,
init,
init_value_scale,
value,
init_from_file_path,
randomSeed=random_seed,
var_name=name)
def test_verify_input(self):
raw_tx = bytes.fromhex('0100000001813f79011acb80925dfe69b3def355fe914bd1d96a3f5f71bf8303c6a989c7d1000000006b483045022100ed81ff192e75a3fd2304004dcadb746fa5e24c5031ccfcf21320b0277457c98f02207a986d955c6e0cb35d446a89d3f56100f4d7f67801c31967743a9c8e10615bed01210349fc4e631e3624a545de3f89f5d8684c7b8138bd94bdd531d2e213bf016b278afeffffff02a135ef01000000001976a914bc3b654dca7e56b04dca18f2566cdaf02e8d9ada88ac99c39800000000001976a9141c4bc762dd5423e332166702cb75f40df79fea1288ac19430600')
stream = BytesIO(raw_tx)
tx = Tx.parse(stream)
self.assertTrue(tx.verify_input(0))
def txFromHex(hexstring):
tx = CTransaction()
f = BytesIO(hex_str_to_bytes(hexstring))
tx.deserialize(f)
return tx
def test_compress(self):
raw = b"test"
compressed = publisher.gzip_compress(raw)
decompressed = gzip.GzipFile(fileobj=BytesIO(compressed)).read()
self.assertEqual(raw, decompressed)
"//button[contains(text(),'View entire discussion')]").click()
except:
print('Already accepted cookies')
scrollToBottom()
time.sleep(1)
print('Taking Screenshots')
post.comments.replace_more(limit=0)
post.comment_sort = config['reddit']['filterBy']
charCount = 0
j = 0
element = driver.find_element_by_id('t3_' + id)
screenshot = element.screenshot_as_png
image = Image.open(BytesIO(screenshot))
image.save('images/' + str(j) + '.png')
audioTimes.append(createVoice(post.title, 'voices/' + str(j) + '.wav'))
j += 1
audioTimeTotal = 0
for comment in post.comments:
if isinstance(comment, MoreComments):
break
if comment.stickied:
continue
if config['reddit']['maxCharacterComment'] < len(comment.body):
continue
async def facebook(self, ctx, *, resp=None):
"""Comando totalmente demente de facebook
Use ash facebook <mensagem desejada>"""
if resp is None:
return await ctx.send(
'<:alert:739251822920728708>│``DIGITE ALGO PARA EU POSTAR``')
rede = [[20, (89, 74)], [(218, 166), (91, 128)],
[['', (90, 93), 9], ['', (112, 74), 7],
['Agora', (112, 81), 7]], 42, 2]
msg = await ctx.send(
'<a:loading:520418506567843860>│``Processando...``')
cont = 0
list_ = resp.split()
resp = ''
for c in list_:
if len(c) + cont >= rede[3]:
cont = 0
resp = '{}{}{}'.format(resp, '''
''', c)
if len(c) > rede[3]:
resp = ' {}-{} {}'.format(c[:rede[3]], '''
''', c[rede[3]:])
cont = len(c) - rede[3]
else:
resp = '{} {}'.format(resp, c)
cont += len(c)
if resp.count('''
''') > rede[4]:
await ctx.send(
'<:alert:739251822920728708>│``Sua mensagem foi muito grande!``'
)
else:
avatar = await get_avatar(ctx.author.avatar_url_as(format="png"),
rede[0][0], rede[0][0])
imgurl = random.choice([
'https://i.imgur.com/2Owhe1y.jpg',
'https://i.imgur.com/pFuPCUE.jpg',
'https://i.imgur.com/0lnhQR9.jpg',
'https://i.imgur.com/mbigFXD.jpg',
'https://i.imgur.com/SL0AZr3.jpg',
'https://i.imgur.com/vj6hIvx.jpg',
'https://i.imgur.com/wMjySPZ.png',
'https://i.imgur.com/GCrHCm4.jpg',
'https://i.imgur.com/caVly1I.jpg',
'https://i.imgur.com/DI3MnVF.jpg',
'https://i.imgur.com/I1oFR7s.jpg',
'https://i.imgur.com/i1TjXts.jpg',
'https://i.imgur.com/IVzCAgX.jpg',
'https://i.imgur.com/AgX0ebq.jpg',
'https://i.imgur.com/ZxUEnnm.jpg',
'https://i.imgur.com/a34fK0P.jpg',
'https://i.imgur.com/JdufgXh.jpg',
'https://i.imgur.com/4bUx6IE.jpg',
'https://i.imgur.com/VXxGrIT.jpg',
'https://i.imgur.com/Kn1yIcC.jpg',
'https://i.imgur.com/YllNI2J.jpg',
'https://i.imgur.com/HI6Qmig.jpg',
'https://i.imgur.com/Nmnx7E8.jpg',
'https://i.imgur.com/A9ZvUzz.jpg',
'https://i.imgur.com/mSPiRMA.jpg',
'https://i.imgur.com/EQV5IS3.jpg',
'https://i.imgur.com/sY76YYa.jpg',
'https://i.imgur.com/jGtn5Q2.jpg',
'https://i.imgur.com/ncgHAFi.jpg',
'https://i.imgur.com/U4UW8Tn.jpg',
'https://i.imgur.com/YpK2xua.jpg',
'https://i.imgur.com/r5ttJuB.jpg',
'https://i.imgur.com/8wbwwV9.jpg',
'https://i.imgur.com/zRc0LtN.jpg',
'https://i.imgur.com/Q5USYEZ.png',
'https://i.imgur.com/XVhh7oO.jpg',
'https://i.imgur.com/vm109nQ.jpg',
'https://i.imgur.com/yMH2IN0.png',
'https://i.imgur.com/6UT2wFZ.jpg',
'https://i.imgur.com/yjSl9fs.jpg',
'https://i.imgur.com/OkSXZst.jpg',
'https://i.imgur.com/Wuad8Zw.jpg',
'https://i.imgur.com/crBWwqo.jpg',
'https://i.imgur.com/QGBSogM.jpg',
'https://i.imgur.com/IKSvnoK.jpg',
'https://i.imgur.com/MNHiUjf.jpg',
'https://i.imgur.com/TpOtHY6.png',
'https://i.imgur.com/mBsvITd.jpg',
'https://i.imgur.com/69PudmI.jpg',
'https://i.imgur.com/Le1XrNv.jpg',
'https://i.imgur.com/I2eCtiW.jpg'
])
imgurl = requests.get(imgurl)
img = Image.open(BytesIO(imgurl.content)).convert('RGBA')
img = img.resize(rede[1][0])
big_img = (img.size[0] * 3, img.size[1] * 3)
mascara = Image.new('L', big_img, 0)
trim = ImageDraw.Draw(mascara)
trim.rectangle((0, 0) + big_img, fill=255) # opacidade
mascara = mascara.resize(img.size, Image.ANTIALIAS)
img.putalpha(mascara)
exit_img = ImageOps.fit(img, mascara.size, centering=(0.5, 0.5))
exit_img.putalpha(mascara)
img = exit_img
um = rede[2][0][0]
dois = rede[2][1][0]
tres = rede[2][2][0]
if rede[2][0][0] == '':
rede[2][0][0] = resp
if rede[2][1][0] == '':
rede[2][1][0] = ctx.author
if rede[2][2][0] == '':
rede[2][2][0] = '@{}'.format(ctx.author)
image = Image.open('images/social/facebook.png').convert('RGBA')
escrita = ImageDraw.Draw(image)
for c in (rede[2]):
font = ImageFont.truetype('fonts/arial.ttf', c[2])
texto = str(c[0])
escrita.text(xy=c[1], text=texto, fill=(10, 10, 10), font=font)
image.paste(avatar, rede[0][1], avatar)
image.paste(img, rede[1][1], img)
image.save('facesbook.png')
await ctx.send(file=discord.File('facesbook.png'))
await msg.delete()
rede[2][0][0] = um
rede[2][1][0] = dois
rede[2][2][0] = tres
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def doit(num_ins, num_outs, M, keys, fee=10000,
outvals=None, segwit_in=False, outstyles=['p2pkh'], change_outputs=[],
incl_xpubs=False):
psbt = BasicPSBT()
txn = Tx(2,[],[])
if incl_xpubs:
# add global header with XPUB's
# - assumes BIP45
for xfp, m, sk in keys:
kk = pack('<II', xfp, 45|0x80000000)
psbt.xpubs.append( (sk.serialize(as_private=False), kk) )
psbt.inputs = [BasicPSBTInput(idx=i) for i in range(num_ins)]
psbt.outputs = [BasicPSBTOutput(idx=i) for i in range(num_outs)]
for i in range(num_ins):
# make a fake txn to supply each of the inputs
# - each input is 1BTC
# addr where the fake money will be stored.
addr, scriptPubKey, script, details = make_ms_address(M, keys, idx=i)
# lots of supporting details needed for p2sh inputs
if segwit_in:
psbt.inputs[i].witness_script = script
else:
psbt.inputs[i].redeem_script = script
for pubkey, xfp_path in details:
psbt.inputs[i].bip32_paths[pubkey] = b''.join(pack('<I', j) for j in xfp_path)
# UTXO that provides the funding for to-be-signed txn
supply = Tx(2,[TxIn(pack('4Q', 0xdead, 0xbeef, 0, 0), 73)],[])
supply.txs_out.append(TxOut(1E8, scriptPubKey))
with BytesIO() as fd:
if not segwit_in:
supply.stream(fd)
psbt.inputs[i].utxo = fd.getvalue()
else:
supply.txs_out[-1].stream(fd)
psbt.inputs[i].witness_utxo = fd.getvalue()
spendable = TxIn(supply.hash(), 0)
txn.txs_in.append(spendable)
for i in range(num_outs):
# random P2PKH
if not outstyles:
style = ADDR_STYLES[i % len(ADDR_STYLES)]
else:
style = outstyles[i % len(outstyles)]
if i in change_outputs:
addr, scriptPubKey, scr, details = \
make_ms_address(M, keys, idx=i, addr_fmt=unmap_addr_fmt[style])
for pubkey, xfp_path in details:
psbt.outputs[i].bip32_paths[pubkey] = b''.join(pack('<I', j) for j in xfp_path)
if 'w' in style:
psbt.outputs[i].witness_script = scr
if style.endswith('p2sh'):
psbt.outputs[i].redeem_script = b'\0\x20' + sha256(scr).digest()
elif style.endswith('sh'):
psbt.outputs[i].redeem_script = scr
else:
scr = fake_dest_addr(style)
assert scr
if not outvals:
h = TxOut(round(((1E8*num_ins)-fee) / num_outs, 4), scriptPubKey)
else:
h = TxOut(outvals[i], scriptPubKey)
txn.txs_out.append(h)
with BytesIO() as b:
txn.stream(b)
psbt.txn = b.getvalue()
rv = BytesIO()
psbt.serialize(rv)
assert rv.tell() <= MAX_TXN_LEN, 'too fat'
return rv.getvalue()
def test_dump():
X_sparse, y_dense = load_svmlight_file(datafile)
X_dense = X_sparse.toarray()
y_sparse = sp.csr_matrix(y_dense)
# slicing a csr_matrix can unsort its .indices, so test that we sort
# those correctly
X_sliced = X_sparse[np.arange(X_sparse.shape[0])]
y_sliced = y_sparse[np.arange(y_sparse.shape[0])]
for X in (X_sparse, X_dense, X_sliced):
for y in (y_sparse, y_dense, y_sliced):
for zero_based in (True, False):
for dtype in [np.float32, np.float64, np.int32, np.int64]:
f = BytesIO()
# we need to pass a comment to get the version info in;
# LibSVM doesn't grok comments so they're not put in by
# default anymore.
if (sp.issparse(y) and y.shape[0] == 1):
# make sure y's shape is: (n_samples, n_labels)
# when it is sparse
y = y.T
# Note: with dtype=np.int32 we are performing unsafe casts,
# where X.astype(dtype) overflows. The result is
# then platform dependent and X_dense.astype(dtype) may be
# different from X_sparse.astype(dtype).asarray().
X_input = X.astype(dtype)
dump_svmlight_file(X_input, y, f, comment="test",
zero_based=zero_based)
f.seek(0)
comment = f.readline()
comment = str(comment, "utf-8")
assert_in("scikit-learn %s" % sklearn.__version__, comment)
comment = f.readline()
comment = str(comment, "utf-8")
assert_in(["one", "zero"][zero_based] + "-based", comment)
X2, y2 = load_svmlight_file(f, dtype=dtype,
zero_based=zero_based)
assert_equal(X2.dtype, dtype)
assert_array_equal(X2.sorted_indices().indices, X2.indices)
X2_dense = X2.toarray()
if sp.issparse(X_input):
X_input_dense = X_input.toarray()
else:
X_input_dense = X_input
if dtype == np.float32:
# allow a rounding error at the last decimal place
assert_array_almost_equal(
X_input_dense, X2_dense, 4)
assert_array_almost_equal(
y_dense.astype(dtype), y2, 4)
else:
# allow a rounding error at the last decimal place
assert_array_almost_equal(
X_input_dense, X2_dense, 15)
assert_array_almost_equal(
y_dense.astype(dtype), y2, 15)
def test_load_zero_based():
f = BytesIO(b"-1 4:1.\n1 0:1\n")
assert_raises(ValueError, load_svmlight_file, f, zero_based=False)
def launch_next(self):
path = ""
title = ""
var.next_downloaded = False
logging.debug(var.current_music)
if var.current_music["type"] == "url" or var.current_music["type"] == "playlist":
url = media.get_url(var.current_music["url"])
if not url:
return
media.clear_tmp_folder(var.config.get('bot', 'tmp_folder'), var.config.getint('bot', 'tmp_folder_max_size'))
if var.current_music["type"] == "playlist":
path, title = self.download_music(url, var.current_music["current_index"])
var.current_music["playlist_title"] = title
else:
path, title = self.download_music(url)
var.current_music["path"] = path
if os.path.isfile(path):
audio = EasyID3(path)
if audio["title"]:
title = audio["title"][0]
path_thumbnail = var.config.get('bot', 'tmp_folder') + hashlib.md5(path.encode()).hexdigest() + '.jpg'
thumbnail_html = ""
if os.path.isfile(path_thumbnail):
im = Image.open(path_thumbnail)
im.thumbnail((100, 100), Image.ANTIALIAS)
buffer = BytesIO()
im.save(buffer, format="JPEG")
thumbnail_base64 = base64.b64encode(buffer.getvalue())
thumbnail_html = '<img - src="data:image/PNG;base64,' + thumbnail_base64.decode() + '"/>'
logging.debug(thumbnail_html)
if var.config.getboolean('bot', 'announce_current_music'):
self.send_msg_channel(var.config.get('strings', 'now_playing') % (title, thumbnail_html))
else:
if var.current_music["type"] == "playlist":
var.current_music['current_index'] = var.current_music['number_track_to_play']
if self.get_next():
self.launch_next()
self.async_download_next()
elif var.current_music["type"] == "file":
path = var.config.get('bot', 'music_folder') + var.current_music["path"]
title = var.current_music["path"]
elif var.current_music["type"] == "radio":
url = media.get_url(var.current_music["path"])
if not url:
return
var.current_music["path"] = url
path = url
title = media.get_radio_server_description(url)
var.current_music["title"] = title
if var.config.getboolean('debug', 'ffmpeg'):
ffmpeg_debug = "debug"
else:
ffmpeg_debug = "warning"
command = ["ffmpeg", '-v', ffmpeg_debug, '-nostdin', '-i', path, '-ac', '1', '-f', 's16le', '-ar', '48000', '-']
self.thread = sp.Popen(command, stdout=sp.PIPE, bufsize=480)
def roundtrip(im, **options):
out = BytesIO()
im.save(out, "PNG", **options)
out.seek(0)
return Image.open(out)
def send_image(filename):
#return send_from_directory("images", filename)
file_data = FileContents.query.filter_by(name=filename).first()
print "data: ", BytesIO(file_data.data)
return send_file(BytesIO(file_data.data), attachment_filename=filename, as_attachment=True)
def test_repr_png(self):
im = hopper()
repr_png = Image.open(BytesIO(im._repr_png_()))
self.assertEqual(repr_png.format, 'PNG')
self.assert_image_equal(im, repr_png)
def download():
file_data = FileContents.query.filter_by(id=1).first()
return send_file(BytesIO(file_data.data), attachment_filename='profile2.jpg', as_attachment=True)
def __import_data__(chat_id, data):
failures = []
for notename, notedata in data.get("extra", {}).items():
match = FILE_MATCHER.match(notedata)
matchsticker = STICKER_MATCHER.match(notedata)
matchbtn = BUTTON_MATCHER.match(notedata)
matchfile = MYFILE_MATCHER.match(notedata)
matchphoto = MYPHOTO_MATCHER.match(notedata)
matchaudio = MYAUDIO_MATCHER.match(notedata)
matchvoice = MYVOICE_MATCHER.match(notedata)
matchvideo = MYVIDEO_MATCHER.match(notedata)
matchvn = MYVIDEONOTE_MATCHER.match(notedata)
if match:
failures.append(notename)
notedata = notedata[match.end():].strip()
if notedata:
sql.add_note_to_db(chat_id, notename[1:], notedata,
sql.Types.TEXT)
elif matchsticker:
content = notedata[matchsticker.end():].strip()
if content:
sql.add_note_to_db(chat_id,
notename[1:],
notedata,
sql.Types.STICKER,
file=content)
elif matchbtn:
parse = notedata[matchbtn.end():].strip()
notedata = parse.split("<###button###>")[0]
buttons = parse.split("<###button###>")[1]
buttons = ast.literal_eval(buttons)
if buttons:
sql.add_note_to_db(
chat_id,
notename[1:],
notedata,
sql.Types.BUTTON_TEXT,
buttons=buttons,
)
elif matchfile:
file = notedata[matchfile.end():].strip()
file = file.split("<###TYPESPLIT###>")
notedata = file[1]
content = file[0]
if content:
sql.add_note_to_db(chat_id,
notename[1:],
notedata,
sql.Types.DOCUMENT,
file=content)
elif matchphoto:
photo = notedata[matchphoto.end():].strip()
photo = photo.split("<###TYPESPLIT###>")
notedata = photo[1]
content = photo[0]
if content:
sql.add_note_to_db(chat_id,
notename[1:],
notedata,
sql.Types.PHOTO,
file=content)
elif matchaudio:
audio = notedata[matchaudio.end():].strip()
audio = audio.split("<###TYPESPLIT###>")
notedata = audio[1]
content = audio[0]
if content:
sql.add_note_to_db(chat_id,
notename[1:],
notedata,
sql.Types.AUDIO,
file=content)
elif matchvoice:
voice = notedata[matchvoice.end():].strip()
voice = voice.split("<###TYPESPLIT###>")
notedata = voice[1]
content = voice[0]
if content:
sql.add_note_to_db(chat_id,
notename[1:],
notedata,
sql.Types.VOICE,
file=content)
elif matchvideo:
video = notedata[matchvideo.end():].strip()
video = video.split("<###TYPESPLIT###>")
notedata = video[1]
content = video[0]
if content:
sql.add_note_to_db(chat_id,
notename[1:],
notedata,
sql.Types.VIDEO,
file=content)
elif matchvn:
video_note = notedata[matchvn.end():].strip()
video_note = video_note.split("<###TYPESPLIT###>")
notedata = video_note[1]
content = video_note[0]
if content:
sql.add_note_to_db(chat_id,
notename[1:],
notedata,
sql.Types.VIDEO_NOTE,
file=content)
else:
sql.add_note_to_db(chat_id, notename[1:], notedata, sql.Types.TEXT)
if failures:
with BytesIO(str.encode("\n".join(failures))) as output:
output.name = "failed_imports.txt"
dispatcher.bot.send_document(
chat_id,
document=output,
filename="failed_imports.txt",
caption="These files/photos failed to import due to originating "
"from another bot. This is a telegram API restriction, and can't "
"be avoided. Sorry for the inconvenience!",
)
def echo(self, _body):
return BytesIO(_body.read())
def run_test(self):
self.log.info(
'prepare some coins for multiple *rawtransaction commands')
self.nodes[2].generate(1)
self.sync_all()
self.nodes[0].generate(101)
self.sync_all()
self.nodes[0].sendtoaddress(self.nodes[2].getnewaddress(), 1.5)
self.nodes[0].sendtoaddress(self.nodes[2].getnewaddress(), 1.0)
self.nodes[0].sendtoaddress(self.nodes[2].getnewaddress(), 5.0)
self.sync_all()
self.nodes[0].generate(5)
self.sync_all()
self.log.info(
'Test getrawtransaction on genesis block coinbase returns an error'
)
block = self.nodes[0].getblock(self.nodes[0].getblockhash(0))
assert_raises_rpc_error(
-5,
"The genesis block coinbase is not considered an ordinary transaction",
self.nodes[0].getrawtransaction, block['merkleroot'])
self.log.info(
'Check parameter types and required parameters of createrawtransaction'
)
# Test `createrawtransaction` required parameters
assert_raises_rpc_error(-1, "createrawtransaction",
self.nodes[0].createrawtransaction)
assert_raises_rpc_error(-1, "createrawtransaction",
self.nodes[0].createrawtransaction, [])
# Test `createrawtransaction` invalid extra parameters
assert_raises_rpc_error(-1, "createrawtransaction",
self.nodes[0].createrawtransaction, [], {}, 0,
False, 'foo')
# Test `createrawtransaction` invalid `inputs`
txid = '1d1d4e24ed99057e84c3f80fd8fbec79ed9e1acee37da269356ecea000000000'
assert_raises_rpc_error(-3, "Expected type array",
self.nodes[0].createrawtransaction, 'foo', {})
assert_raises_rpc_error(-1, "JSON value is not an object as expected",
self.nodes[0].createrawtransaction, ['foo'],
{})
assert_raises_rpc_error(-1, "JSON value is not a string as expected",
self.nodes[0].createrawtransaction, [{}], {})
assert_raises_rpc_error(
-8, "txid must be of length 64 (not 3, for 'foo')",
self.nodes[0].createrawtransaction, [{
'txid': 'foo'
}], {})
assert_raises_rpc_error(
-8,
"txid must be hexadecimal string (not 'ZZZ7bb8b1697ea987f3b223ba7819250cae33efacb068d23dc24859824a77844')",
self.nodes[0].createrawtransaction, [{
'txid':
'ZZZ7bb8b1697ea987f3b223ba7819250cae33efacb068d23dc24859824a77844'
}], {})
assert_raises_rpc_error(-8, "Invalid parameter, missing vout key",
self.nodes[0].createrawtransaction,
[{
'txid': txid
}], {})
assert_raises_rpc_error(-8, "Invalid parameter, missing vout key",
self.nodes[0].createrawtransaction,
[{
'txid': txid,
'vout': 'foo'
}], {})
assert_raises_rpc_error(-8, "Invalid parameter, vout must be positive",
self.nodes[0].createrawtransaction, [{
'txid': txid,
'vout': -1
}], {})
assert_raises_rpc_error(
-8, "Invalid parameter, sequence number is out of range",
self.nodes[0].createrawtransaction, [{
'txid': txid,
'vout': 0,
'sequence': -1
}], {})
# Test `createrawtransaction` invalid `outputs`
address = self.nodes[0].getnewaddress()
address2 = self.nodes[0].getnewaddress()
assert_raises_rpc_error(-1, "JSON value is not an array as expected",
self.nodes[0].createrawtransaction, [], 'foo')
self.nodes[0].createrawtransaction(
inputs=[],
outputs={}) # Should not throw for backwards compatibility
self.nodes[0].createrawtransaction(inputs=[], outputs=[])
assert_raises_rpc_error(-8, "Data must be hexadecimal string",
self.nodes[0].createrawtransaction, [],
{'data': 'foo'})
assert_raises_rpc_error(-5, "Invalid Bitcoin address",
self.nodes[0].createrawtransaction, [],
{'foo': 0})
assert_raises_rpc_error(-3, "Invalid amount",
self.nodes[0].createrawtransaction, [],
{address: 'foo'})
assert_raises_rpc_error(-3, "Amount out of range",
self.nodes[0].createrawtransaction, [],
{address: -1})
assert_raises_rpc_error(
-8, "Invalid parameter, duplicated address: %s" % address,
self.nodes[0].createrawtransaction, [],
multidict([(address, 1), (address, 1)]))
assert_raises_rpc_error(
-8, "Invalid parameter, duplicated address: %s" % address,
self.nodes[0].createrawtransaction, [], [{
address: 1
}, {
address: 1
}])
assert_raises_rpc_error(-8, "Invalid parameter, duplicate key: data",
self.nodes[0].createrawtransaction, [],
[{
"data": 'aa'
}, {
"data": "bb"
}])
assert_raises_rpc_error(-8, "Invalid parameter, duplicate key: data",
self.nodes[0].createrawtransaction, [],
multidict([("data", 'aa'), ("data", "bb")]))
assert_raises_rpc_error(
-8,
"Invalid parameter, key-value pair must contain exactly one key",
self.nodes[0].createrawtransaction, [], [{
'a': 1,
'b': 2
}])
assert_raises_rpc_error(
-8, "Invalid parameter, key-value pair not an object as expected",
self.nodes[0].createrawtransaction, [],
[['key-value pair1'], ['2']])
# Test `createrawtransaction` invalid `locktime`
assert_raises_rpc_error(-3, "Expected type number",
self.nodes[0].createrawtransaction, [], {},
'foo')
assert_raises_rpc_error(-8, "Invalid parameter, locktime out of range",
self.nodes[0].createrawtransaction, [], {}, -1)
assert_raises_rpc_error(-8, "Invalid parameter, locktime out of range",
self.nodes[0].createrawtransaction, [], {},
4294967296)
# Test `createrawtransaction` invalid `replaceable`
assert_raises_rpc_error(-3, "Expected type bool",
self.nodes[0].createrawtransaction, [], {}, 0,
'foo')
self.log.info(
'Check that createrawtransaction accepts an array and object as outputs'
)
tx = CTransaction()
# One output
tx.deserialize(
BytesIO(
hex_str_to_bytes(self.nodes[2].createrawtransaction(
inputs=[{
'txid': txid,
'vout': 9
}], outputs={address: 99}))))
assert_equal(len(tx.vout), 1)
assert_equal(
tx.serialize().hex(),
self.nodes[2].createrawtransaction(inputs=[{
'txid': txid,
'vout': 9
}],
outputs=[{
address: 99
}]),
)
# Two outputs
tx.deserialize(
BytesIO(
hex_str_to_bytes(self.nodes[2].createrawtransaction(
inputs=[{
'txid': txid,
'vout': 9
}],
outputs=OrderedDict([(address, 99), (address2, 99)])))))
assert_equal(len(tx.vout), 2)
assert_equal(
tx.serialize().hex(),
self.nodes[2].createrawtransaction(inputs=[{
'txid': txid,
'vout': 9
}],
outputs=[{
address: 99
}, {
address2: 99
}]),
)
# Multiple mixed outputs
tx.deserialize(
BytesIO(
hex_str_to_bytes(self.nodes[2].createrawtransaction(
inputs=[{
'txid': txid,
'vout': 9
}],
outputs=multidict([(address, 99), (address2, 99),
('data', '99')])))))
assert_equal(len(tx.vout), 3)
assert_equal(
tx.serialize().hex(),
self.nodes[2].createrawtransaction(inputs=[{
'txid': txid,
'vout': 9
}],
outputs=[{
address: 99
}, {
address2: 99
}, {
'data': '99'
}]),
)
for type in ["bech32", "p2sh-segwit", "legacy"]:
addr = self.nodes[0].getnewaddress("", type)
addrinfo = self.nodes[0].getaddressinfo(addr)
pubkey = addrinfo["scriptPubKey"]
self.log.info('sendrawtransaction with missing prevtx info (%s)' %
(type))
# Test `signrawtransactionwithwallet` invalid `prevtxs`
inputs = [{'txid': txid, 'vout': 3, 'sequence': 1000}]
outputs = {self.nodes[0].getnewaddress(): 1}
rawtx = self.nodes[0].createrawtransaction(inputs, outputs)
prevtx = dict(txid=txid, scriptPubKey=pubkey, vout=3, amount=1)
succ = self.nodes[0].signrawtransactionwithwallet(rawtx, [prevtx])
assert succ["complete"]
if type == "legacy":
del prevtx["amount"]
succ = self.nodes[0].signrawtransactionwithwallet(
rawtx, [prevtx])
assert succ["complete"]
if type != "legacy":
assert_raises_rpc_error(
-3, "Missing amount",
self.nodes[0].signrawtransactionwithwallet, rawtx,
[{
"txid": txid,
"scriptPubKey": pubkey,
"vout": 3,
}])
assert_raises_rpc_error(-3, "Missing vout",
self.nodes[0].signrawtransactionwithwallet,
rawtx, [{
"txid": txid,
"scriptPubKey": pubkey,
"amount": 1,
}])
assert_raises_rpc_error(-3, "Missing txid",
self.nodes[0].signrawtransactionwithwallet,
rawtx, [{
"scriptPubKey": pubkey,
"vout": 3,
"amount": 1,
}])
assert_raises_rpc_error(-3, "Missing scriptPubKey",
self.nodes[0].signrawtransactionwithwallet,
rawtx, [{
"txid": txid,
"vout": 3,
"amount": 1
}])
#########################################
# sendrawtransaction with missing input #
#########################################
self.log.info('sendrawtransaction with missing input')
inputs = [{
'txid':
"1d1d4e24ed99057e84c3f80fd8fbec79ed9e1acee37da269356ecea000000000",
'vout': 1
}] #won't exists
outputs = {self.nodes[0].getnewaddress(): 4.998}
rawtx = self.nodes[2].createrawtransaction(inputs, outputs)
rawtx = self.nodes[2].signrawtransactionwithwallet(rawtx)
# This will raise an exception since there are missing inputs
assert_raises_rpc_error(-25, "Missing inputs",
self.nodes[2].sendrawtransaction, rawtx['hex'])
#####################################
# getrawtransaction with block hash #
#####################################
# make a tx by sending then generate 2 blocks; block1 has the tx in it
tx = self.nodes[2].sendtoaddress(self.nodes[1].getnewaddress(), 1)
block1, block2 = self.nodes[2].generate(2)
self.sync_all()
# We should be able to get the raw transaction by providing the correct block
gottx = self.nodes[0].getrawtransaction(tx, True, block1)
assert_equal(gottx['txid'], tx)
assert_equal(gottx['in_active_chain'], True)
# We should not have the 'in_active_chain' flag when we don't provide a block
gottx = self.nodes[0].getrawtransaction(tx, True)
assert_equal(gottx['txid'], tx)
assert 'in_active_chain' not in gottx
# We should not get the tx if we provide an unrelated block
assert_raises_rpc_error(-5, "No such transaction found",
self.nodes[0].getrawtransaction, tx, True,
block2)
# An invalid block hash should raise the correct errors
assert_raises_rpc_error(-1, "JSON value is not a string as expected",
self.nodes[0].getrawtransaction, tx, True,
True)
assert_raises_rpc_error(
-8, "parameter 3 must be of length 64 (not 6, for 'foobar')",
self.nodes[0].getrawtransaction, tx, True, "foobar")
assert_raises_rpc_error(
-8, "parameter 3 must be of length 64 (not 8, for 'abcd1234')",
self.nodes[0].getrawtransaction, tx, True, "abcd1234")
assert_raises_rpc_error(
-8,
"parameter 3 must be hexadecimal string (not 'ZZZ0000000000000000000000000000000000000000000000000000000000000')",
self.nodes[0].getrawtransaction, tx, True,
"ZZZ0000000000000000000000000000000000000000000000000000000000000")
assert_raises_rpc_error(
-5, "Block hash not found", self.nodes[0].getrawtransaction, tx,
True,
"0000000000000000000000000000000000000000000000000000000000000000")
# Undo the blocks and check in_active_chain
self.nodes[0].invalidateblock(block1)
gottx = self.nodes[0].getrawtransaction(txid=tx,
verbose=True,
blockhash=block1)
assert_equal(gottx['in_active_chain'], False)
self.nodes[0].reconsiderblock(block1)
assert_equal(self.nodes[0].getbestblockhash(), block2)
#########################
# RAW TX MULTISIG TESTS #
#########################
# 2of2 test
addr1 = self.nodes[2].getnewaddress()
addr2 = self.nodes[2].getnewaddress()
addr1Obj = self.nodes[2].getaddressinfo(addr1)
addr2Obj = self.nodes[2].getaddressinfo(addr2)
# Tests for createmultisig and addmultisigaddress
assert_raises_rpc_error(-5, "Invalid public key",
self.nodes[0].createmultisig, 1, ["01020304"])
self.nodes[0].createmultisig(
2, [addr1Obj['pubkey'], addr2Obj['pubkey']
]) # createmultisig can only take public keys
assert_raises_rpc_error(
-5, "Invalid public key", self.nodes[0].createmultisig, 2,
[addr1Obj['pubkey'], addr1]
) # addmultisigaddress can take both pubkeys and addresses so long as they are in the wallet, which is tested here.
mSigObj = self.nodes[2].addmultisigaddress(
2, [addr1Obj['pubkey'], addr1])['address']
#use balance deltas instead of absolute values
bal = self.nodes[2].getbalance()
# send 1.2 BTC to msig adr
txId = self.nodes[0].sendtoaddress(mSigObj, 1.2)
self.sync_all()
self.nodes[0].generate(1)
self.sync_all()
assert_equal(
self.nodes[2].getbalance(), bal + Decimal('1.20000000')
) #node2 has both keys of the 2of2 ms addr., tx should affect the balance
# 2of3 test from different nodes
bal = self.nodes[2].getbalance()
addr1 = self.nodes[1].getnewaddress()
addr2 = self.nodes[2].getnewaddress()
addr3 = self.nodes[2].getnewaddress()
addr1Obj = self.nodes[1].getaddressinfo(addr1)
addr2Obj = self.nodes[2].getaddressinfo(addr2)
addr3Obj = self.nodes[2].getaddressinfo(addr3)
mSigObj = self.nodes[2].addmultisigaddress(
2, [addr1Obj['pubkey'], addr2Obj['pubkey'], addr3Obj['pubkey']
])['address']
txId = self.nodes[0].sendtoaddress(mSigObj, 2.2)
decTx = self.nodes[0].gettransaction(txId)
rawTx = self.nodes[0].decoderawtransaction(decTx['hex'])
self.sync_all()
self.nodes[0].generate(1)
self.sync_all()
#THIS IS AN INCOMPLETE FEATURE
#NODE2 HAS TWO OF THREE KEY AND THE FUNDS SHOULD BE SPENDABLE AND COUNT AT BALANCE CALCULATION
assert_equal(
self.nodes[2].getbalance(), bal
) #for now, assume the funds of a 2of3 multisig tx are not marked as spendable
txDetails = self.nodes[0].gettransaction(txId, True)
rawTx = self.nodes[0].decoderawtransaction(txDetails['hex'])
vout = next(o for o in rawTx['vout']
if o['value'] == Decimal('2.20000000'))
bal = self.nodes[0].getbalance()
inputs = [{
"txid": txId,
"vout": vout['n'],
"scriptPubKey": vout['scriptPubKey']['hex'],
"amount": vout['value']
}]
outputs = {self.nodes[0].getnewaddress(): 2.19}
rawTx = self.nodes[2].createrawtransaction(inputs, outputs)
rawTxPartialSigned = self.nodes[1].signrawtransactionwithwallet(
rawTx, inputs)
assert_equal(rawTxPartialSigned['complete'],
False) #node1 only has one key, can't comp. sign the tx
rawTxSigned = self.nodes[2].signrawtransactionwithwallet(rawTx, inputs)
assert_equal(
rawTxSigned['complete'],
True) #node2 can sign the tx compl., own two of three keys
self.nodes[2].sendrawtransaction(rawTxSigned['hex'])
rawTx = self.nodes[0].decoderawtransaction(rawTxSigned['hex'])
self.sync_all()
self.nodes[0].generate(1)
self.sync_all()
assert_equal(self.nodes[0].getbalance(), bal + Decimal('50.00000000') +
Decimal('2.19000000')) #block reward + tx
# 2of2 test for combining transactions
bal = self.nodes[2].getbalance()
addr1 = self.nodes[1].getnewaddress()
addr2 = self.nodes[2].getnewaddress()
addr1Obj = self.nodes[1].getaddressinfo(addr1)
addr2Obj = self.nodes[2].getaddressinfo(addr2)
self.nodes[1].addmultisigaddress(
2, [addr1Obj['pubkey'], addr2Obj['pubkey']])['address']
mSigObj = self.nodes[2].addmultisigaddress(
2, [addr1Obj['pubkey'], addr2Obj['pubkey']])['address']
mSigObjValid = self.nodes[2].getaddressinfo(mSigObj)
txId = self.nodes[0].sendtoaddress(mSigObj, 2.2)
decTx = self.nodes[0].gettransaction(txId)
rawTx2 = self.nodes[0].decoderawtransaction(decTx['hex'])
self.sync_all()
self.nodes[0].generate(1)
self.sync_all()
assert_equal(
self.nodes[2].getbalance(), bal
) # the funds of a 2of2 multisig tx should not be marked as spendable
txDetails = self.nodes[0].gettransaction(txId, True)
rawTx2 = self.nodes[0].decoderawtransaction(txDetails['hex'])
vout = next(o for o in rawTx2['vout']
if o['value'] == Decimal('2.20000000'))
bal = self.nodes[0].getbalance()
inputs = [{
"txid": txId,
"vout": vout['n'],
"scriptPubKey": vout['scriptPubKey']['hex'],
"redeemScript": mSigObjValid['hex'],
"amount": vout['value']
}]
outputs = {self.nodes[0].getnewaddress(): 2.19}
rawTx2 = self.nodes[2].createrawtransaction(inputs, outputs)
rawTxPartialSigned1 = self.nodes[1].signrawtransactionwithwallet(
rawTx2, inputs)
self.log.debug(rawTxPartialSigned1)
assert_equal(rawTxPartialSigned1['complete'],
False) #node1 only has one key, can't comp. sign the tx
rawTxPartialSigned2 = self.nodes[2].signrawtransactionwithwallet(
rawTx2, inputs)
self.log.debug(rawTxPartialSigned2)
assert_equal(rawTxPartialSigned2['complete'],
False) #node2 only has one key, can't comp. sign the tx
rawTxComb = self.nodes[2].combinerawtransaction(
[rawTxPartialSigned1['hex'], rawTxPartialSigned2['hex']])
self.log.debug(rawTxComb)
self.nodes[2].sendrawtransaction(rawTxComb)
rawTx2 = self.nodes[0].decoderawtransaction(rawTxComb)
self.sync_all()
self.nodes[0].generate(1)
self.sync_all()
assert_equal(self.nodes[0].getbalance(), bal + Decimal('50.00000000') +
Decimal('2.19000000')) #block reward + tx
# decoderawtransaction tests
# witness transaction
encrawtx = "010000000001010000000000000072c1a6a246ae63f74f931e8365e15a089c68d61900000000000000000000ffffffff0100e1f50500000000000102616100000000"
decrawtx = self.nodes[0].decoderawtransaction(
encrawtx, True) # decode as witness transaction
assert_equal(decrawtx['vout'][0]['value'], Decimal('1.00000000'))
assert_raises_rpc_error(
-22, 'TX decode failed', self.nodes[0].decoderawtransaction,
encrawtx, False) # force decode as non-witness transaction
# non-witness transaction
encrawtx = "01000000010000000000000072c1a6a246ae63f74f931e8365e15a089c68d61900000000000000000000ffffffff0100e1f505000000000000000000"
decrawtx = self.nodes[0].decoderawtransaction(
encrawtx, False) # decode as non-witness transaction
assert_equal(decrawtx['vout'][0]['value'], Decimal('1.00000000'))
# getrawtransaction tests
# 1. valid parameters - only supply txid
txId = rawTx["txid"]
assert_equal(self.nodes[0].getrawtransaction(txId), rawTxSigned['hex'])
# 2. valid parameters - supply txid and 0 for non-verbose
assert_equal(self.nodes[0].getrawtransaction(txId, 0),
rawTxSigned['hex'])
# 3. valid parameters - supply txid and False for non-verbose
assert_equal(self.nodes[0].getrawtransaction(txId, False),
rawTxSigned['hex'])
# 4. valid parameters - supply txid and 1 for verbose.
# We only check the "hex" field of the output so we don't need to update this test every time the output format changes.
assert_equal(self.nodes[0].getrawtransaction(txId, 1)["hex"],
rawTxSigned['hex'])
# 5. valid parameters - supply txid and True for non-verbose
assert_equal(self.nodes[0].getrawtransaction(txId, True)["hex"],
rawTxSigned['hex'])
# 6. invalid parameters - supply txid and string "Flase"
assert_raises_rpc_error(-1, "not a boolean",
self.nodes[0].getrawtransaction, txId, "Flase")
# 7. invalid parameters - supply txid and empty array
assert_raises_rpc_error(-1, "not a boolean",
self.nodes[0].getrawtransaction, txId, [])
# 8. invalid parameters - supply txid and empty dict
assert_raises_rpc_error(-1, "not a boolean",
self.nodes[0].getrawtransaction, txId, {})
inputs = [{
'txid':
"1d1d4e24ed99057e84c3f80fd8fbec79ed9e1acee37da269356ecea000000000",
'vout': 1,
'sequence': 1000
}]
outputs = {self.nodes[0].getnewaddress(): 1}
rawtx = self.nodes[0].createrawtransaction(inputs, outputs)
decrawtx = self.nodes[0].decoderawtransaction(rawtx)
assert_equal(decrawtx['vin'][0]['sequence'], 1000)
# 9. invalid parameters - sequence number out of range
inputs = [{
'txid':
"1d1d4e24ed99057e84c3f80fd8fbec79ed9e1acee37da269356ecea000000000",
'vout': 1,
'sequence': -1
}]
outputs = {self.nodes[0].getnewaddress(): 1}
assert_raises_rpc_error(
-8, 'Invalid parameter, sequence number is out of range',
self.nodes[0].createrawtransaction, inputs, outputs)
# 10. invalid parameters - sequence number out of range
inputs = [{
'txid':
"1d1d4e24ed99057e84c3f80fd8fbec79ed9e1acee37da269356ecea000000000",
'vout': 1,
'sequence': 4294967296
}]
outputs = {self.nodes[0].getnewaddress(): 1}
assert_raises_rpc_error(
-8, 'Invalid parameter, sequence number is out of range',
self.nodes[0].createrawtransaction, inputs, outputs)
inputs = [{
'txid':
"1d1d4e24ed99057e84c3f80fd8fbec79ed9e1acee37da269356ecea000000000",
'vout': 1,
'sequence': 4294967294
}]
outputs = {self.nodes[0].getnewaddress(): 1}
rawtx = self.nodes[0].createrawtransaction(inputs, outputs)
decrawtx = self.nodes[0].decoderawtransaction(rawtx)
assert_equal(decrawtx['vin'][0]['sequence'], 4294967294)
####################################
# TRANSACTION VERSION NUMBER TESTS #
####################################
# Test the minimum transaction version number that fits in a signed 32-bit integer.
tx = CTransaction()
tx.nVersion = -0x80000000
rawtx = ToHex(tx)
decrawtx = self.nodes[0].decoderawtransaction(rawtx)
assert_equal(decrawtx['version'], -0x80000000)
# Test the maximum transaction version number that fits in a signed 32-bit integer.
tx = CTransaction()
tx.nVersion = 0x7fffffff
rawtx = ToHex(tx)
decrawtx = self.nodes[0].decoderawtransaction(rawtx)
assert_equal(decrawtx['version'], 0x7fffffff)
self.log.info('sendrawtransaction/testmempoolaccept with maxfeerate')
# Test a transaction with a small fee.
txId = self.nodes[0].sendtoaddress(self.nodes[2].getnewaddress(), 1.0)
rawTx = self.nodes[0].getrawtransaction(txId, True)
vout = next(o for o in rawTx['vout']
if o['value'] == Decimal('1.00000000'))
self.sync_all()
inputs = [{"txid": txId, "vout": vout['n']}]
# Fee 10,000 satoshis, (1 - (10000 sat * 0.00000001 BTC/sat)) = 0.9999
outputs = {self.nodes[0].getnewaddress(): Decimal("0.99990000")}
rawTx = self.nodes[2].createrawtransaction(inputs, outputs)
rawTxSigned = self.nodes[2].signrawtransactionwithwallet(rawTx)
assert_equal(rawTxSigned['complete'], True)
# Fee 10,000 satoshis, ~100 b transaction, fee rate should land around 100 sat/byte = 0.00100000 BTC/kB
# Thus, testmempoolaccept should reject
testres = self.nodes[2].testmempoolaccept([rawTxSigned['hex']],
0.00001000)[0]
assert_equal(testres['allowed'], False)
assert_equal(testres['reject-reason'], 'absurdly-high-fee')
# and sendrawtransaction should throw
assert_raises_rpc_error(-26, "absurdly-high-fee",
self.nodes[2].sendrawtransaction,
rawTxSigned['hex'], 0.00001000)
# and the following calls should both succeed
testres = self.nodes[2].testmempoolaccept(
rawtxs=[rawTxSigned['hex']])[0]
assert_equal(testres['allowed'], True)
self.nodes[2].sendrawtransaction(hexstring=rawTxSigned['hex'])
# Test a transaction with a large fee.
txId = self.nodes[0].sendtoaddress(self.nodes[2].getnewaddress(), 1.0)
rawTx = self.nodes[0].getrawtransaction(txId, True)
vout = next(o for o in rawTx['vout']
if o['value'] == Decimal('1.00000000'))
self.sync_all()
inputs = [{"txid": txId, "vout": vout['n']}]
# Fee 2,000,000 satoshis, (1 - (2000000 sat * 0.00000001 BTC/sat)) = 0.98
outputs = {self.nodes[0].getnewaddress(): Decimal("0.98000000")}
rawTx = self.nodes[2].createrawtransaction(inputs, outputs)
rawTxSigned = self.nodes[2].signrawtransactionwithwallet(rawTx)
assert_equal(rawTxSigned['complete'], True)
# Fee 2,000,000 satoshis, ~100 b transaction, fee rate should land around 20,000 sat/byte = 0.20000000 BTC/kB
# Thus, testmempoolaccept should reject
testres = self.nodes[2].testmempoolaccept([rawTxSigned['hex']])[0]
assert_equal(testres['allowed'], False)
assert_equal(testres['reject-reason'], 'absurdly-high-fee')
# and sendrawtransaction should throw
assert_raises_rpc_error(-26, "absurdly-high-fee",
self.nodes[2].sendrawtransaction,
rawTxSigned['hex'])
# and the following calls should both succeed
testres = self.nodes[2].testmempoolaccept(rawtxs=[rawTxSigned['hex']],
maxfeerate='0.20000000')[0]
assert_equal(testres['allowed'], True)
self.nodes[2].sendrawtransaction(hexstring=rawTxSigned['hex'],
maxfeerate='0.20000000')
def img2str(img):
rawBytes = BytesIO()
img.save(rawBytes, "PNG")
rawBytes.seek(0)
return base64.b64encode(rawBytes.read()).decode('utf-8')
def to_wcs(self, use_full_header=False, target_image=None):
"""
Convert AVM projection information into a Astropy WCS object.
Parameters
----------
use_full_header : bool, optional
Whether to use the full embedded Header if available. If set to
`False`, the WCS is determined from the regular AVM keywords.
target_image : str, optional
In some cases, the dimensions of the image containing the AVM/WCS
information is different from the dimensions of the image for which
the AVM was defined. The `target_image` option can be used to pass
the path of an image from which the size will be used to re-scale
the WCS.
"""
if not astropy_installed:
raise Exception("Astropy is required to use to_wcs()")
if repr(self.Spatial) == '':
raise NoSpatialInformation(
"AVM meta-data does not contain any spatial information")
if use_full_header and self.Spatial.FITSheader is not None:
print("Using full FITS header from Spatial.FITSheader")
header = fits.Header(txtfile=BytesIO(self.Spatial.FITSheader))
return WCS(header)
# Initializing WCS object
wcs = WCS(naxis=2)
# Find the coordinate type
if self.Spatial.CoordinateFrame is not None:
ctype = self.Spatial.CoordinateFrame
else:
warnings.warn("Spatial.CoordinateFrame not found, assuming ICRS")
ctype = 'ICRS'
if ctype in ['ICRS', 'FK5', 'FK4']:
xcoord = "RA--"
ycoord = "DEC-"
wcs.wcs.radesys = ctype.encode('ascii')
elif ctype in ['ECL']:
xcoord = "ELON"
ycoord = "ELAT"
elif ctype in ['GAL']:
xcoord = "GLON"
ycoord = "GLAT"
elif ctype in ['SGAL']:
xcoord = "SLON"
ycoord = "SLAT"
else:
raise Exception("Unknown coordinate system: %s" % ctype)
# Find the projection type
cproj = ('%+4s' % self.Spatial.CoordsystemProjection).replace(' ', '-')
wcs.wcs.ctype[0] = (xcoord + cproj).encode('ascii')
wcs.wcs.ctype[1] = (ycoord + cproj).encode('ascii')
# Find the equinox
if self.Spatial.Equinox is None:
warnings.warn("Spatial.Equinox is not present, assuming 2000")
wcs.wcs.equinox = 2000.
elif type(self.Spatial.Equinox) is str:
if self.Spatial.Equinox == "J2000":
wcs.wcs.equinox = 2000.
elif self.Spatial.Equinox == "B1950":
wcs.wcs.equinox = 1950.
else:
try:
wcs.wcs.equinox = float(self.Spatial.Equinox)
except ValueError:
raise ValueError("Unknown equinox: %s" %
self.Spatial.Equinox)
else:
wcs.wcs.equinox = float(self.Spatial.Equinox)
# Set standard WCS parameters
if self.Spatial.ReferenceDimension is not None:
wcs_naxis1, wcs_naxis2 = self.Spatial.ReferenceDimension
if hasattr(wcs, 'naxis1'): # PyWCS and Astropy < 0.4
wcs.naxis1, wcs.naxis2 = wcs_naxis1, wcs_naxis2
else:
wcs_naxis1, wcs_naxis2 = None, None
wcs.wcs.crval = self.Spatial.ReferenceValue
wcs.wcs.crpix = self.Spatial.ReferencePixel
if self.Spatial.CDMatrix is not None:
wcs.wcs.cd = [
self.Spatial.CDMatrix[0:2], self.Spatial.CDMatrix[2:4]
]
elif self.Spatial.Scale is not None:
# AVM Standard 1.2:
#
# "The scale should follow the standard FITS convention for sky
# projections in which the first element is negative (indicating
# increasing RA/longitude to the left) and the second is positive.
# In practice, only the absolute value of the first term should be
# necessary to identify the pixel scale since images should always
# be presented in an undistorted 1:1 aspect ratio as they appear in
# the sky when viewed from Earth.This field can be populated from
# the FITS keywords: CDELT1, CDELT2 (or derived from CD matrix)."
#
# Therefore, we have to enforce the sign of CDELT:
wcs.wcs.cdelt[0] = -abs(self.Spatial.Scale[0])
wcs.wcs.cdelt[1] = +abs(self.Spatial.Scale[1])
if self.Spatial.Rotation is not None:
wcs.wcs.crota = self.Spatial.Rotation, self.Spatial.Rotation
# If `target_image` is set, we have to rescale the reference pixel and
# the scale
if target_image is not None:
# Find target image size
from PIL import Image
nx, ny = Image.open(target_image).size
if self.Spatial.ReferenceDimension is None:
raise ValueError(
"Spatial.ReferenceDimension should be set in order to determine scale in target image"
)
# Find scale in x and y
scale_x = nx / float(wcs_naxis1)
scale_y = ny / float(wcs_naxis2)
# Check that scales are consistent
if abs(scale_x - scale_y) / (scale_x + scale_y) * 2. < 0.01:
scale = scale_x
else:
raise ValueError(
"Cannot scale WCS to target image consistently in x and y direction"
)
wcs.wcs.cdelt /= scale
wcs.wcs.crpix *= scale
if hasattr(wcs, 'naxis1'): # PyWCS and Astropy < 0.4
wcs.naxis1 = nx
wcs.naxis2 = ny
return wcs
def config_from_string(config_str, portnumfile):
parser = ConfigParser.SafeConfigParser()
parser.readfp(BytesIO(config_str))
return _Config(parser, portnumfile, '<in-memory>')
url1=" "
url2=" "
url3=" "
import json
import requests
str1=input('enter the name of city')
url1="http://api.openweathermap.org/data/2.5/weather?q="
url1=url1+str1
url3="&appid=5bd3b3302e17b1fb27cd720ccebff986"
url1=url1+url3
output=requests.get(url1)
output2=output.json()
#print(output2)
print("cordinate are {} weather is {} Wind Speed {} Sunset Rise{} and Set timing {}".format(output2["coord"],output2["weather"],output2["wind"],output2["sys"]["sunrise"],output2["sys"]["sunset"]))
from PIL import Image
import requests
from io import BytesIO
url = "http://forsk.in/images/Forsk_logo_bw.png"
response = requests.get(url)
img = Image.open(BytesIO(response.content))
img.save("forsk-logo.png")
def chunk(cid, *data):
test_file = BytesIO()
PngImagePlugin.putchunk(*(test_file, cid) + data)
return test_file.getvalue()
async def handler(event):
if event.fwd_from:
return
if not event.is_reply:
await event.edit("Reply to a photo/sticker to kang it.")
return
await event.edit(
"```Me kanging your shitty stickers and you can't do anything about that shitty hooman...```"
)
reply_message = await event.get_reply_message()
sticker_emoji = "🔥"
pack_id = ""
input_str = event.pattern_match.group(1)
if input_str:
input_str = input_str.split()
is_int = False
for char in input_str:
try:
is_int = int(char)
except:
is_int = False
sticker_emoji = char
if is_int:
pack_id = char
botuser = await client.get_me()
botuser = f"@{botuser.username}"
userid = event.from_id
if ENV.STICKER_PACK is None:
if not pack_id:
pack_id = 1
packname = f"{botuser}'s kang pack vol.{pack_id}"
packshortname = f"cyberdoge_kang_pack_vol{pack_id}_{userid}"
else:
if pack_id:
pack_id = f" {pack_id}"
packname = f"{ENV.STICKER_PACK}{pack_id}"
packshortname = f"Uniborg_Pack{pack_id}_{userid}"
is_a_s = is_it_animated_sticker(reply_message)
file_ext_ns_ion = "@CyberDoge_Sticker.png"
file = await client.download_file(reply_message.media)
uploaded_sticker = None
if is_a_s:
file_ext_ns_ion = "@CyberDoge_ANIMATED.tgs"
uploaded_sticker = await client.upload_file(file,
file_name=file_ext_ns_ion)
packname = f"{packname} [ANIMATED]"
packshortname = f"{packshortname}_animated"
elif not is_message_image(reply_message):
await event.edit("Invalid message type")
return
else:
with BytesIO(file) as mem_file, BytesIO() as sticker:
resize_image(mem_file, sticker)
sticker.seek(0)
uploaded_sticker = await client.upload_file(
sticker, file_name=file_ext_ns_ion)
async with client.conversation("@Stickers") as bot_conv:
now = datetime.datetime.now()
dt = now + datetime.timedelta(minutes=1)
if not await stickerset_exists(bot_conv, packshortname):
await silently_send_message(bot_conv, "/cancel")
if is_a_s:
response = await silently_send_message(bot_conv,
"/newanimated")
else:
response = await silently_send_message(bot_conv, "/newpack")
if "Yay!" not in response.text:
await event.edit(
f"**FAILED**! @Stickers replied: {response.text}")
return
response = await silently_send_message(bot_conv, packname)
if not response.text.startswith("Alright!"):
await event.edit(
f"{packname} is full, try .kang <optional_emoji> {pack_id+1}"
)
return
w = await bot_conv.send_file(file=uploaded_sticker,
allow_cache=False,
force_document=True)
response = await bot_conv.get_response()
if "Sorry" in response.text:
await event.edit(
f"**FAILED**! @Stickers replied: {response.text}")
return
await silently_send_message(bot_conv, sticker_emoji)
await silently_send_message(bot_conv, "/publish")
response = await silently_send_message(bot_conv, f"<{packname}>")
await silently_send_message(bot_conv, "/skip")
response = await silently_send_message(bot_conv, packshortname)
if response.text == "Sorry, this short name is already taken.":
await event.edit(
f"**FAILED**! @Stickers replied: {response.text}")
return
else:
await silently_send_message(bot_conv, "/cancel")
await silently_send_message(bot_conv, "/addsticker")
response = await silently_send_message(bot_conv, packshortname)
if "Whoa!" in response.text:
await event.edit(
f"{packname} is full, try .kang <optional_emoji> {int(pack_id) + 1}"
)
return
await bot_conv.send_file(file=uploaded_sticker,
allow_cache=False,
force_document=True)
response = await bot_conv.get_response()
if "Sorry" in response.text:
await event.edit(
f"**FAILED**! @Stickers replied: {response.text}")
return
await silently_send_message(bot_conv, response)
await silently_send_message(bot_conv, sticker_emoji)
await silently_send_message(bot_conv, "/done")
await event.edit(
f"Sticker successfully kanged to [{packname}](t.me/addstickers/{packshortname})!"
)
def load(data):
return Image.open(BytesIO(data))
async def analyze(request):
data = await request.form()
img_bytes = await (data['file'].read())
img = open_image(BytesIO(img_bytes))
return JSONResponse({'result': learn.predict(img)[0]})
def form_01(request_data):
"""
Форма 003/у - cстационарная карта
"""
num_dir = request_data["dir_pk"]
direction_obj = Napravleniya.objects.get(pk=num_dir)
hosp_nums_obj = hosp_get_hosp_direction(num_dir)
hosp_nums = f"- {hosp_nums_obj[0].get('direction')}"
ind_card = direction_obj.client
patient_data = ind_card.get_data_individual()
hospital: Hospitals = request_data["hospital"]
hospital_name = hospital.safe_short_title
hospital_address = hospital.safe_address
hospital_kod_ogrn = hospital.safe_ogrn
if sys.platform == 'win32':
locale.setlocale(locale.LC_ALL, 'rus_rus')
else:
locale.setlocale(locale.LC_ALL, 'ru_RU.UTF-8')
pdfmetrics.registerFont(
TTFont('PTAstraSerifBold',
os.path.join(FONTS_FOLDER, 'PTAstraSerif-Bold.ttf')))
pdfmetrics.registerFont(
TTFont('PTAstraSerifReg',
os.path.join(FONTS_FOLDER, 'PTAstraSerif-Regular.ttf')))
buffer = BytesIO()
doc = SimpleDocTemplate(buffer,
pagesize=A4,
leftMargin=20 * mm,
rightMargin=12 * mm,
topMargin=6 * mm,
bottomMargin=4 * mm,
allowSplitting=1,
title="Форма {}".format("003/у"))
width, height = portrait(A4)
styleSheet = getSampleStyleSheet()
style = styleSheet["Normal"]
style.fontName = "PTAstraSerifReg"
style.fontSize = 12
style.leading = 15
style.spaceAfter = 0.5 * mm
styleLead = deepcopy(style)
styleLead.leading = 12
styleLead.alignment = TA_JUSTIFY
styleBold = deepcopy(style)
styleBold.fontName = "PTAstraSerifBold"
styleCenter = deepcopy(style)
styleCenter.alignment = TA_CENTER
styleCenter.fontSize = 12
styleCenter.leading = 15
styleCenter.spaceAfter = 1 * mm
styleCenterBold = deepcopy(styleBold)
styleCenterBold.alignment = TA_CENTER
styleCenterBold.fontSize = 12
styleCenterBold.leading = 15
styleCenterBold.face = 'PTAstraSerifBold'
styleCenterBold.borderColor = black
styleJustified = deepcopy(style)
styleJustified.alignment = TA_JUSTIFY
styleJustified.spaceAfter = 4.5 * mm
styleJustified.fontSize = 12
styleJustified.leading = 4.5 * mm
styleRight = deepcopy(styleJustified)
styleRight.alignment = TA_RIGHT
objs = []
styleT = deepcopy(style)
styleT.alignment = TA_LEFT
styleT.fontSize = 10
styleT.leading = 4.5 * mm
styleT.face = 'PTAstraSerifReg'
print_district = ''
if SettingManager.get("district", default='True', default_type='b'):
if ind_card.district is not None:
print_district = 'Уч: {}'.format(ind_card.district.title)
opinion = [
[
Paragraph(
'<font size=11>{}<br/>Адрес: {}<br/>ОГРН: {} <br/><u>{}</u> </font>'
.format(hospital_name, hospital_address, hospital_kod_ogrn,
print_district), styleT),
Paragraph(
'<font size=9 >Код формы по ОКУД:<br/>Код организации по ОКПО: 31348613<br/>'
'Медицинская документация<br/>форма № 003/у</font>', styleT),
],
]
tbl = Table(opinion, 2 * [90 * mm])
tbl.setStyle(
TableStyle([
('GRID', (0, 0), (-1, -1), 0.75, colors.white),
('LEFTPADDING', (1, 0), (-1, -1), 80),
('VALIGN', (0, 0), (-1, -1), 'TOP'),
]))
objs.append(tbl)
space_symbol = ' '
if patient_data['age'] < SettingManager.get(
"child_age_before", default='15', default_type='i'):
patient_data['serial'] = patient_data['bc_serial']
patient_data['num'] = patient_data['bc_num']
else:
patient_data['serial'] = patient_data['passport_serial']
patient_data['num'] = patient_data['passport_num']
p_phone = ''
if patient_data['phone']:
p_phone = 'тел.: ' + ", ".join(patient_data['phone'])
p_address = patient_data['main_address']
work_place = patient_data['work_place_db'] if patient_data[
'work_place_db'] else patient_data['work_place']
p_work = work_place
card_num_obj = patient_data['card_num'].split(' ')
p_card_num = card_num_obj[0]
# взять самое последнее направленеие из hosp_dirs
hosp_last_num = hosp_nums_obj[-1].get('direction')
############################################################################################################
# Получение данных из выписки
# Взять услугу типа выписка. Из полей "Дата выписки" - взять дату. Из поля "Время выписки" взять время
hosp_extract_data = hosp_extract_get_data(hosp_last_num)
extrac_date, extract_time, final_diagnos, other_diagnos, near_diagnos, outcome, doc_fio, manager_depart, room_num, depart_extract = '', '', '', '', '', '', '', '', '', ''
days_count = '__________________________'
if hosp_extract_data:
extrac_date = hosp_extract_data['date_value']
extract_time = hosp_extract_data['time_value']
final_diagnos = hosp_extract_data['final_diagnos']
other_diagnos = hosp_extract_data['other_diagnos']
near_diagnos = hosp_extract_data['near_diagnos']
days_count = hosp_extract_data['days_count']
if hosp_extract_data['outcome']:
outcome = hosp_extract_data['outcome'] + ' (' + hosp_extract_data[
'result_hospital'] + ')'
doc_fio = hosp_extract_data['doc_fio']
manager_depart = hosp_extract_data['manager_depart']
room_num = hosp_extract_data['room_num']
iss_last_hosp = Issledovaniya.objects.filter(
napravleniye__pk=hosp_last_num)[0]
depart_extract = iss_last_hosp.research.title
# Получить отделение - из названия услуги или самого главного направления
hosp_depart = hosp_nums_obj[0].get('research_title')
############################################################################################################
# Получить данные из первичного приема (самого первого hosp-направления)
hosp_first_num = hosp_nums_obj[0].get('direction')
primary_reception_data = primary_reception_get_data(hosp_first_num)
###########################################################################################################
# Получение данных группы крови
fcaction_avo_id = Fractions.objects.filter(
title='Групповая принадлежность крови по системе АВО').first()
fcaction_rezus_id = Fractions.objects.filter(title='Резус').first()
group_blood_avo = get_fraction_result(ind_card.pk,
fcaction_avo_id.pk,
count=1)
if group_blood_avo:
group_blood_avo_value = group_blood_avo[0][5]
else:
group_blood_avo_value = primary_reception_data['blood_group']
group_blood_rezus = get_fraction_result(ind_card.pk,
fcaction_rezus_id.pk,
count=1)
if group_blood_rezus:
group_rezus_value = group_blood_rezus[0][5].replace('<br/>', ' ')
else:
group_rezus_value = primary_reception_data['resus_factor']
###########################################################################################################
# получение данных клинического диагноза
clinical_diagnos = hosp_get_clinical_diagnos(hosp_nums_obj)
#####################################################################################################
# получить даные из переводного эпикриза: Дата перевода, Время перевода, в какое отделение переведен
# у каждого hosp-направления найти подчиненное эпикриз Перевод*
transfers_data = hosp_get_transfers_data(hosp_nums_obj)
transfers = ''
for i in transfers_data:
transfers = f"{transfers} в {i['transfer_research_title']} {i['date_transfer_value']}/{i['time_transfer_value']};"
#####################################################################################################
title_page = [
Indenter(left=0 * mm),
Spacer(1, 8 * mm),
Paragraph(
'<font fontname="PTAstraSerifBold" size=15>МЕДИЦИНСКАЯ КАРТА № {} <u>{}</u>, <br/> стационарного больного</font>'
.format(p_card_num, hosp_nums), styleCenter),
Spacer(1, 2 * mm),
Spacer(1, 2 * mm),
Spacer(1, 2 * mm),
Paragraph(
'Дата и время поступления: {} - {}'.format(
primary_reception_data['date_entered_value'],
primary_reception_data['time_entered_value']), style),
Spacer(1, 0.5 * mm),
Paragraph(
'Дата и время выписки: {} - {}'.format(extrac_date, extract_time),
style),
Spacer(1, 0.5 * mm),
Paragraph('Отделение: {}'.format(hosp_depart), style),
Spacer(1, 0.5 * mm),
Paragraph(f"Палата №: {room_num} {depart_extract}", style),
Spacer(1, 0.5 * mm),
Paragraph('Переведен в отделение:', style),
Spacer(1, 8 * mm),
Paragraph('Проведено койко-дней: {}'.format(days_count), style),
Spacer(1, 0.5 * mm),
Paragraph(
'Виды транспортировки(на каталке, на кресле, может идти): {}'.
format(primary_reception_data['type_transport']), style),
Spacer(1, 0.5 * mm),
Paragraph(
'Группа крови: {}. Резус-принадлежность: {}'.format(
group_blood_avo_value, group_rezus_value), style),
Spacer(1, 1 * mm),
Paragraph('Побочное действие лекарств(непереносимость):', style),
Spacer(1, 12 * mm),
Paragraph("1. Фамилия, имя, отчество: ", style),
Spacer(1, 2 * mm),
Paragraph(
'2. Пол: {} {} 3. Дата рождения: {}'.format(
patient_data['sex'], 3 * space_symbol, patient_data['born']),
style),
Spacer(1, 0.5 * mm),
Paragraph('4. Постоянное место жительства: ', style),
Spacer(1, 3.5 * mm),
Paragraph('5. Место работы, профессия или должность:', style),
Spacer(1, 0.5 * mm),
Paragraph('6. Кем направлен больной:', style),
Spacer(1, 0.5 * mm),
Paragraph(
'7. Доставлен в стационар по экстренным показаниям: {}'.format(
primary_reception_data['extra_hospital']), style),
Spacer(1, 0.5 * mm),
Paragraph(
' через: {} после начала заболевания, получения травмы; '.format(
primary_reception_data['time_start_ill']), style),
Spacer(1, 0.5 * mm),
Paragraph(
' госпитализирован в плановом порядке (подчеркнуть) {}.'.format(
primary_reception_data['plan_hospital']), style),
Spacer(1, 0.5 * mm),
Paragraph('8. Диагноз направившего учреждения:', style),
Spacer(1, 8 * mm),
Paragraph('9. Диагноз при поступлении:', style),
Spacer(1, 10 * mm),
Paragraph('10. Диагноз клинический:', style),
PageBreak(),
]
closed_bl_result = closed_bl(hosp_nums_obj[0].get('direction'))
data_bl = ''
if closed_bl_result['start_date'] and closed_bl_result[
'end_date'] and closed_bl_result['num']:
data_bl = (
f"<br/>открыт <u>{closed_bl_result['start_date']}</u>{5 * space_symbol}закрыт: <u>{closed_bl_result['end_date']}</u> {3 * space_symbol}"
f"к труду: <u>{closed_bl_result['start_work']}</u> <br/>Номер ЛН: <u>{closed_bl_result['num']}</u> Выдан кому: {closed_bl_result['who_get']} "
)
second_page = [
Spacer(1, 2 * mm),
Paragraph('11. Диагноз заключительный клинический:', style),
Spacer(1, 0.5 * mm),
Paragraph('а) основной:', style),
Spacer(1, 45 * mm),
Paragraph('б) осложнение основного:', style),
Spacer(1, 18 * mm),
Paragraph('в) сопутствующий:', style),
Spacer(1, 19 * mm),
Paragraph(
'12. Госпитализирован в данном году по поводу данного заболевания: {}, <br/>'
'всего - {} раз.:'.format(
primary_reception_data['what_time_hospitalized'],
primary_reception_data['all_hospitalized']),
styleLead,
),
Spacer(1, 1 * mm),
Paragraph(
'13. Хирургические операции, методы обезболивания и послеоперационные осложнения:',
styleLead),
Spacer(1, 40 * mm),
Paragraph(
'14. Другие виды лечения:___________________________________________',
styleLead),
Spacer(1, 0.2 * mm),
Paragraph('для больных злокачественными новообразованиями.',
styleLead),
Spacer(1, 0.2 * mm),
Paragraph(
' 1.Специальное лечение: хирургическое(дистанционная гамматерапия, рентгенотерапия, быстрые '
'электроны, контактная и дистанционная гамматерапия, контактная гамматерапия и глубокая '
'рентгенотерапия); комбинированное(хирургическое и гамматерапия, хирургическое и рентгено - '
'терапия, хирургическое и сочетанное лучевое); химиопрепаратами, гормональными препаратами.',
styleLead,
),
Spacer(1, 1 * mm),
Paragraph('2. Паллиативное', styleLead),
Spacer(1, 0.2 * mm),
Paragraph('3. Симптоматическое лечение.', styleLead),
Spacer(1, 0.2 * mm),
Paragraph(f"15. Отметка о выдаче листка нетрудоспособности:{data_bl}",
styleLead),
Spacer(1, 1 * mm),
Paragraph('16. Исход заболевания: {}'.format(outcome), styleLead),
Spacer(1, 1 * mm),
Paragraph(
'17. Трудоспособность восстановлена полностью, снижена, временно утрачена, стойко утрачена в связи '
'с данным заболеванием, с другими причинами(подчеркнуть): {}'.
format(''),
styleLead,
),
Spacer(1, 1 * mm),
Paragraph(
'18. Для поступивших на экспертизу - заключение:___________________',
styleLead),
Spacer(1, 1 * mm),
Paragraph(
'___________________________________________________________________',
styleLead),
Spacer(1, 1 * mm),
Paragraph('19. Особые отметки', style),
Spacer(1, 2 * mm),
Paragraph('Лечащий врач: {}'.format(doc_fio), style),
Paragraph('Заведующий отделением: {}'.format(manager_depart), style),
]
if primary_reception_data['weight']:
second_page.append(
Paragraph(f"Вес: {primary_reception_data['weight']}", styleRight))
objs.extend(title_page)
objs.extend(second_page)
closed_bl_result = closed_bl(hosp_nums_obj[0].get('direction'))
def first_pages(canvas, document):
canvas.saveState()
if closed_bl_result.get('is_closed', None):
canvas.setFont('PTAstraSerifBold', 12)
canvas.drawString(7 * mm, 290 * mm, 'ЛН')
# Переведен
transfers_text = [Paragraph('{}'.format(transfers), styleJustified)]
transfers_frame = Frame(27 * mm,
206 * mm,
175 * mm,
7 * mm,
leftPadding=0,
bottomPadding=0,
rightPadding=0,
topPadding=0,
id='diagnos_frame',
showBoundary=0)
transfers_inframe = KeepInFrame(
175 * mm,
12 * mm,
transfers_text,
hAlign='LEFT',
vAlign='TOP',
)
transfers_frame.addFromList([transfers_inframe], canvas)
# Побочное действие лекарств(непереносимость) координаты
medicament_text = [
Paragraph(
'{}'.format(primary_reception_data['medicament_allergy']),
styleJustified)
]
medicament_frame = Frame(27 * mm,
171 * mm,
175 * mm,
9 * mm,
leftPadding=0,
bottomPadding=0,
rightPadding=0,
topPadding=0,
id='diagnos_frame',
showBoundary=0)
medicament_inframe = KeepInFrame(
175 * mm,
12 * mm,
medicament_text,
hAlign='LEFT',
vAlign='TOP',
)
medicament_frame.addFromList([medicament_inframe], canvas)
# ФИО
fio_text = [
Paragraph(
"<font size=11.7 fontname ='PTAstraSerifBold'> {}</font> ".
format(patient_data['fio']), style)
]
fio_frame = Frame(77 * mm,
159 * mm,
125 * mm,
8 * mm,
leftPadding=0,
bottomPadding=0,
rightPadding=0,
topPadding=0,
id='diagnos_frame',
showBoundary=0)
fio_inframe = KeepInFrame(
175 * mm,
12 * mm,
fio_text,
hAlign='LEFT',
vAlign='TOP',
)
fio_frame.addFromList([fio_inframe], canvas)
# Постоянное место жительства
live_text = [Paragraph('{}, {}'.format(p_address, p_phone), style)]
live_frame = Frame(88 * mm,
144 * mm,
115 * mm,
9 * mm,
leftPadding=0,
bottomPadding=0,
rightPadding=0,
topPadding=0,
id='diagnos_frame',
showBoundary=0)
live_inframe = KeepInFrame(
175 * mm,
12 * mm,
live_text,
hAlign='LEFT',
vAlign='TOP',
)
live_frame.addFromList([live_inframe], canvas)
# Место работы
work_text = [Paragraph('{}'.format(p_work), style)]
work_frame = Frame(108 * mm,
138.5 * mm,
95 * mm,
5 * mm,
leftPadding=0,
bottomPadding=0,
rightPadding=0,
topPadding=0,
id='diagnos_frame',
showBoundary=0)
work_inframe = KeepInFrame(
175 * mm,
12 * mm,
work_text,
hAlign='LEFT',
vAlign='TOP',
)
work_frame.addFromList([work_inframe], canvas)
# Кем направлен больной
who_directed_text = [
Paragraph('{}'.format(primary_reception_data['who_directed']),
style)
]
who_directed_frame = Frame(77 * mm,
129.5 * mm,
126 * mm,
7 * mm,
leftPadding=0,
bottomPadding=0,
rightPadding=0,
topPadding=0,
id='diagnos_frame',
showBoundary=0)
who_directed_inframe = KeepInFrame(
175 * mm,
12 * mm,
who_directed_text,
hAlign='LEFT',
vAlign='TOP',
)
who_directed_frame.addFromList([who_directed_inframe], canvas)
# Диагноз направившего учреждения координаты
diagnos_directed_text = [
Paragraph(
'{}'.format(primary_reception_data['diagnos_who_directed']),
styleJustified)
]
diagnos_directed_frame = Frame(27 * mm,
98 * mm,
175 * mm,
9 * mm,
leftPadding=0,
bottomPadding=0,
rightPadding=0,
topPadding=0,
id='diagnos_frame',
showBoundary=0)
diagnos_directed_inframe = KeepInFrame(
175 * mm,
10 * mm,
diagnos_directed_text,
hAlign='LEFT',
vAlign='TOP',
)
diagnos_directed_frame.addFromList([diagnos_directed_inframe], canvas)
# Диагноз при поступлении координаты
diagnos_entered_text = [
Paragraph('{}'.format(primary_reception_data['diagnos_entered']),
styleJustified)
]
diagnos_entered_frame = Frame(27 * mm,
83 * mm,
175 * mm,
10 * mm,
leftPadding=0,
bottomPadding=0,
rightPadding=0,
topPadding=0,
id='diagnos_frame',
showBoundary=0)
diagnos_entered_inframe = KeepInFrame(
175 * mm,
10 * mm,
diagnos_entered_text,
hAlign='LEFT',
vAlign='TOP',
)
diagnos_entered_frame.addFromList([diagnos_entered_inframe], canvas)
# клинический диагноз координаты
diagnos_text = [
Paragraph('{}'.format(clinical_diagnos), styleJustified)
]
diagnos_frame = Frame(27 * mm,
22 * mm,
175 * mm,
55 * mm,
leftPadding=0,
bottomPadding=0,
rightPadding=0,
topPadding=0,
id='diagnos_frame',
showBoundary=0)
diagnos_inframe = KeepInFrame(175 * mm, 55 * mm, diagnos_text)
diagnos_frame.addFromList([diagnos_inframe], canvas)
# представитель пациента
p_agent = None
agent_status = ''
agent = ''
if ind_card.who_is_agent:
p_agent = getattr(ind_card, ind_card.who_is_agent)
agent_status = ind_card.get_who_is_agent_display()
if p_agent:
agent_data = p_agent.get_data_individual()
agent_fio = agent_data['fio']
agent_phone = ','.join(agent_data['phone'])
agent = f"{agent_status}: {agent_fio}, тел.:{agent_phone}"
agent_text = [Paragraph('<u>{}</u>'.format(agent), styleRight)]
agent_frame = Frame(27 * mm,
5 * mm,
175 * mm,
7 * mm,
leftPadding=0,
bottomPadding=0,
rightPadding=0,
topPadding=0,
id='diagnos_frame',
showBoundary=0)
agent_inframe = KeepInFrame(175 * mm, 10 * mm, agent_text)
agent_frame.addFromList([agent_inframe], canvas)
canvas.restoreState()
# Получить все услуги из категории операции
styleTO = deepcopy(style)
styleTO.alignment = TA_LEFT
styleTO.firstLineIndent = 0
styleTO.fontSize = 9.5
styleTO.leading = 10
styleTO.spaceAfter = 0.2 * mm
# Таблица для операции
opinion_oper = [[
Paragraph('№', styleTO),
Paragraph('Название операции', styleTO),
Paragraph('Дата,   час', styleTO),
Paragraph('Метод обезболивания', styleTO),
Paragraph('Осложнения', styleTO),
Paragraph('Оперировал', styleTO),
]]
hosp_operation = hosp_get_operation_data(num_dir)
x = 0
operation_result = []
for i in hosp_operation:
operation_template = [''] * 6
x += 1
operation_template[0] = Paragraph(str(x), styleTO)
operation_template[1] = Paragraph(
f"{i['name_operation']} <br/><font face=\"PTAstraSerifBold\" size=\"8.7\">({i['category_difficult']})</font>",
styleTO)
operation_template[2] = Paragraph(
i['date'] + '<br/>' + i['time_start'] + '-' + i['time_end'],
styleTO)
operation_template[3] = Paragraph(i['anesthesia method'], styleTO)
operation_template[4] = Paragraph(i['complications'], styleTO)
operation_template[5] = Paragraph(i['doc_fio'], styleTO)
operation_result.append(operation_template.copy())
opinion_oper.extend(operation_result)
t_opinion_oper = opinion_oper.copy()
tbl_o = Table(
t_opinion_oper,
colWidths=(
7 * mm,
62 * mm,
25 * mm,
30 * mm,
15 * mm,
45 * mm,
),
)
tbl_o.setStyle(
TableStyle([
('GRID', (0, 0), (-1, -1), 1.0, colors.black),
('BOTTOMPADDING', (0, 0), (-1, -1), 2.1 * mm),
('VALIGN', (0, 0), (-1, -1), 'MIDDLE'),
]))
def later_pages(canvas, document):
canvas.saveState()
# Заключительные диагнозы
# Основной заключительный диагноз
final_diagnos_text = [
Paragraph('{}'.format(final_diagnos), styleJustified)
]
final_diagnos_frame = Frame(27 * mm,
230 * mm,
175 * mm,
45 * mm,
leftPadding=0,
bottomPadding=0,
rightPadding=0,
topPadding=0,
showBoundary=0)
final_diagnos_inframe = KeepInFrame(
175 * mm,
50 * mm,
final_diagnos_text,
hAlign='LEFT',
vAlign='TOP',
)
final_diagnos_frame.addFromList([final_diagnos_inframe], canvas)
# Осложнения основного заключительного диагноза
other_diagnos_text = [
Paragraph('{}'.format(other_diagnos), styleJustified)
]
other_diagnos_frame = Frame(27 * mm,
205 * mm,
175 * mm,
20 * mm,
leftPadding=0,
bottomPadding=0,
rightPadding=0,
topPadding=0,
showBoundary=0)
other_diagnos_inframe = KeepInFrame(
175 * mm,
20 * mm,
other_diagnos_text,
hAlign='LEFT',
vAlign='TOP',
)
other_diagnos_frame.addFromList([other_diagnos_inframe], canvas)
# Сопутствующие основного заключительного диагноза
near_diagnos_text = [
Paragraph(
'{}'.format(
near_diagnos.replace('<', '<').replace('>', '>')),
styleJustified)
]
near_diagnos_frame = Frame(27 * mm,
181 * mm,
175 * mm,
20 * mm,
leftPadding=0,
bottomPadding=0,
rightPadding=0,
topPadding=0,
showBoundary=0)
near_diagnos_inframe = KeepInFrame(
175 * mm,
20 * mm,
near_diagnos_text,
vAlign='TOP',
)
near_diagnos_frame.addFromList([near_diagnos_inframe], canvas)
# Таблица операции
operation_text = [tbl_o]
operation_frame = Frame(22 * mm,
123 * mm,
170 * mm,
40 * mm,
leftPadding=0,
bottomPadding=0,
rightPadding=0,
topPadding=0,
showBoundary=0)
operation_inframe = KeepInFrame(175 * mm,
40 * mm,
operation_text,
hAlign='CENTRE',
vAlign='TOP',
fakeWidth=False)
operation_frame.addFromList([operation_inframe], canvas)
canvas.setFont('PTAstraSerifBold', 8)
hospital: Hospitals = request_data["hospital"]
hospital_name = hospital.safe_short_title
canvas.drawString(55 * mm, 12 * mm, '{}'.format(hospital_name))
canvas.drawString(
55 * mm, 9 * mm,
'№ карты : {}; Номер истории: {}'.format(p_card_num, hosp_nums))
canvas.drawString(
55 * mm, 6 * mm, 'Пациент: {} {}'.format(patient_data['fio'],
patient_data['born']))
canvas.line(55 * mm, 11.5 * mm, 200 * mm, 11.5 * mm)
canvas.restoreState()
doc.build(objs, onFirstPage=first_pages, onLaterPages=later_pages)
pdf = buffer.getvalue()
buffer.close()
return pdf
