alive progress
1.0.0
Pernahkah Anda bertanya-tanya di mana proses panjang Anda berlangsung, dan kapan akan selesai? Apakah Anda biasanya menekan RETURN beberapa kali untuk memastikan tidak crash, atau koneksi SSH tidak macet? Pernahkah Anda berpikir akan luar biasa jika bisa menjeda beberapa pemrosesan tanpa kerumitan, kembali ke perintah Python untuk memperbaiki beberapa item secara manual, lalu melanjutkannya dengan lancar ? Ya...
Saya telah memulai bilah kemajuan baru ini dengan memikirkan semua itu, lihatlah kemajuan yang hidup ! ?
Memperkenalkan konsep terbaru di bilah kemajuan untuk Python! alive-progress memiliki kelas tersendiri, dengan serangkaian fitur keren yang membedakannya. Berikut beberapa hal penting:
check() super canggih yang membantu Anda mendesain animasi Anda sendiri! Anda dapat melihat bagaimana bingkai dan siklus animasi yang dihasilkan akan terlihat, meledak di layar Anda, dan bahkan melihatnya hidup sebelum dipasang dalam alive-progress ! Ini adalah alat paling keren di dunia! Bebaskan kreativitas Anda! README ini selalu berkembang, jadi lihatlah secara lebih komprehensif dari waktu ke waktu... Anda mungkin menemukan detail baru yang menarik di bagian lain! ?
alive-progressbar() yang berbeda Setelah sekitar satu tahun menjaga stabilitas, alive-progress akhirnya tercapai!
Fitur utama dan peningkatannya adalah:
bar() dengan 0 dan bahkan -N untuk membuatnya mundur! Berguna ketika Anda tidak dapat membuat kemajuan apa pun dalam sebuah iterasi atau harus memutar kembali sesuatu!Dan banyak lagi!
enrich_offset khusus yang akan digunakan untuk pesan yang dicetak atau dicatat, memungkinkan Anda memulai dengan on 1: atau melanjutkan dari perhitungan sebelumnya! Pembaruan yang sangat keren di sini! Selain menyempurnakan dan meningkatkan dukungan terminal, kini alive-progress mendukung melanjutkan komputasi!
Saat memproses kumpulan data besar atau hal-hal yang memerlukan waktu lama, Anda dapat menggunakan batch atau menyimpan sebagian hasil. Kemudian, jika berhenti dan dimulai ulang, Anda akhirnya melewatkan semua item yang sudah selesai dengan sangat cepat, yang membuat alive_bar mengira Anda sedang memproses ribuan item per detik, yang pada gilirannya merusak ETA... Tapi sekarang tidak lagi ! Katakan saja pada bar() bahwa Anda telah melewatkan item... ?
Anda dapat menggunakannya dengan dua cara:
1. Jika Anda tahu di mana Anda berhenti:
with alive_bar ( 120000 ) as bar :
bar ( 60000 , skipped = True )
for i in range ( 60000 , 120000 ):
# process item
bar () Yap, panggil saja bar(N, skipped=True) satu kali, dengan jumlah itemnya.
2. Jika tidak tahu atau barangnya berserakan:
with alive_bar ( 120000 ) as bar :
for i in range ( 120000 ):
if done ( i ):
bar ( skipped = True )
continue
# process item
bar () Ya, sesederhana itu! Panggil saja bar(skipped=True) ketika suatu item sudah selesai, atau bar() seperti biasa. Anda juga dapat membagikan satu panggilan bar(skipped=?) di akhir, dengan bool yang menyatakan apakah Anda melewatkan item itu atau tidak. Keren, ya?
Juga dalam versi ini:
max_cols baru, jumlah kolom yang akan digunakan jika tidak memungkinkan untuk mengambilnya, seperti di jupyter dan platform lain yang tidak mendukung ukuranYap, saya akhirnya bisa mengeluarkan versi ini! Ini adalah barang barunya:
B , bytes , atau bahkan °C !sys.stderr dan file lain selain sys.stdout !Perbaikan yang sangat dinanti:
TypeError: unhashable type: 'types.SimpleNamespace' .RotatingFileHandler s! Yap, mencari dukungan ada di sini.Dan yang tak kalah pentingnya, tata letak yang lebih halus agar Anda dapat menikmati kemajuan Anda!
Sekarang, alive_bar mendukung mode teks Dual Line !
Jika Anda ingin memasukkan pesan situasional yang lebih panjang ke dalam bilah, Anda mungkin merasa terjepit dalam satu baris. Anda harus mengecilkan bilah animasi yang indah atau, lebih buruk lagi, menghapus widget (!) untuk dapat melihat apa yang Anda butuhkan...
Tidak lagi!! Anda sekarang dapat membuat bilah Garis Ganda , dan meletakkan teks di bawahnya!
Ya, ada pesan di bawah keseluruhan bilah, dan pesan cetak/pencatatan lainnya gulir ke atasnya!
letters = [ chr ( ord ( 'A' ) + x ) for x in range ( 26 )]
with alive_bar ( 26 , dual_line = True , title = 'Alphabet' ) as bar :
for c in letters :
bar . text = f'-> Teaching the letter: { c } , please wait...'
if c in 'HKWZ' :
print ( f'fail " { c } ", retry later' )
time . sleep ( 0.3 )
bar ()Keluaran:
on 7: fail "H", retry later
on 10: fail "K", retry later
Alphabet |███████████████████████████▊ | ▃▅▇ 18/26 [69%] in 6s (3.2/s, eta: 3s)
-> Teaching the letter: S, please wait...
Ada juga parameter fungsi finalize baru di alive_it yang memungkinkan Anda mengatur judul dan/atau teks tanda terima akhir, dan dukungan logging yang ditingkatkan yang mendeteksi logger yang disesuaikan.
Ini semua tentang penyesuaian; widget inti sekarang dapat diubah:
monitor , elapsed , dan stats agar terlihat sesuai keinginan Anda!Sungguh luar biasa bahwa string ini mendukung semua fitur format Python, sehingga Anda dapat misalnya,
{percent:.1%}.
Mereka dapat dikustomisasi lebih lanjut saat berada di tanda terima akhir !
monitor_end , elapsed_end , dan stats_end baru, dengan format dinamis yang diwarisi dari format standar!Jika Anda pernah menyembunyikan beberapa widget sebelumnya, supaya tidak muncul di tanda terima, sekarang Anda dapat melihatnya dengan segala kemegahannya, dan hanya menyembunyikan widget tanda terima! Atau sebaliknya?
Tambahan lainnya, sekarang alive-progress dengan indah menampilkan tanda terima akhirnya yang keren setiap kali dihentikan, bahkan jika Anda CTRL+C sebelum waktunya! Entah kenapa aku tidak memikirkan hal itu sebelumnya...
Download |██████████████████︎ | (!) 45/100 [45%] in 4.8s (9.43/s)
Dan terakhir, Anda dapat memilih untuk menonaktifkan CTRL+C sama sekali! Standarnya adalah ctrl_c=True yang lebih aman, yang membuat CTRL-C berfungsi seperti biasa.
Nonaktifkan ctrl_c=False , untuk membuat alive_bar interaktif Anda lebih lancar untuk digunakan (tidak ada jejak tumpukan jika Anda menghentikannya), dan/atau jika itu berada di level teratas program Anda!
Hati-hati: Jika misalnya berada di dalam for-loop, itu hanya akan melanjutkan ke iterasi berikutnya, yang mungkin Anda inginkan atau tidak...
for i in range ( 10 ):
with alive_bar ( 100 , ctrl_c = False , title = f'Download { i } ' ) as bar :
for i in range ( 100 ):
time . sleep ( 0.02 )
bar ()Keluaran:
Download 0 |████████▊︎ | (!) 22/100 [22%] in 0.6s (36.40/s)
Download 1 |████████████████▊︎ | (!) 42/100 [42%] in 1.0s (41.43/s)
Download 2 |██████▍︎ | (!) 16/100 [16%] in 0.4s (39.29/s)
Download 3 |█████▋︎ | (!) 14/100 [14%] in 0.4s (33.68/s)
Download 4 |█████████████▎︎ | (!) 33/100 [33%] in 0.8s (39.48/s)
Download 5 |███████▎︎ | (!) 18/100 [18%] in 0.5s (37.69/s)
Download 6 |█████▎︎ | (!) 13/100 [13%] in 0.3s (37.28/s)
Download 7 |████████████︎ | (!) 30/100 [30%] in 0.8s (38.43/s)
Download 8 |██████︎ | (!) 15/100 [15%] in 0.4s (36.26/s)
...
Beberapa fitur baru utama, yang sering diminta, akhirnya hadir!
click.echo() YA! Sekarang alive-progress memiliki dukungan untuk Notebook Jupyter dan juga menyertakan status Dinonaktifkan ! Keduanya sangat dicari, dan akhirnya mendarat!
Dan lebih baik lagi, saya telah menerapkan mekanisme deteksi otomatis untuk notebook jupyter, sehingga langsung berfungsi, tanpa perubahan apa pun pada kode Anda!!
Lihat sendiri:
Tampaknya ini bekerja dengan sangat baik, tetapi pada saat ini, ini harus dianggap eksperimental .
Ada beberapa contoh di mana beberapa gangguan visual muncul, seperti dua penyegaranalive_bardigabungkan bersama-sama, bukan satu sama lain... Dan itu adalah sesuatu yang menurut saya tidak mungkin dapat saya atasi: sepertinya Jupyter terkadang menyegarkan kanvas pada waktu yang tidak biasa, yang membuatnya kehilangan beberapa data. Tolong beri tahu saya tentang masalah ini jika muncul sesuatu yang lebih lucu.
Ini merupakan terobosan besar dalam alive-progress !
Saya membutuhkan waktu 1 tahun untuk mengembangkannya, dan saya sangat bangga dengan apa yang telah saya capai o/
.check() baru yang kuat dan halus yang mengkompilasi dan merender semua bingkai dengan indah dari semua siklus animasi pemintal dan batang! mereka bahkan dapat menyertakan data bingkai lengkap, titik kode internal, dan bahkan animasinya! ?alive-progress !alive_it , yang menerima iterable dan memanggil bar() untuk Anda!Karena ini adalah perubahan versi besar, kompatibilitas langsung ke belakang tidak dijamin. Jika ada sesuatu yang tidak berfungsi pada awalnya, cukup periksa tanda tangan impor dan fungsi baru, dan Anda siap melakukannya. Semua fitur sebelumnya masih berfungsi di sini! ?
alive-progressCukup instal dengan pip:
❯ pip install alive-progress Jika Anda bertanya-tanya gaya apa yang ada di dalamnya, inilah showtime ! ;)
from alive_progress . styles import showtime
showtime ()Catatan: Harap abaikan jalur pada animasi gif di bawah, yang benar ada di atas. Pembuatan GIF panjang ini sangat memakan waktu, jadi saya tidak bisa membuat GIF lain setiap ada perubahan. Terima kasih atas pengertian Anda.
Saya membuat gaya ini hanya untuk mencoba semua pabrik animasi yang saya buat, tapi menurut saya beberapa di antaranya berakhir sangat, sangat keren! Gunakan sesuka hati, dan campurkan sesuka hati Anda!
Apakah Anda ingin melihat bilah alive-progress nyata berjalan dengan baik di sistem Anda sebelum mencobanya sendiri?
❯ python -m alive_progress.tools.demo Keren ya?? Sekarang masukkan REPL ipython dan coba ini:
from alive_progress import alive_bar
import time
for x in 1000 , 1500 , 700 , 0 :
with alive_bar ( x ) as bar :
for i in range ( 1000 ):
time . sleep ( .005 )
bar ()Anda akan melihat sesuatu seperti ini, dengan animasi keren sepanjang prosesnya?:
|████████████████████████████████████████| 1000/1000 [100%] in 5.8s (171.62/s)
|██████████████████████████▋︎ | (!) 1000/1500 [67%] in 5.8s (172.62/s)
|████████████████████████████████████████✗︎ (!) 1000/700 [143%] in 5.8s (172.06/s)
|████████████████████████████████████████| 1000 in 5.8s (172.45/s)
Bagus, ya? Menyukainya? Saya tahu Anda akan melakukannya, terima kasih?.
Untuk benar-benar menggunakannya, cukup bungkus loop normal Anda dalam manajer konteks alive_bar seperti ini:
with alive_bar ( total ) as bar : # declare your expected total
for item in items : # <<-- your original loop
print ( item ) # process each item
bar () # call `bar()` at the endDan itu hidup! ?
Jadi, singkatnya: ambil item seperti biasa, masukkan manajer konteks alive_bar dengan jumlah item, lalu ulangi/proses item tersebut, panggil bar() di akhir! Sesederhana itu! :)
items dapat berupa apa saja yang dapat diubah, seperti misalnya, kumpulan kueri;alive_bar adalah total yang diharapkan, seperti qs.count() untuk kumpulan kueri, len(items) untuk iterable dengan panjang, atau bahkan angka statis;bar() inilah yang membuat bilah maju — Anda biasanya memanggilnya di setiap iterasi, tepat setelah menyelesaikan suatu item;bar() terlalu banyak (atau terlalu sedikit di akhir), bilah akan menampilkan deviasi tersebut secara grafis dari total yang diharapkan, sehingga sangat mudah untuk melihat luapan dan luapan;bar.current .Anda bisa menjadi kreatif! Karena bar hanya bergerak maju ketika Anda memanggil
bar(), maka bar tidak bergantung pada loop ! Jadi Anda dapat menggunakannya untuk memantau apa pun yang Anda inginkan, seperti transaksi yang tertunda, barang rusak, dll., atau bahkan meneleponnya lebih dari sekali dalam iterasi yang sama! Jadi, pada akhirnya, Anda akan mengetahui berapa banyak acara "khusus" yang ada, termasuk persentasenya dibandingkan total!
Saat berada dalam konteks alive_bar , Anda dapat dengan mudah menampilkan pesan yang terintegrasi erat dengan bilah kemajuan yang sedang ditampilkan! Itu tidak akan rusak sama sekali dan bahkan akan memperkaya pesan Anda!
bar.text('message') dan bar.text = 'message' yang keren mengatur pesan situasional tepat di dalam bilah, tempat Anda dapat menampilkan sesuatu tentang item saat ini atau fase pemrosesan;bar.title('Title') dan bar.title = 'Title' — campur dengan title_length agar bilah tidak berubah panjang;print() biasa, di mana alive_bar membersihkan baris dengan baik, mencetak pesan Anda di samping posisi bilah saat ini, dan melanjutkan bilah tepat di bawahnya;logging Python standar, termasuk keluaran file, juga diperkaya persis seperti yang sebelumnya;click.echo() untuk mencetak teks bergaya.Luar biasa bukan? Dan semua ini berfungsi sama di terminal atau di notebook Jupyter!
Anda sekarang memiliki cara yang lebih cepat untuk memantau apa pun! Di sini, item secara otomatis dilacak untuk Anda!
Lihatlah alive_it => adaptor iterator alive_bar !
Cukup bungkus item Anda dengan itu, dan ulangi seperti biasa!
Bilahnya akan berfungsi; sesederhana itu!
from alive_progress import alive_it
for item in alive_it ( items ): # <<-- wrapped items
print ( item ) # process each itemSEBERAPA KEREN ITU?! ?
Semua parameter alive_bar berlaku tetapi total , yang lebih cerdas (jika tidak disediakan, maka akan disimpulkan secara otomatis dari data Anda menggunakan len atau length_hint ), dan manual yang tidak masuk akal di sini.
Perhatikan bahwa tidak ada pegangan bar sama sekali di sana. Tapi bagaimana jika Anda menginginkannya, misalnya untuk mengatur pesan teks atau mengambil kemajuan saat ini?
Anda dapat berinteraksi dengan alive_bar internal hanya dengan menugaskan alive_it ke variabel seperti ini:
bar = alive_it ( items ) # <<-- bar with wrapped items
for item in bar : # <<-- iterate on bar
print ( item ) # process each item
bar . text ( f'ok: { item } ' ) # WOW, it works! Perhatikan bahwa ini adalah bar yang sedikit istimewa, yang tidak mendukung bar() , karena adaptor iterator melacak item secara otomatis untuk Anda. Selain itu, ia mendukung finalize , yang memungkinkan Anda mengatur judul dan/atau teks tanda terima akhir:
alive_it ( items , finalize = lambda bar : bar . text ( 'Success!' ))
...Pendeknya:
- penggunaan penuh selalu
with alive_bar() as bar, tempat Anda mengulangi dan memanggilbar()kapan pun Anda mau;- penggunaan adaptor cepat adalah
for item in alive_it(items), di mana item dilacak secara otomatis;- penggunaan adaptor penuh adalah
bar = alive_it(items), di mana selain item dilacak secara otomatis, Anda mendapatkanbariterable khusus yang dapat menyesuaikan bagian dalamalive_progresssesuka Anda.
Mode defaultnya adalah auto dan unknown , yang menggunakan penghitung internal untuk melacak kemajuan. Mereka menghitung jumlah item yang diproses, dan menggunakannya untuk memperbarui bilah kemajuan.
Argumen total bersifat opsional. Jika Anda menyediakannya, bilah masuk dalam mode otomatis . Dalam mode ini, kemajuan operasi dilacak secara otomatis, dan semua widget yang ditawarkan alive-progress tersedia: bilah presisi, spinner, persentase, penghitung, throughput, dan ETA.
Jika Anda tidak memberikan total , bilah masuk ke mode tidak diketahui . Dalam mode ini, kemajuan tidak dapat ditentukan, dan oleh karena itu ETA, sehingga seluruh bilah kemajuan terus dianimasikan. Widget yang tersedia adalah: bilah animasi, spinner, penghitung, dan throughput.
Pemintal keren ini berjalan sepenuhnya secara independen dari bilah animasi, keduanya menjalankan animasinya sendiri secara bersamaan, menampilkan pertunjukan unik di terminal Anda! ?
Yang terakhir, mode otomatis memiliki kemampuan unik: menandai item sebagai dilewati, membuat throughput dan ETA jauh lebih akurat! Lebih lanjut tentang itu nanti.
Mode manual , yang diaktifkan secara manual dengan argumen manual=True , menggunakan persentase internal untuk melacak kemajuan. Ini memungkinkan Anda untuk mendapatkan kendali penuh atas posisi bar. Biasanya digunakan untuk memantau proses yang hanya memberi Anda persentase penyelesaian, atau untuk menghasilkan beberapa efek khusus acak.
Anda dapat menggunakannya secara langsung dengan alive_bar atau melalui config_handler , dan ini memungkinkan Anda mengirim persentase ke bar() handler! Misalnya, untuk menyetelnya ke penyelesaian 15%, cukup panggil bar(0.15) — yaitu 15/100.
Anda juga dapat memberikan total di sini. Jika Anda melakukannya, alive-progress akan secara otomatis menyimpulkan penghitung internal, dan dengan demikian akan dapat menawarkan kepada Anda semua widget yang sama yang tersedia dalam mode otomatis!
Jika Anda tidak memberikan total , Anda setidaknya akan mendapatkan versi kasar dari widget throughput dan ETA, masing-masing dihitung sebagai "%/s" (persentase per detik) dan hingga 100%. Tak satu pun dari keduanya sangat akurat, tetapi lebih baik daripada tidak sama sekali.
Ketika total disediakan semuanya keren:
| mode | menangkal | persentase | keluaran | ETA | atas/bawah mengalir |
|---|---|---|---|---|---|
| mobil | ✅ (centang pengguna) | ✅ (disimpulkan) | ✅ | ✅ | ✅ |
| panduan | ✅ (disimpulkan) | ✅ (kumpulan pengguna) | ✅ | ✅ | ✅ |
Jika tidak, beberapa kompromi harus dilakukan:
| mode | menangkal | persentase | keluaran | ETA | atas/bawah mengalir |
|---|---|---|---|---|---|
| tidak dikenal | ✅ (centang pengguna) | ✅ | |||
| panduan | ✅ (kumpulan pengguna) | ✅ |
Namun sebenarnya mudah untuk dipahami: Anda tidak perlu memikirkan mode mana yang sebaiknya Anda gunakan!
total jika Anda memilikinya, dan gunakan manual jika Anda membutuhkannya!Itu saja! Ini akan bekerja sebaik mungkin! ? Hai/
bar() yang berbeda Penangan bar() mendukung semantik relatif atau absolut, bergantung pada mode:
bar() untuk menambah penghitung sebanyak satu, atau mengirim kenaikan lainnya seperti bar(200) untuk menambah 200 sekaligus;mereka bahkan mendukung
bar(0)danbar(-5)untuk ditahan atau dikurangi jika diperlukan!
bar(0.35) untuk membuat bar langsung melompat ke kemajuan 35%.Kedua mode memungkinkan Anda menjadi kreatif! Karena Anda dapat langsung mengarahkan bilah ke posisi apa pun yang Anda inginkan, Anda dapat:
- membuatnya mundur — misalnya untuk menampilkan batas waktu sesuatu secara grafis;
- membuat efek khusus — misalnya untuk meniru semacam pengukur analog waktu nyata.
Anda dapat memanggil bar() sebanyak yang Anda mau! Kecepatan penyegaran terminal akan selalu dihitung secara asinkron sesuai dengan throughput dan kemajuan saat ini, sehingga Anda tidak akan mengambil risiko mengirim spam ke terminal dengan lebih banyak pembaruan daripada yang diperlukan.
Bagaimanapun, untuk mengambil penghitung/persentase saat ini, cukup panggil: bar.current :
Terakhir, pengendali bar() memanfaatkan kemampuan unik mode otomatis : cukup panggil bar(skipped=True) atau bar(N, skipped=True) untuk menggunakannya. Ketika skipped diatur ke= True , item terkait dikecualikan dari perhitungan throughput, mencegah item yang dilewati mempengaruhi ETA secara tidak akurat.
Mempertahankan proyek sumber terbuka itu sulit dan memakan waktu, dan saya telah mengerahkan banyak ❤️ dan upaya dalam hal ini.
Jika Anda menghargai karya saya, Anda dapat mendukung saya dengan donasi! Terima kasih ?
Pameran showtime memiliki argumen opsional untuk memilih pertunjukan mana yang akan disajikan, Show.SPINNERS (default), Show.BARS atau Show.THEMES , lihatlah! ;)
from alive_progress . styles import showtime , Show
showtime ( Show . BARS )
showtime ( Show . THEMES )Catatan: Harap abaikan jalur pada animasi gif di bawah, yang benar ada di atas. GIF panjang ini sangat memakan waktu untuk dibuat, jadi saya tidak bisa membuat GIF lain setiap ada perubahan. Terima kasih atas pengertian Anda.
Dan temanya (? baru di 2.0):
Pameran showtime juga menerima beberapa opsi penyesuaian:
Misalnya untuk mendapatkan pertunjukan kelautan, Anda dapat showtime(pattern='boat|fish|crab') :
Anda juga dapat mengakses acara ini dengan singkatan
show_bars(),show_spinners(), danshow_themes()!
Ada juga utilitas kecil bernama
print_chars(), untuk membantu menemukan karakter keren untuk dimasukkan ke dalam spinner dan bar kustom Anda, atau untuk menentukan apakah terminal Anda mendukung karakter Unicode.
Ada beberapa opsi untuk menyesuaikan penampilan dan perilaku!
Semuanya dapat diatur baik secara langsung di alive_bar atau secara global di config_handler !
Ini adalah opsi - nilai default dalam tanda kurung:
title : judul bilah opsional yang selalu terlihatlength : [ 40 ] jumlah kolom untuk merender bilah kemajuan animasimax_cols : [ 80 ] col maksimum yang akan digunakan jika tidak memungkinkan untuk mengambilnya, seperti di jupyterspinner : gaya spinner yang akan dirender di sebelah bilahbar : gaya batang yang akan dirender dalam mode yang diketahuiunknown : gaya batang yang akan dirender dalam mode tidak diketahuitheme : [ 'smooth' ] satu set pemintal, bilah, dan tidak diketahui yang cocokforce_tty : [ None ] memaksa animasi untuk hidup, mati, atau sesuai dengan tty (detail lebih lanjut di sini)file : [ sys.stdout ] objek file yang akan digunakan: sys.stdout , sys.stderr , atau TextIOWrapper serupadisable : [ False ] jika Benar, nonaktifkan sepenuhnya semua keluaran, jangan pasang kaitmanual : [ False ] diatur untuk mengontrol posisi bar secara manualenrich_print : [ True ] memperkaya print() dan mencatat pesan dengan posisi bilahenrich_offset : [ 0 ] offset yang akan diterapkan pada pengayaan_cetakreceipt : [ True ] mencetak tanda terima akhir yang bagus, menonaktifkan jika Salahreceipt_text : [ False ] diatur untuk mengulang pesan teks terakhir di resi terakhirmonitor (bool|str): [ True ] mengkonfigurasi widget monitor 152/200 [76%]{count} , {total} dan {percent} untuk menyesuaikannyaelapsed (bool|str): [ True ] mengonfigurasi widget waktu yang telah berlalu in 12s{elapsed} untuk menyesuaikannyastats (bool|str): [ True ] mengonfigurasi widget statistik (123.4/s, eta: 12s){rate} dan {eta} untuk menyesuaikannyamonitor_end (bool|str): [ True ] mengonfigurasi widget monitor dalam tanda terima akhirmonitorelapsed_end (bool|str): [ True ] mengonfigurasi widget waktu yang telah berlalu dalam tanda terima akhirelapsedstats_end (bool|str): [ True ] mengonfigurasi widget statistik dalam tanda terima akhir{rate} untuk menyesuaikannya (tidak ada hubungannya dengan statistik)title_length : [ 0 ] memperbaiki panjang judul, atau 0 tanpa batasspinner_length : [ 0 ] memaksa panjang spinner, atau 0 untuk panjang aslinyarefresh_secs : [ 0 ] memaksa periode penyegaran ke ini, 0 adalah umpan balik visual reaktifctrl_c : [ True ] jika Salah, nonaktifkan CTRL+C (menangkapnya)dual_line : [ False ] jika Benar, tempatkan teks di bawah bilahunit : teks apa pun yang memberi label pada entitas Andascale : penskalaan yang diterapkan pada satuan: None , SI , IEC , atau SI2False atau '' -> None , True -> SI , 10 or '10' -> SI , 2 or '2' -> IECprecision : [ 1 ] berapa banyak desimal yang ditampilkan saat penskalaan Dan ada juga satu yang hanya dapat diatur secara lokal dalam konteks alive_bar :
calibrate : throughput teoritis maksimum untuk mengkalibrasi kecepatan animasi (detail lebih lanjut di sini) Untuk mengaturnya secara lokal, cukup kirimkan sebagai argumen kata kunci ke alive_bar :
with alive_bar ( total , title = 'Processing' , length = 20 , bar = 'halloween' ) as bar :
... Untuk menggunakannya secara global, kirimkan ke config_handler , dan alive_bar apa pun yang dibuat setelahnya akan menyertakan opsi tersebut! Dan Anda dapat memadupadankannya, opsi lokal selalu lebih diutamakan daripada opsi global:
from alive_progress import config_handler
config_handler . set_global ( length = 20 , spinner = 'wait' )
with alive_bar ( total , bar = 'blocks' , spinner = 'twirls' ) as bar :
# the length is 20, the bar is 'blocks' and the spinner is 'twirls'.
... Ya, Anda dapat merakit pemintal Anda sendiri! Dan itu mudah!
Saya telah membuat banyak sekali efek khusus, jadi Anda bisa memadupadankannya sesuka Anda! Ada pemintal bingkai, bergulir, memantul, berurutan, di samping, dan tertunda! Jadilah kreatif! ?
Animasi pemintal direkayasa oleh ekspresi generator yang sangat canggih, jauh di dalam beberapa lapisan pabrik meta, pabrik, dan generator?!
alive_bar dan config_handler ;Generator ini mampu melakukan beberapa siklus animasi yang berbeda sesuai dengan perilaku spinner, misalnya spinner yang memantul dapat menjalankan satu siklus untuk dengan mulus membawa subjek ke dalam pemandangan, lalu berulang kali mengubah posisinya hingga ke sisi yang lain, lalu membuatnya menghilang dengan mulus dari pemandangan = > dan ini semua hanya satu siklus! Kemudian dapat diikuti dengan siklus lain untuk melakukan semuanya lagi tetapi mundur! Dan pemintal yang memantul juga menerima pola yang berbeda dan bergantian baik dalam arah kanan maupun kiri, yang membuat mereka menghasilkan produk kartesius dari semua kombinasi, kemungkinan menghasilkan lusinan siklus berbeda hingga mereka mulai mengulanginya!! ?
Dan masih ada lagi, menurut saya salah satu pencapaian paling mengesankan yang saya dapatkan dalam sistem animasi ini (selain kompiler spinner itu sendiri)... Mereka hanya menghasilkan lebih banyak bingkai animasi hingga siklus saat ini tidak habis, lalu mereka berhenti sendiri ! Yap, siklus selanjutnya belum dimulai! Perilaku ini menciptakan jeda alami di tempat yang tepat, sehingga animasi tidak terganggu, sehingga saya dapat dengan lancar menghubungkan dengan animasi apa pun yang saya inginkan!!
Hal ini mempunyai implikasi yang menarik: siklus-siklus tersebut dapat memiliki jumlah bingkai yang berbeda-beda, panjang layar yang berbeda-beda, siklus-siklus tersebut tidak perlu disinkronkan, siklus-siklus tersebut dapat membuat rangkaian panjang yang berbeda-beda sendiri, siklus-siklus tersebut dapat bekerja sama untuk memainkan siklus-siklus secara berurutan atau bersamaan, dan saya dapat membuat Anda takjub dengan menampilkan beberapa animasi yang sangat berbeda secara bersamaan tanpa gangguan apa pun!
Ini hampir seperti mereka... hidup !! ?
==> Ya, dari situlah nama proyek ini berasal!
Sekarang, generator siklus dan frame ini telah digunakan sepenuhnya sebelumnya oleh Spinner Compiler ! Ini adalah prosesor baru yang sangat keren yang saya buat dalam upaya Arsitektur Sel , untuk membuat semua animasi ini berfungsi bahkan dengan adanya karakter lebar atau cluster grafem yang kompleks! Sangat sulit untuk membuat cluster ini secara bertahap masuk dan keluar dari frame, dengan lancar, sekaligus menjaganya agar tidak melanggar pengkodean Unicode dan terutama mempertahankan panjang aslinya di semua frame! Ya, beberapa karakter secara berurutan dapat mewakili simbol lain yang sama sekali berbeda, sehingga tidak akan pernah dapat dipisahkan! Mereka harus masuk dan keluar bingkai selalu bersama-sama, sekaligus, atau grafem tidak akan muncul sama sekali (misalnya Emoji)!! Masuk ke Spinner Compiler ......
Hal ini telah memungkinkan beberapa hal luar biasa!! Karena Kompiler ini menghasilkan seluruh data bingkai pemintal sebelumnya:
Jadi, saya bisa mengumpulkan semua animasi yang siap diputar dan menyelesaikannya, tanpa overhead runtime sama sekali!! ?
Selain itu, dengan data frame lengkap yang dikompilasi dan dipertahankan, saya dapat membuat beberapa perintah untuk memfaktorkan ulang data tersebut, seperti mengubah bentuk, mengganti karakter, menambahkan jeda visual (pengulangan frame), menghasilkan efek memantul sesuai permintaan pada konten apa pun, dan bahkan mentransposisi siklus dengan bingkai!!
Tapi bagaimana Anda bisa melihat efek ini? Apakah efek yang Anda buat terlihat bagus? Atau tidak berfungsi seperti yang Anda kira? YA, sekarang Anda dapat melihat semua siklus dan bingkai yang dihasilkan secara analitis, dalam versi yang sangat indah!!
Saya suka apa yang telah saya capai di sini?, ini mungkin alat terindah yang pernah saya buat... Lihatlah alat check !!
Luar biasa jika saya sendiri yang mengatakannya, bukan? Dan sepotong perangkat lunak yang sangat kompleks yang saya banggakan, lihat kodenya jika Anda mau.
Dan alat check jauh lebih kuat! Misalnya, Anda dapat melihat titik kode dari bingkai !!! Dan mungkin memiliki sekilas mengapa versi ini begitu, sangat sulit dan rumit untuk membuat ...
Dengan warna merah, Anda melihat kelompok grafe, yang menempati satu atau dua "posisi logis", terlepas dari ukuran sebenarnya mereka ... ini adalah "sel" dari arsitektur sel baru ...
Lihat betapa hebatnya bendera emoji diwakili:
Bendera tampaknya bergerak begitu lancar karena menggunakan "setengah karakter"! Karena ini adalah arang yang luas, alive-progress tahu itu akan diterjemahkan dengan "dua karakter yang terlihat", dan animasi mempertimbangkan ini, tetapi ditulis dengan spasi, yang hanya menempati satu. Ketika seseorang menggunakan latar belakang campuran, situasinya jauh lebih kompleks ...
Jenis pabrik yang saya buat adalah:
frames : Menggambar urutan karakter apa pun sesuka hati, yang akan dimainkan bingkai demi bingkai secara berurutan;scrolling : Menghasilkan aliran halus dari satu sisi ke sisi lain, bersembunyi di belakang atau membungkus perbatasan yang tidak terlihat - memungkinkan menggunakan subjek satu per satu, menghasilkan beberapa siklus karakter yang berbeda;bouncing : Mirip dengan scrolling , tetapi membuat animasi memantul kembali ke awal, bersembunyi di belakang atau segera memantul di perbatasan yang tidak terlihat;sequential dapatkan beberapa pabrik dan mainkan satu setelah yang lain secara berurutan! memungkinkan untuk mencampurnya atau tidak;alongside dengan beberapa pabrik dan mainkan bersama secara bersamaan, mengapa memilih kapan Anda bisa memiliki semuanya?! memungkinkan untuk memilih pivot animasi;delayed : Dapatkan pabrik lain dan salin beberapa kali, semakin melewatkan beberapa bingkai pada masing -masing! Efek yang sangat keren dibuat di sini!Untuk detail lebih lanjut silakan lihat Docstrings mereka, yang sangat lengkap.
Menyesuaikan bar tidak ada yang terlibat. Katakanlah mereka "langsung", benda pasif. Mereka tidak mendukung animasi, yaitu mereka akan selalu menghasilkan rendisi yang sama mengingat parameter yang sama. Ingat pemintal adalah generator tak terbatas, mampu menghasilkan urutan yang panjang dan kompleks.
Nah, bar juga memiliki pabrik meta, menggunakan penutupan untuk menyimpan parameter styling, dan menerima parameter operasi tambahan, tetapi kemudian pabrik yang sebenarnya tidak dapat menghasilkan konten apa pun dengan sendirinya. Masih membutuhkan parameter tambahan, angka poin mengambang antara 0 dan 1, yang merupakan persentase untuk membuat dirinya sendiri.
alive_barmenghitung persentase ini secara otomatis berdasarkan konter dan total, tetapi Anda dapat mengirimkannya sendiri ketika dalam modemanual!
Bar juga tidak memiliki kompiler batang, tetapi mereka menyediakan alat cek !! ?
Anda bahkan dapat mencampur dan mencocokkan karakter lebar dan karakter normal seperti di pemintal! (Dan semuanya tetap selaras dengan sempurna?)
Gunakan alat periksa untuk konten hati Anda !! Mereka memiliki lebih banyak barang yang menunggu Anda, bahkan animasi real-time!
Buat animasi paling liar dan paling keren yang Anda bisa dan kirimkan kepada saya!
Saya sedang berpikir untuk membuat semacam paketcontrib, dengan pemintal dan bilah yang dikendalikan pengguna!
Wow, jika Anda telah membaca semuanya sampai di sini, Anda sekarang harus memiliki pengetahuan yang baik tentang menggunakan alive-progress ! ?
Tapi persiapkan diri Anda karena ada lebih banyak lagi, hal -hal menarik ada di depan!
Mempertahankan proyek open source adalah sulit dan memakan waktu, dan saya sudah banyak ❤️ dan upaya untuk ini.
Jika Anda menghargai pekerjaan saya, Anda dapat mendukung saya dengan sumbangan! Terima kasih ?
Oh, Anda ingin berhenti sama sekali, saya dengar? Ini adalah konsep novel yang luar biasa, tidak ditemukan di mana pun afaik.
Dengan ini Anda dapat bertindak atas beberapa item secara manual , sesuka hati, tepat di tengah pemrosesan yang sedang berlangsung !!
Ya, Anda dapat kembali ke prompt dan memperbaiki, mengubah, mengirimkan barang, dan bilah hanya akan "mengingat" di mana itu ...
Misalkan Anda perlu merekonsiliasi transaksi pembayaran (sudah ada, dilakukan). Anda perlu mengulangi ribuan dari mereka, mendeteksi entah bagaimana yang salah, dan memperbaikinya. Perbaikan ini tidak sederhana atau deterministik, Anda perlu mempelajari masing -masing untuk memahami apa yang harus dilakukan. Mereka bisa kehilangan penerima, atau memiliki jumlah yang salah, atau tidak disinkronkan dengan server, dll., Sulit membayangkan semua kemungkinan.
Biasanya, Anda harus membiarkan proses deteksi berjalan sampai selesai, menambahkan ke daftar masing -masing ketidakkonsistenan yang ditemukan dan menunggu, berpotensi lama, sampai Anda akhirnya dapat mulai memperbaikinya ... Anda tentu saja dapat mengurangi itu dengan memproses dalam potongan -potongan chunks , atau mencetaknya dan bertindak melalui cangkang lain, dll., Tetapi mereka memiliki kekurangan sendiri ...?
Sekarang, ada cara yang lebih baik! Cukup jeda proses deteksi yang sebenarnya untuk sementara waktu! Maka Anda hanya perlu menunggu sampai kesalahan berikutnya ditemukan, dan bertindak hampir real-time!
Untuk menggunakan mekanisme jeda, Anda hanya perlu menulis fungsi, sehingga kode dapat yield item yang ingin Anda berinteraksi. Anda kemungkinan besar sudah menggunakan satu dalam kode Anda, tetapi di cangkang ipython atau reparasi lain Anda mungkin tidak. Jadi cukup bungkus kode debug Anda dalam suatu fungsi, lalu masukkan dalam konteks bar.pause() !!
def reconcile_transactions ():
qs = Transaction . objects . filter () # django example, or in sqlalchemy: session.query(Transaction).filter()
with alive_bar ( qs . count ()) as bar :
for transaction in qs :
if faulty ( transaction ):
with bar . pause ():
yield transaction
bar () Itu saja! Sesederhana itu! Hai/
Sekarang jalankan gen = reconcile_transactions() untuk membuat instantiate generator, dan kapan pun Anda menginginkan transaksi yang salah berikutnya, panggil saja next(gen, None) ! Saya menyukainya...
Bilah alive-progress akan dimulai dan berjalan seperti biasa, tetapi segera setelah ketidakkonsistenan ditemukan, bilah akan berhenti sejenak, mematikan benang penyegaran dan mengingat keadaan yang tepat, dan menghasilkan transaksi kepada Anda langsung pada prompt! Hampir ajaib! ?
In [11]: gen = reconcile_transactions()
In [12]: next(gen, None)
|█████████████████████ | 105/200 [52%] in 5s (18.8/s, eta: 4s)
Out[12]: Transaction<#123>
Anda kemudian dapat memeriksa transaksi dengan jalan pintas _ ipython yang biasa (atau langsung menetapkannya dengan t = next(gen, None) ), dan Anda siap untuk memperbaikinya!
Ketika Anda selesai, mengaktifkan kembali bar dengan panggilan next yang sama seperti sebelumnya !! Bar muncul kembali, menyalakan semuanya kembali, dan terus seperti itu tidak pernah berhenti !! Oke, ini ajaib?
In [21]: next(gen, None)
|█████████████████████ | ▁▃▅ 106/200 [52%] in 5s (18.8/s, eta: 4s)
Bilas dan ulangi sampai tanda terima akhir muncul, dan tidak akan ada transaksi yang salah lagi. ?
Jadi, Anda perlu memantau operasi tetap, tanpa loop, bukan?
Ini akan berhasil! Berikut ini adalah contoh yang naif (kami akan melakukan yang lebih baik sebentar lagi):
with alive_bar ( 4 ) as bar :
corpus = read_file ( file )
bar () # file was read, tokenizing
tokens = tokenize ( corpus )
bar () # tokens generated, processing
data = process ( tokens )
bar () # process finished, sending response
resp = send ( data )
bar () # we're done! four bar calls with `total=4` Ini naif karena mengasumsikan semua langkah membutuhkan waktu yang sama, tetapi sebenarnya, masing -masing mungkin membutuhkan waktu yang sangat berbeda untuk diselesaikan. Pikirkan read_file dan tokenize mungkin sangat cepat, yang membuat persentase meroket hingga 50%, kemudian berhenti untuk waktu yang lama dalam langkah process ... Anda mengerti intinya, itu dapat merusak pengalaman pengguna dan membuat ETA yang sangat menyesatkan.
Untuk meningkatkan itu, Anda perlu mendistribusikan persentase langkah -langkah yang sesuai! Karena Anda memberi tahu alive_bar ada empat langkah, ketika yang pertama selesai dipahami 1/4 atau 25% dari seluruh pemrosesan selesai ... dengan demikian, Anda perlu mengukur berapa lama langkah Anda sebenarnya dan menggunakan mode manual untuk Tingkatkan persentase bar berdasarkan jumlah yang tepat di setiap langkah!
Anda dapat menggunakan proyek open source saya yang lain tentang waktu untuk dengan mudah mengukur durasi ini! Cobalah untuk mensimulasikan dengan beberapa input yang representatif, untuk mendapatkan hasil yang lebih baik. Sesuatu seperti:
from about_time import about_time
with about_time () as t_total : # this about_time will measure the whole time of the block.
with about_time () as t1 : # the other four will get the relative timings within the whole.
corpus = read_file ( file ) # `about_time` supports several calling conventions, including one-liners.
with about_time () as t2 : # see its documentation for more details.
tokens = tokenize ( corpus )
with about_time () as t3 :
data = process ( tokens )
with about_time () as t4 :
resp = send ( data )
print ( f'percentage1 = { t1 . duration / t_total . duration } ' )
print ( f'percentage2 = { t2 . duration / t_total . duration } ' )
print ( f'percentage3 = { t3 . duration / t_total . duration } ' )
print ( f'percentage4 = { t4 . duration / t_total . duration } ' ) Ini dia! Sekarang Anda tahu waktu relatif dari semua langkah, dan dapat menggunakannya untuk meningkatkan kode asli Anda! Dapatkan saja waktu kumulatif dan letakkan di dalam mode manual alive_bar !
Misalnya, jika waktu yang Anda temukan adalah 10%, 30%, 20%, dan 40%, Anda akan menggunakan 0,1, 0,4, 0,6, dan 1,0 (yang terakhir harus selalu 1,0):
with alive_bar ( 4 , manual = True ) as bar :
corpus = read_big_file ()
bar ( 0.1 ) # 10%
tokens = tokenize ( corpus )
bar ( 0.4 ) # 30% + 10% from previous steps
data = process ( tokens )
bar ( 0.6 ) # 20% + 40% from previous steps
resp = send ( data )
bar ( 1. ) # always 1. in the last stepItu saja! Pengalaman pengguna dan ETA harus sangat ditingkatkan sekarang.
Ya, Anda dapat mengkalibrasi kecepatan pemintal!
Bilah alive-progress memiliki umpan balik visual yang keren dari throughput saat ini, sehingga Anda benar-benar dapat melihat seberapa cepat pemrosesan Anda, karena pemintal berjalan lebih cepat atau lebih lambat dengannya.
Agar hal ini terjadi, saya telah mengumpulkan dan menerapkan beberapa kurva FPS untuk secara empiris menemukan mana yang memberikan rasa kecepatan terbaik:
(Versi interaktif [di sini] (https://www.desmos.com/calculator/ema05elsux)))
Grafik menunjukkan kurva logaritmik (merah), parabola (biru) dan linier (hijau), ini adalah yang saya mulai. Itu bukan tugas yang mudah, saya telah melakukan lusinan tes, dan tidak pernah menemukan yang benar -benar menginspirasi rasa kecepatan yang saya cari. Yang terbaik tampaknya adalah logaritmik, tetapi bereaksi buruk dengan jumlah kecil. Saya tahu saya bisa membuatnya bekerja dengan beberapa tikungan untuk jumlah kecil itu, jadi saya banyak bereksperimen dan menyesuaikan kurva logaritmik (oranye putus -putus) sampai akhirnya saya menemukan perilaku yang saya harapkan! Ini adalah salah satu yang tampaknya memberikan perubahan kecepatan terbaik yang dirasakan di seluruh spektrum dari beberapa hingga miliaran ... itulah kurva yang saya selesaikan, dan itu yang digunakan dalam semua mode dan kondisi. Di masa depan dan jika seseorang merasa berguna, kurva itu dapat dikonfigurasi.
Nah, kalibrasi alive-progress default adalah 1.000.000 dalam mode terikat, yaitu, dibutuhkan 1 juta iterasi per detik untuk bar untuk menyegarkan dirinya pada 60 frame per detik. Dalam mode tidak terbatas manual, itu adalah 1,0 (100%). Keduanya memungkinkan jangkauan operasi yang luas dan umumnya bekerja dengan cukup baik.
Misalnya, lihat efek kalibrasi yang sangat berbeda ini, menjalankan kode yang sama pada kecepatan yang sama! Perhatikan nuansa pemintal yang diteruskan ke pengguna, apakah pemrosesan ini berjalan lambat atau berjalan cepat? Dan ingat itu bukan hanya pemintal yang menyegarkan tetapi seluruh garis, lengkap dengan rendisi bar dan semua widget, jadi semuanya menjadi lebih halus atau lamban:
Jadi, jika pemrosesan Anda hampir tidak mencapai 20 item per detik, dan Anda pikir
alive-progressmenjadi lamban, Anda bisa meningkatkan rasa kecepatan dengan mengkalibrasi untuk mengatakan40, dan itu akan berjalan lebih cepat ... Lebih baik selalu meninggalkan ruang kepala dan mengkalibrasi ke sesuatu antara 50% dan 100% lebih, dan kemudian mengubahnya dari sana untuk menemukan yang paling Anda sukai! :)
Apakah animasi- alive-progress yang menakjubkan ini menolak untuk ditampilkan?
Pycharm luar biasa, saya menyukainya! Tapi saya tidak akan pernah mengerti mengapa mereka menonaktifkan meniru terminal secara default ... jika Anda menggunakan konsol output Pycharm, harap aktifkan ini pada semua konfigurasi run Anda:
Saya bahkan menyarankan Anda masuk ke
File>New Projects Setup>Run Configuration Templates, PilihPython, dan juga mengaktifkannya di sana, jadi apa pun yang Anda buat sudah memiliki set ini.
Selain itu, beberapa terminal melaporkan diri mereka sebagai "non-interaktif", seperti ketika kehabisan terminal nyata (pycharm dan jupyter misalnya), di pipa shell ( cat file.txt | python program.py ), atau di latar belakang proses (tidak terhubung ke TTY).
Ketika alive-progress menemukan dirinya di terminal non-interaktif, secara otomatis menonaktifkan semua jenis animasi, hanya mencetak kwitansi akhir. Hal ini dibuat untuk menghindari keduanya mengacaukan output pipa dan spam file log Anda dengan ribuan penyegaran alive-progress .
Jadi, ketika Anda tahu itu aman, Anda dapat memaksa mereka untuk melihat alive-progress dalam segala kemuliaan! Inilah argumen force_tty :
with alive_bar ( 1000 , force_tty = True ) as bar :
for i in range ( 1000 ):
time . sleep ( .01 )
bar ()Nilai yang diterima adalah:
force_tty=True -> selalu memungkinkan animasi, dan deteksi otomatis jupyter notebooks!force_tty=False -> selalu menonaktifkan animasi, hanya menyimpan tanda terima akhirforce_tty=None (default) -> deteksi otomatis, sesuai dengan status TTY terminal Anda juga dapat mengaturnya di seluruh sistem menggunakan config_handler , jadi Anda tidak perlu melewatkannya secara manual lagi.
Perhatikan bahwa konsol Pycharm dan notebook Jupyter sangat diinstrumentasi dan karenanya memiliki lebih banyak overhead, sehingga hasilnya mungkin tidak seberat yang Anda harapkan. Selain itu, Jupyter Notebooks tidak mendukung kode pelarian ANSI, jadi saya harus mengembangkan beberapa solusi untuk meniru fungsi seperti "Clear the Line" dan "Clear From Cursor" ... untuk melihat animasi cairan dan lancar
alive_barseperti yang saya maksudkan , selalu lebih suka terminal penuh.
alive-progress tidak memiliki ketergantungan. Sekarang memiliki dua: satu adalah waktu (proyek menarik lainnya, jika saya mengatakannya sendiri), yang digunakan untuk melacak waktu yang dibutuhkan untuk kompilasi pemintal, dan untuk menghasilkan rendisi ramah manusia. Yang lainnya adalah Grapheme, untuk mendeteksi kerusakan grapheme cluster (saya telah membuka masalah di sana bertanya tentang masa depan dan kebenarannya, dan penulis menjamin ia bermaksud untuk memperbarui proyek pada setiap versi Unicode baru);alive-progress tidak memiliki kelas Python tunggal! Sekarang ia memiliki beberapa yang kecil karena alasan yang sangat spesifik (ubah callable, adaptor iterator, dan beberapa deskriptor untuk widget alive_bar ).alive_bar itu sendiri hanyalah sebuah fungsi! Meskipun, untuk bersikap adil, itu adalah "hanya" fungsi di mana saya secara dinamis menghubungkan beberapa penutupan dari dalam dirinya sendiri (ingat bahwa fungsi Python memiliki __dict__ seperti halnya kelas?). alive_bar tidak melihat perubahan ukuran terminal, tetapi hanya memotong garis yang sesuai).contrib entah bagaimana, untuk memungkinkan cara sederhana untuk berbagi pemintal dan bar keren dari pengguna.skippedstderr dan file lainnya bukan stdoutmonitor , elapsed , stats
Lengkap di sini.
alive_it yang tidak valid, mendeteksi penggunaan bersarang Alive_Progress dan melempar pesan kesalahan yang lebih jelasalive_itskipped , pengaturan konfigurasi max_cols baru untuk jupyter, perbaiki mengambil ukuran terminal saat menggunakan stderr, secara resmi mendukung Python 3.11sys.stderr dan file lain alih -alih sys.stdout , merampas estimasi laju, lebih banyak kueri ke widget yang sedang berjalan ' data, sistem bantuan dalam kesalahan konfigurasimonitor inti yang dapat disesuaikan, elapsed , dan stats , monitor_end baru, elapsed_end , dan widget inti stats_end , dukungan yang lebih baik untuk Ctrl+C, yang membuat stop alive_bar sebelum waktunyaclick.echo() dukungan; kinerja lebih cepat; deteksi kolom terminal yang lebih aman; bar.current Acts seperti properti; Hapus Python 3.6.check() alat di kedua pemintal dan batang; mesin bar dan pemintal perombakan; mode animasi baru di samping dan pemintal berurutan; pemintal, bar, dan tema baru; Dynamic Showtime dengan tema, pelindung gulir dan pola filter; Peningkatan logging untuk file; beberapa opsi konfigurasi baru untuk menyesuaikan penampilan; adaptor iterator baru alive_it ; menggunakan time.perf_counter() jam resolusi tinggi; Membutuhkan Python 3.6+ (dan secara resmi mendukung Python 3.9 dan 3.10)bar.current() ; Newline dicetak di Vanilla Python Rept; Bilah dipotong menjadi 80 char di windowsbar.text() , untuk mengatur pesan situasional kapan saja, tanpa penambahan posisi (mencela parameter 'teks' di bar() ); Optimalisasi Kinerjabackground alih -alih blank , yang menerima string berukuran sewenang -wenang dan tetap diperbaiki di latar belakang, mensimulasikan bilah yang terjadi "di atasnya"show_spinners dan show_bars , utilitas baru print_chars , show_bars mendapatkan beberapa demonstrasi lanjutan (coba lagi!) alive_progress akan selalu berusaha untuk mengikuti python, jadi mulai dari versi 2.0, saya akan menjatuhkan dukungan untuk semua versi Python yang memasuki EOL. Lihat jadwal mereka di sini.
Tapi jangan khawatir jika Anda tidak dapat bermigrasi dulu: Versi alive_progress adalah abadi, jadi terus gunakan yang bekerja untuk Anda dan Anda baik.
Saya hanya sangat merekomendasikan pengaturan paket alive_progress yang lebih lama dalam file persyaratan.txt dengan format berikut. Ini akan selalu mengambil rilis build terbaru sebelum versi yang diberikan, jadi, jika saya pernah merilis perbaikan bug, Anda akan mendapatkannya juga.
❯ pip install -U " alive_progress<2 "❯ pip install -U " alive_progress<2.2 "❯ pip install -U " alive_progress<3.2 " Perangkat lunak ini dilisensikan di bawah lisensi MIT. Lihat file LISENSI di direktori distribusi teratas untuk teks lisensi lengkap.
Mempertahankan proyek open source adalah sulit dan memakan waktu, dan saya sudah banyak ❤️ dan upaya untuk ini.
Jika Anda menghargai pekerjaan saya, Anda dapat mendukung saya dengan sumbangan! Terima kasih ?
