alive progress
1.0.0
คุณเคยสงสัยบ้างไหมว่าการประมวลผลอันยาวนานของคุณอยู่ที่ไหน และจะเสร็จสิ้นเมื่อใด ปกติคุณกด RETURN หลายครั้งเพื่อให้แน่ใจว่าจะไม่ขัดข้อง หรือการเชื่อมต่อ SSH ไม่หยุดนิ่ง คุณเคยคิดบ้างไหมว่าคงจะดีไม่น้อยหากสามารถ หยุดการประมวลผลบางอย่าง ชั่วคราวโดยไม่ยุ่งยาก กลับไปที่พรอมต์ของ Python เพื่อแก้ไขบางรายการด้วยตนเอง จากนั้นจึง กลับมาทำงานต่อได้อย่างราบรื่น ฉันทำ...
ฉันได้เริ่มแถบความคืบหน้าใหม่โดยคิดถึงเรื่องทั้งหมด ดู ความก้าวหน้าที่ยังมีชีวิตอยู่ ! -
ขอแนะนำแนวคิดใหม่ล่าสุดในแถบความคืบหน้าสำหรับ Python! alive-progress นั้นอยู่ในระดับของตัวเอง พร้อมด้วยคุณสมบัติเจ๋งๆ มากมายที่ทำให้แตกต่างออกไป นี่คือไฮไลท์บางส่วน:
check() ที่ทรงพลังอย่างยิ่งที่ช่วยคุณออกแบบแอนิเมชั่นของคุณเอง! คุณสามารถดูได้ว่าเฟรมที่สร้างขึ้นและวงจรแอนิเมชั่นจะมีลักษณะอย่างไร ระเบิดบนหน้าจอของคุณ และแม้กระทั่งเห็นมัน มีชีวิต ก่อนที่จะทำการติดตั้งใน alive-progress ! เป็นเครื่องมือที่เจ๋งที่สุดในโลก! ปลดปล่อยความคิดสร้างสรรค์ของคุณ! README นี้มีการพัฒนาอยู่เสมอ ดังนั้นโปรดพิจารณาให้ครอบคลุมมากขึ้นเป็นครั้งคราว... คุณอาจพบรายละเอียดใหม่ๆ ที่ดีในส่วนอื่นๆ! -
alive-progressbar() ที่แตกต่างกัน หลังจากผ่านไปประมาณหนึ่งปีแห่งความมั่นคง ในที่สุด alive-progress ครั้งใหม่ก็มาถึง!
คุณสมบัติหลักและการปรับปรุงคือ:
bar() ด้วย 0 และคู่ -N เพื่อให้ย้อนกลับได้! มีประโยชน์เมื่อคุณไม่สามารถดำเนินการใดๆ ในการวนซ้ำหรือต้องย้อนกลับบางสิ่ง!และอื่นๆ อีกมากมาย!
enrich_offset แบบกำหนดเองเพื่อใช้สำหรับข้อความที่พิมพ์หรือบันทึก ซึ่งช่วยให้คุณเริ่มต้นด้วย on 1: หรือดำเนินการต่อจากจุดที่คุณจากการคำนวณครั้งก่อน! การอัปเดตที่ยอดเยี่ยมมากที่นี่! นอกเหนือจากการขัดเกลาสิ่งต่าง ๆ และปรับปรุงการรองรับเทอร์มินัลแล้ว ขณะนี้ alive-progress ยังสนับสนุนการคำนวณต่อ!
เมื่อประมวลผลชุดข้อมูลขนาดใหญ่หรือสิ่งที่ใช้เวลานาน คุณอาจใช้แบตช์หรือแคชผลลัพธ์บางส่วน จากนั้น ในกรณีที่มันหยุดและรีสตาร์ท คุณจะต้องข้ามรายการที่ทำไปแล้วทั้งหมดอย่างรวดเร็ว ซึ่งทำให้ alive_bar คิดว่าคุณกำลังประมวลผลรายการนับพันต่อวินาที ซึ่งในทางกลับกันจะทำลาย ETA โดยสิ้นเชิง... แต่ไม่ใช่อีกต่อไป ! แค่บอก bar() ว่าคุณข้ามรายการแล้ว... ?
คุณสามารถใช้มันได้สองวิธี:
1. หากคุณรู้ว่าคุณหยุดอยู่ที่ไหน:
with alive_bar ( 120000 ) as bar :
bar ( 60000 , skipped = True )
for i in range ( 60000 , 120000 ):
# process item
bar () ใช่ เพียงแค่เรียก bar(N, skipped=True) หนึ่งครั้ง โดยระบุจำนวนรายการ
2. หากคุณไม่ทราบหรือรายการกระจัดกระจาย:
with alive_bar ( 120000 ) as bar :
for i in range ( 120000 ):
if done ( i ):
bar ( skipped = True )
continue
# process item
bar () ใช่ มันง่ายอย่างนั้น! เพียงเรียก bar(skipped=True) เมื่อรายการเสร็จสิ้นแล้ว หรือเรียก bar() ตามปกติ คุณยังสามารถแชร์การโทรแบบ bar(skipped=?) ในตอนท้าย โดยมีบูลบอกว่าคุณข้ามรายการนั้นหรือไม่ เจ๋งใช่มั้ย?
นอกจากนี้ในเวอร์ชันนี้:
max_cols ใหม่ จำนวนคอลัมน์ที่จะใช้หากไม่สามารถดึงข้อมูลได้ เช่นใน jupyter และแพลตฟอร์มอื่นๆ ที่ไม่รองรับขนาดใช่แล้ว ในที่สุดฉันก็สามารถออกเวอร์ชันนี้ได้แล้ว! นี่คือสินค้าใหม่:
B , bytes หรือแม้แต่ °C !sys.stderr และไฟล์อื่น ๆ แทน sys.stdout !การแก้ไขที่คาดหวังไว้สูง:
TypeError: unhashable type: 'types.SimpleNamespace'RotatingFileHandler s! ใช่แล้ว ขอความช่วยเหลือได้ที่นี่และสุดท้ายแต่ไม่ท้ายสุด รูปแบบที่สวยงามยิ่งขึ้นเพื่อให้คุณเพลิดเพลินไปกับความก้าวหน้าของคุณ!
ตอนนี้ alive_bar รองรับโหมดข้อความ Dual Line !
หากคุณต้องการรวมข้อความสถานการณ์ที่ยาวขึ้นไว้ในแถบ คุณอาจรู้สึกว่าถูกบีบให้เหลือบรรทัดเดียว คุณต้องย่อแถบภาพเคลื่อนไหวที่สวยงามหรือแย่กว่านั้นคือลบวิดเจ็ต (!) เพื่อให้สามารถเห็นสิ่งที่คุณต้องการ...
ไม่ใช่แล้ว!! ตอนนี้คุณสามารถสร้างแถบ Dual Line และใส่ข้อความไว้ด้านล่างได้แล้ว!
ใช่ มีข้อความอยู่ใต้แถบทั้งหมด และข้อความการพิมพ์/บันทึกอื่นๆ เลื่อนอยู่ด้านบน!
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 ()เอาท์พุท:
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...
นอกจากนี้ยังมีพารามิเตอร์ฟังก์ชัน finalize ใหม่ใน alive_it ซึ่งช่วยให้คุณสามารถตั้งชื่อและ/หรือข้อความของใบเสร็จรับเงินขั้นสุดท้ายได้ และรองรับการบันทึกที่ได้รับการปรับปรุงซึ่งตรวจจับตัวบันทึกที่ปรับแต่งเองได้
ทั้งหมดนี้เกี่ยวกับการปรับแต่ง วิดเจ็ตหลักสามารถเปลี่ยนแปลงได้:
monitor , elapsed และวิดเจ็ต stats เพื่อให้ดูตามที่คุณต้องการ!เป็นเรื่องเหลือเชื่อที่สตริงเหล่านี้รองรับฟีเจอร์รูปแบบ Python ทั้งหมด ดังนั้นคุณจึงสามารถเช่น
{percent:.1%}
พวกเขาสามารถปรับแต่งเพิ่มเติมได้เมื่ออยู่ใน ใบเสร็จรับเงินขั้นสุดท้าย !
monitor_end , elapsed_end และ stats_end พร้อมรูปแบบไดนามิกที่สืบทอดมาจากรูปแบบมาตรฐาน!หากคุณเคยซ่อนวิดเจ็ตบางตัวมาก่อน เพียงเพื่อไม่ให้วิดเจ็ตปรากฏบนใบเสร็จรับเงิน ตอนนี้คุณสามารถมองเห็นวิดเจ็ตเหล่านั้นได้อย่างรุ่งโรจน์ และซ่อนเฉพาะวิดเจ็ตเท่านั้น! หรือวิธีอื่น ๆ ?
นอกจากนี้ alive-progress ทำให้การรับครั้งสุดท้ายสวยงามทุกครั้งที่หยุด แม้ว่าคุณจะกด CTRL+C ก่อนเวลาอันควรก็ตาม! ไม่รู้ว่าทำไมฉันไม่เคยคิดเรื่องนี้มาก่อน...
Download |██████████████████︎ | (!) 45/100 [45%] in 4.8s (9.43/s)
และสุดท้าย คุณสามารถเลือกปิดการใช้งาน CTRL+C ได้เลย! ค่าเริ่มต้นคือ safer ctrl_c=True ซึ่งทำให้ CTRL-C ทำงานตามปกติ
ปิดการใช้งาน ctrl_c=False เพื่อให้การโต้ตอบของคุณ alive_bar ใช้งานได้ราบรื่นขึ้นมาก (ไม่มีการติดตามสแต็กหากคุณหยุด) และ/หรือหากอยู่ที่ระดับบนสุดของโปรแกรมของคุณ!
ระวัง: ถ้ามันอยู่ใน for-loop มันจะดำเนินต่อไปในการวนซ้ำครั้งถัดไป ซึ่งอาจเป็นสิ่งที่คุณต้องการหรือไม่ก็ได้...
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 ()เอาท์พุท:
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)
...
ในที่สุดคุณสมบัติใหม่ๆ ที่สำคัญๆ ที่มักถูกร้องขอก็มาถึงแล้ว!
click.echo() ใหม่ ใช่! ขณะนี้ alive-progress ได้รับการสนับสนุน Jupyter Notebooks และยังรวมถึงสถานะ ปิดการใช้งาน ด้วย! ทั้งสองเป็นที่ต้องการอย่างมาก และในที่สุดก็ได้มาถึงแล้ว!
และที่ดีกว่านั้น ฉันได้ใช้กลไกการตรวจจับอัตโนมัติสำหรับโน้ตบุ๊ก jupyter ดังนั้นมันจึงใช้งานได้ทันทีโดยไม่ต้องเปลี่ยนโค้ดของคุณ!!
ดูด้วยตัวคุณเอง:
ดูเหมือนว่าจะทำงานได้ดีมาก แต่ในขณะนี้ ควรได้รับการพิจารณาว่า เป็นการทดลอง
มีกรณีที่เกิดความบกพร่องทางการมองเห็น เช่น การรีเฟรชalive_barสองครั้งถูกต่อเข้าด้วยกันแทนที่จะต่อกัน... และเป็นสิ่งที่ฉันคิดว่าฉันไม่สามารถแก้ไขได้: ดูเหมือนว่าบางครั้ง Jupyter จะรีเฟรชผืนผ้าใบในเวลาที่ไม่ปกติ ซึ่งทำให้ข้อมูลบางส่วนสูญหาย โปรดแจ้งให้เราทราบในประเด็นต่างๆ หากมีเรื่องตลกเกิดขึ้น
นี่คือความก้าวหน้าครั้งสำคัญใน alive-progress !
ฉันใช้เวลา 1 ปีในการพัฒนา และฉันก็ภูมิใจกับความสำเร็จที่ได้ทำสำเร็จ o/
.check() ใหม่ที่ทรงพลังและสวยงาม ซึ่งรวบรวมและเรนเดอร์เฟรมทั้งหมดจากรอบแอนิเมชั่นทั้งหมดของสปินเนอร์และบาร์ได้อย่างสวยงาม! พวกมันยังสามารถรวมข้อมูลเฟรมที่สมบูรณ์ จุดรหัสภายใน และแม้กระทั่งภาพเคลื่อนไหว! -alive-progress !alive_it ที่ยอมรับการทำซ้ำได้และการเรียก bar() สำหรับคุณ!เนื่องจากนี่คือการเปลี่ยนแปลงเวอร์ชันหลัก จึงไม่รับประกันความเข้ากันได้แบบย้อนหลังโดยตรง หากมีบางอย่างใช้งานไม่ได้ในตอนแรก เพียงตรวจสอบลายเซ็นการนำเข้าและฟังก์ชันใหม่ เท่านี้คุณก็พร้อมแล้ว คุณสมบัติก่อนหน้านี้ทั้งหมดควรยังคงใช้งานได้ที่นี่! -
alive-progressเพียงติดตั้งด้วย pip:
❯ pip install alive-progress หากคุณสงสัยว่ามีสไตล์อะไรในตัวก็ถึง showtime ! -
from alive_progress . styles import showtime
showtime ()หมายเหตุ: โปรดมองข้ามเส้นทางในภาพเคลื่อนไหว GIF ด้านล่าง เส้นทางที่ถูกต้องอยู่ด้านบน GIF ขนาดยาวเหล่านี้ใช้เวลานานมากในการสร้าง ดังนั้นฉันจึงไม่สามารถสร้างใหม่ได้ในการเปลี่ยนแปลงทุกครั้ง ขอบคุณสำหรับความเข้าใจของคุณ.
ฉันสร้างสไตล์เหล่านี้เพื่อลองใช้โรงงานแอนิเมชันทั้งหมดที่ฉันสร้างขึ้น แต่ฉันคิดว่าบางสไตล์ก็เจ๋งมาก! ใช้มันได้ตามต้องการและผสมให้เข้ากันตามใจคุณ!
คุณต้องการที่จะเห็นแถบ alive-progress จริงที่ทำงานอย่างรุ่งโรจน์ในระบบของคุณก่อนที่จะลองด้วยตัวเองหรือไม่?
❯ python -m alive_progress.tools.demo เจ๋งใช่มั้ย?? ตอนนี้ป้อน ipython REPL แล้วลองสิ่งนี้:
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 ()คุณจะเห็นสิ่งนี้พร้อมภาพเคลื่อนไหวเจ๋งๆ ตลอดกระบวนการ ?:
|████████████████████████████████████████| 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)
ดีใช่มั้ย? รักมันเหรอ? ฉันรู้ว่าคุณจะทำ ขอบคุณ?.
หากต้องการใช้งานจริง เพียงรวมลูปปกติของคุณไว้ในตัวจัดการบริบท alive_bar ดังนี้:
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 endและมันก็ยังมีชีวิตอยู่! -
โดยสรุป: ดึงข้อมูลรายการต่างๆ เช่นเคย ป้อนเครื่องมือจัดการบริบท alive_bar พร้อมจำนวนรายการ จากนั้นวนซ้ำ/ประมวลผลรายการเหล่านั้น โดยเรียก bar() ในตอนท้าย! มันง่ายมาก! -
items สามารถทำซ้ำได้ เช่น ชุดแบบสอบถามalive_bar คือผลรวมที่คาดหวัง เช่น qs.count() สำหรับชุดแบบสอบถาม len(items) สำหรับการทำซ้ำที่มีความยาว หรือแม้แต่ตัวเลขคงที่bar() คือสิ่งที่ทำให้แถบไปข้างหน้า โดยปกติคุณจะเรียกมันในทุก ๆ รอบ หลังจากเสร็จสิ้นรายการbar() มากเกินไป (หรือน้อยเกินไปในตอนท้าย) แถบจะแสดงค่าเบี่ยงเบนนั้นจากผล total ที่คาดหวังไว้แบบกราฟิก ทำให้ง่ายต่อการสังเกตการล้นและอันเดอร์โฟลว์bar.currentคุณสามารถสร้างสรรค์ได้! เนื่องจาก bar จะเดินหน้าต่อเมื่อคุณเรียก
bar()เท่านั้น มันจึง ไม่ขึ้นอยู่กับ loop ! ดังนั้นคุณสามารถใช้มันเพื่อตรวจสอบสิ่งที่คุณต้องการ เช่น ธุรกรรมที่รอดำเนินการ รายการที่เสียหาย ฯลฯ หรือแม้แต่เรียกมันมากกว่าหนึ่งครั้งในการวนซ้ำครั้งเดียวกัน! ดังนั้น ในท้ายที่สุด คุณจะได้รู้ว่ามีกิจกรรม "พิเศษ" เหล่านั้นจำนวนเท่าใด รวมถึงเปอร์เซ็นต์ที่สัมพันธ์กับทั้งหมดด้วย!
ขณะที่อยู่ในบริบทของ alive_bar คุณสามารถแสดงข้อความที่ผสานรวมกับแถบความคืบหน้าที่กำลังแสดงอยู่ได้อย่างง่ายดาย! มันจะไม่พัง แต่อย่างใดและยังทำให้ข้อความของคุณดีขึ้นอีกด้วย!
bar.text('message') และ bar.text = 'message' ตั้งค่าข้อความตามสถานการณ์ภายในแถบ ซึ่งคุณสามารถแสดงบางอย่างเกี่ยวกับรายการปัจจุบันหรือระยะที่การประมวลผลอยู่bar.title('Title') และ bar.title = 'Title' — ผสมกับ title_length เพื่อป้องกันไม่ให้แถบเปลี่ยน ความยาว;print() ตามปกติ โดยที่ alive_bar ทำความสะอาดบรรทัดอย่างสวยงาม พิมพ์ข้อความของคุณข้างตำแหน่งแถบปัจจุบันในขณะนั้น และยังคงแถบด้านล่างต่อไปlogging Python มาตรฐาน รวมถึงเอาต์พุตของไฟล์นั้นได้รับการปรับปรุงให้เหมือนกับเฟรมเวิร์กก่อนหน้าทุกประการclick.echo() เพื่อพิมพ์ข้อความที่มีสไตล์ได้เจ๋งใช่มั้ยล่ะ? และทั้งหมดนี้ทำงานเหมือนกันในเทอร์มินัลหรือในสมุดบันทึก Jupyter!
ตอนนี้คุณมีวิธีติดตามทุกสิ่งได้รวดเร็วยิ่งขึ้น! ที่นี่รายการต่างๆ จะถูกติดตามโดยอัตโนมัติสำหรับคุณ!
ดูอะแดปเตอร์ตัววนซ้ำ alive_it => alive_bar !
เพียงใช้มันห่อสิ่งของของคุณแล้ววนทับตามปกติ!
บาร์ก็จะใช้งานได้ มันง่ายมาก!
from alive_progress import alive_it
for item in alive_it ( items ): # <<-- wrapped items
print ( item ) # process each itemมันเจ๋งขนาดไหน! -
พารามิเตอร์ alive_bar ทั้งหมดใช้แต่ total ซึ่งฉลาดกว่า (หากไม่ได้ระบุไว้ ระบบจะอนุมานอัตโนมัติจากข้อมูลของคุณโดยใช้ len หรือ length_hint ) และ manual ที่ไม่สมเหตุสมผลที่นี่
โปรดทราบว่าไม่มีที่จับ bar อยู่ในนั้นเลย แต่ถ้าคุณต้องการ เช่น ตั้งค่าข้อความหรือดึงข้อมูลความคืบหน้าปัจจุบันล่ะ
คุณสามารถโต้ตอบกับ alive_bar ภายในได้โดยเพียงกำหนด alive_it ให้กับตัวแปรดังนี้:
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! โปรดทราบว่านี่เป็น bar พิเศษเล็กน้อย ซึ่งไม่รองรับ bar() เนื่องจากอะแดปเตอร์ตัววนซ้ำจะติดตามรายการต่างๆ ให้คุณโดยอัตโนมัติ นอกจากนี้ยังรองรับ finalize ซึ่งช่วยให้คุณสามารถตั้งชื่อและ/หรือข้อความของใบเสร็จรับเงินขั้นสุดท้ายได้:
alive_it ( items , finalize = lambda bar : bar . text ( 'Success!' ))
...โดยสรุป:
- การใช้งานเต็มรูปแบบมักจะ
with alive_bar() as barซึ่งคุณวนซ้ำและเรียกbar()ทุกครั้งที่คุณต้องการ- การใช้อแด็ปเตอร์ด่วน
for item in alive_it(items)โดยที่รายการจะถูกติดตามโดยอัตโนมัติ- การใช้อแด็ปเตอร์แบบสมบูรณ์คือ
bar = alive_it(items)โดยที่นอกเหนือจากรายการที่ถูกติดตามโดยอัตโนมัติแล้ว คุณยังได้รับbarที่ทำซ้ำได้พิเศษที่สามารถปรับแต่งalive_progressอยู่ภายในได้ตามที่คุณต้องการ
โหมดเริ่มต้นคือ อัตโนมัติ และ ไม่ทราบ ซึ่งใช้ ตัวนับ ภายในเพื่อติดตามความคืบหน้า พวกเขานับจำนวนรายการที่ประมวลผล และใช้มันเพื่ออัปเดตแถบความคืบหน้าตามลำดับ
อาร์กิวเมนต์ total เป็นทางเลือก หากคุณระบุ แถบจะเข้าสู่ โหมดอัตโนมัติ ในโหมดนี้ ความคืบหน้าของการดำเนินการจะถูกติดตามโดยอัตโนมัติ และมีวิดเจ็ต alive-progress ทั้งหมดที่มีให้ใช้งาน: แถบที่แม่นยำ สปินเนอร์ เปอร์เซ็นต์ ตัวนับ ปริมาณงาน และการทางพิเศษแห่งประเทศไทย
หากคุณไม่ระบุ total แถบจะเข้าสู่ โหมดที่ไม่รู้จัก ในโหมดนี้ ความคืบหน้าจะกำหนดไม่ได้ ดังนั้น ETA ดังนั้นแถบความคืบหน้าทั้งหมดจึงเคลื่อนไหวอย่างต่อเนื่อง วิดเจ็ตที่ใช้ได้ได้แก่: แถบภาพเคลื่อนไหว, สปินเนอร์, ตัวนับ และทรูพุต
สปินเนอร์สุดเจ๋งทำงานโดยสมบูรณ์โดยไม่ขึ้นอยู่กับแถบภาพเคลื่อนไหว โดยทั้งคู่รันแอนิเมชั่นของตัวเองไปพร้อมๆ กัน แสดงผลการแสดงที่ไม่ซ้ำใครในเทอร์มินัลของคุณ! -
สุดท้ายแต่ไม่ท้ายสุด โหมด อัตโนมัติ มีความสามารถเฉพาะตัว: ทำเครื่องหมายรายการว่าข้ามไป ทำให้ปริมาณงานและการทางพิเศษแห่งประเทศไทยแม่นยำยิ่งขึ้น! เพิ่มเติมเกี่ยวกับเรื่องนี้ในภายหลัง
โหมดแมนนวล ซึ่งเปิดใช้งานด้วยตนเองโดยอาร์กิวเมนต์ manual=True ใช้ เปอร์เซ็นต์ ภายในเพื่อติดตามความคืบหน้า ช่วยให้คุณควบคุมตำแหน่งบาร์ได้อย่างสมบูรณ์ โดยปกติจะใช้เพื่อตรวจสอบกระบวนการที่ป้อนเปอร์เซ็นต์ของความสำเร็จให้คุณเท่านั้น หรือเพื่อสร้างเอฟเฟกต์พิเศษแบบสุ่ม
คุณสามารถใช้มันได้โดยตรงกับ alive_bar หรือผ่าน config_handler และช่วยให้คุณสามารถส่งเปอร์เซ็นต์ไปยังตัวจัดการ bar() ได้! ตัวอย่างเช่น หากต้องการตั้งค่าให้เสร็จสมบูรณ์ 15% เพียงเรียก bar(0.15) ซึ่งก็คือ 15/100
คุณสามารถระบุยอด total ได้ที่นี่ หากคุณทำเช่นนั้น alive-progress จะอนุมานตัวนับภายในโดยอัตโนมัติ และจะสามารถเสนอวิดเจ็ตแบบเดียวกันทั้งหมดให้คุณในโหมดอัตโนมัติได้!
หากคุณไม่ระบุผล total อย่างน้อยที่สุดคุณจะได้รับเวอร์ชันคร่าวๆ ของปริมาณงานและวิดเจ็ต ETA ซึ่งคำนวณเป็น "%/s" (เปอร์เซ็นต์ต่อวินาที) และจนถึง 100% ตามลำดับ ทั้งสองอย่างไม่ถูกต้องนัก แต่ก็ดีกว่าไม่มีอะไรเลย
เมื่อ total ทุกอย่างเรียบร้อยแล้ว:
| โหมด | เคาน์เตอร์ | เปอร์เซ็นต์ | ปริมาณงาน | การทางพิเศษแห่งประเทศไทย | เกิน/อันเดอร์โฟลว์ |
|---|---|---|---|---|---|
| อัตโนมัติ | ✅ (ติ๊กผู้ใช้) | ✅ (อนุมาน) | |||
| คู่มือ | ✅ (อนุมาน) | ✅ (ชุดผู้ใช้) |
เมื่อไม่เป็นเช่นนั้น จะต้องมีการประนีประนอมบางประการ:
| โหมด | เคาน์เตอร์ | เปอร์เซ็นต์ | ปริมาณงาน | การทางพิเศษแห่งประเทศไทย | เกิน/อันเดอร์โฟลว์ |
|---|---|---|---|---|---|
| ไม่ทราบ | ✅ (ติ๊กผู้ใช้) | ||||
| คู่มือ | ✅ (ชุดผู้ใช้) |
แต่จริงๆ แล้วเป็นเรื่องง่ายที่จะเข้าใจ: คุณไม่จำเป็นต้องคิดว่าควรใช้โหมดใด!
total เสมอหากคุณมี และใช้ manual หากต้องการ!แค่นั้นแหละ! มันจะทำงานได้ดีที่สุดเท่าที่จะทำได้! - o/
bar() ที่แตกต่างกัน ตัวจัดการ bar() รองรับความหมายแบบสัมพัทธ์หรือแบบสัมบูรณ์ ขึ้นอยู่กับโหมด:
bar() เพื่อเพิ่มตัวนับทีละหนึ่ง หรือส่งส่วนเพิ่มอื่นๆ เช่น bar(200) เพื่อเพิ่มทีละ 200 ในครั้งเดียวพวกเขายังรองรับ
bar(0)และbar(-5)เพื่อพักหรือลดขนาดหากจำเป็น!
bar(0.35) เพื่อให้แถบเลื่อนไปที่ความคืบหน้า 35% ได้ทันทีทั้งสองโหมดช่วยให้คุณสร้างสรรค์ได้! เนื่องจากคุณสามารถทำให้แถบเลื่อนไปยังตำแหน่งใดก็ได้ที่คุณต้องการทันที คุณจึงสามารถ:
- ทำให้มันย้อนกลับ - เช่นเพื่อแสดงการหมดเวลาของบางสิ่งแบบกราฟิก
- สร้างเอฟเฟ็กต์พิเศษ เช่น เพื่อเลียนแบบมาตรวัดแอนะล็อกแบบเรียลไทม์บางประเภท
คุณสามารถเรียก bar() ได้บ่อยเท่าที่คุณต้องการ! อัตรารีเฟรชเทอร์มินัลจะถูกคำนวณแบบอะซิงโครนัสตามปริมาณงานและความคืบหน้าในปัจจุบัน ดังนั้นคุณจะไม่เสี่ยงที่จะส่งการอัปเดตเทอร์มินัลเกินความจำเป็น
ไม่ว่าในกรณีใด หากต้องการดึงข้อมูลตัวนับ/เปอร์เซ็นต์ปัจจุบัน เพียงโทร: bar.current :
สุดท้าย ตัวจัดการ bar() ใช้ประโยชน์จากความสามารถเฉพาะของโหมด อัตโนมัติ : เพียงเรียก bar(skipped=True) หรือ bar(N, skipped=True) เพื่อใช้งาน เมื่อตั้งค่า skipped เป็น= True รายการที่เกี่ยวข้องจะถูกแยกออกจากการคำนวณปริมาณงาน เพื่อป้องกันไม่ให้รายการที่ข้ามส่งผลกระทบอย่างไม่ถูกต้องต่อการทางพิเศษแห่งประเทศไทย
การดูแลรักษาโครงการโอเพ่นซอร์สนั้นยากและใช้เวลานาน และฉันได้ทุ่มเท ❤️ และความพยายามอย่างมากในเรื่องนี้
หากคุณชื่นชมผลงานของฉัน คุณสามารถสนับสนุนฉันได้ด้วยการบริจาค! ขอบคุณ ?
การจัดแสดง showtime มีตัวเลือกอาร์กิวเมนต์ให้เลือกว่าจะนำเสนอรายการใด ได้แก่ Show.SPINNERS (ค่าเริ่มต้น), Show.BARS หรือ Show.THEMES โปรดดูที่รายการเหล่านั้น! -
from alive_progress . styles import showtime , Show
showtime ( Show . BARS )
showtime ( Show . THEMES )หมายเหตุ: โปรดมองข้ามเส้นทางในภาพเคลื่อนไหว GIF ด้านล่าง เส้นทางที่ถูกต้องอยู่ด้านบน GIF ขนาดยาวเหล่านี้ใช้เวลานานมากในการสร้าง ดังนั้นฉันจึงไม่สามารถสร้างใหม่ได้ในการเปลี่ยนแปลงทุกครั้ง ขอบคุณสำหรับความเข้าใจของคุณ.
และธีมหนึ่ง (? ใหม่ใน 2.0):
การจัดแสดง showtime ยังยอมรับตัวเลือกการปรับแต่งบางอย่างด้วย:
ตัวอย่างเช่น หากต้องการดูการแสดงทางทะเล คุณสามารถ showtime(pattern='boat|fish|crab') :
คุณยังสามารถเข้าถึงรายการเหล่านี้ได้โดยใช้ชวเลข
show_bars(),show_spinners()และshow_themes()!
นอกจากนี้ยังมียูทิลิตี้ขนาดเล็กที่เรียกว่า
print_chars()เพื่อช่วยค้นหาตัวละครเจ๋งๆ ที่จะใส่ในสปินเนอร์และแท่งที่คุณกำหนดเอง หรือเพื่อตรวจสอบว่าเทอร์มินัลของคุณรองรับอักขระ Unicode หรือไม่
มีหลายตัวเลือกในการปรับแต่งทั้งรูปลักษณ์และลักษณะการทำงาน!
ทั้งหมดสามารถตั้งค่าได้ทั้งโดยตรงใน alive_bar หรือทั่วโลกใน config_handler !
นี่คือตัวเลือก - ค่าเริ่มต้นในวงเล็บ:
title : ชื่อแถบที่ไม่บังคับและมองเห็นได้ตลอดเวลาlength : [ 40 ] จำนวนคอลัมน์ในการแสดงแถบความคืบหน้าแบบเคลื่อนไหวmax_cols : [ 80 ] คอลัมน์สูงสุดที่จะใช้หากไม่สามารถดึงข้อมูลได้ เช่นใน jupyterspinner : รูปแบบสปินเนอร์ที่จะแสดงผลถัดจากแถบbar : สไตล์แท่งที่จะเรนเดอร์ในโหมดที่รู้จักunknown : รูปแบบแถบที่จะแสดงผลในโหมดที่ไม่รู้จักtheme : [ 'smooth' ] ชุดสปินเนอร์ บาร์ และไม่ทราบที่มาที่ตรงกันforce_tty : [ None ] บังคับให้เปิด ปิด หรือตาม tty (รายละเอียดเพิ่มเติมที่นี่)file : [ sys.stdout ] วัตถุไฟล์ที่จะใช้: sys.stdout , sys.stderr หรือ TextIOWrapper ที่คล้ายกันdisable : [ False ] หากเป็น True ปิดการใช้งานเอาต์พุตทั้งหมดโดยสมบูรณ์ ไม่ต้องติดตั้ง hooksmanual : [ False ] ตั้งค่าให้ควบคุมตำแหน่งแถบด้วยตนเองenrich_print : [ True ] เพิ่มคุณค่าการพิมพ์ () และการบันทึกข้อความด้วยตำแหน่งแถบenrich_offset : [ 0 ] ออฟเซ็ตที่จะใช้กับ rich_printreceipt : [ True ] พิมพ์ใบเสร็จรับเงินสุดท้ายที่ดี ปิดใช้งานหากเป็นเท็จreceipt_text : [ False ] ตั้งค่าให้ทำซ้ำข้อความสุดท้ายในใบเสร็จรับเงินสุดท้ายmonitor (bool|str): [ True ] กำหนดค่าวิดเจ็ตจอภาพ 152/200 [76%]{count} , {total} และ {percent} เพื่อปรับแต่งelapsed (bool|str): [ True ] กำหนดค่าวิดเจ็ตเวลาที่ผ่านไป in 12s{elapsed} เพื่อปรับแต่งstats (bool|str): [ True ] กำหนดค่าวิดเจ็ตสถิติ (123.4/s, eta: 12s){rate} และ {eta} เพื่อปรับแต่งmonitor_end (bool|str): [ True ] กำหนดค่าวิดเจ็ตมอนิเตอร์ภายในการรับครั้งสุดท้ายmonitorelapsed_end (bool|str): [ True ] กำหนดค่าวิดเจ็ตเวลาที่ผ่านไปภายในการรับครั้งสุดท้ายelapsedstats_end (bool|str): [ True ] กำหนดค่าวิดเจ็ตสถิติภายในการรับครั้งสุดท้าย{rate} เพื่อปรับแต่ง (ไม่เกี่ยวข้องกับสถิติ)title_length : [ 0 ] แก้ไขความยาวของชื่อเรื่อง หรือ 0 สำหรับไม่จำกัดspinner_length : [ 0 ] บังคับความยาวของสปินเนอร์ หรือ 0 สำหรับความยาวธรรมชาติrefresh_secs : [ 0 ] บังคับให้ช่วงเวลารีเฟรชเป็นเช่นนี้ 0 คือการตอบสนองด้วยภาพเชิงโต้ตอบctrl_c : [ True ] หากเป็น False ให้ปิดใช้งาน CTRL+C (จับภาพ)dual_line : [ False ] ถ้าเป็น True ให้วางข้อความไว้ใต้แถบunit : ข้อความใดๆ ที่ติดป้ายกำกับเอนทิตีของคุณscale : มาตราส่วนที่จะใช้กับหน่วย: None , SI , IEC หรือ SI2False หรือ '' -> None , True -> SI , 10 หรือ '10' -> SI , 2 หรือ '2' -> IECprecision : [ 1 ] จำนวนทศนิยมที่แสดงเมื่อปรับขนาด และยังมีอีกอันหนึ่งที่สามารถตั้งค่าได้เฉพาะในบริบทของ alive_bar เท่านั้น:
calibrate : ปริมาณงานทางทฤษฎีสูงสุดเพื่อปรับเทียบความเร็วของภาพเคลื่อนไหว (รายละเอียดเพิ่มเติมที่นี่) หากต้องการตั้งค่าในเครื่อง เพียงส่งเป็นอาร์กิวเมนต์คำหลักไปที่ alive_bar :
with alive_bar ( total , title = 'Processing' , length = 20 , bar = 'halloween' ) as bar :
... หากต้องการใช้ทั่วโลก ให้ส่งไปที่ config_handler และ alive_bar ใดๆ ที่สร้างขึ้นหลังจากนั้นจะรวมตัวเลือกเหล่านั้นไว้ด้วย! และคุณสามารถผสมและจับคู่พวกมันได้ ตัวเลือกท้องถิ่นจะมีความสำคัญมากกว่าตัวเลือกระดับโลกเสมอ:
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'.
... ใช่แล้ว คุณสามารถประกอบสปินเนอร์ของคุณเองได้! และมันง่ายมาก!
ฉันได้สร้างเอฟเฟกต์พิเศษมากมาย ดังนั้นคุณจึงสามารถมิกซ์แอนด์แมทช์เอฟเฟกต์เหล่านั้นตามที่คุณต้องการ! มีทั้งเฟรม เลื่อน เด้ง ต่อเนื่อง ข้าง ๆ และดีเลย์สปินเนอร์! สร้างสรรค์! -
แอนิเมชั่นของสปินเนอร์ได้รับการออกแบบโดยการแสดงออกของตัวสร้างขั้นสูง ลึกเข้าไปในโรงงานเมตา โรงงาน และเครื่องกำเนิดไฟฟ้าหลายชั้น ?!
alive_bar และ config_handler ;เครื่องกำเนิดเหล่านี้มีความสามารถในการสร้างวงจรแอนิเมชั่นที่แตกต่างกันหลายรอบตามพฤติกรรมของสปินเนอร์ เช่น สปินเนอร์ที่เด้งสามารถวิ่งหนึ่งรอบเพื่อนำวัตถุเข้าสู่ฉากได้อย่างราบรื่น จากนั้นจึงเปลี่ยนตำแหน่งซ้ำๆ จนกระทั่งอีกด้านหนึ่ง จากนั้นทำให้มันหายไปจากฉากอย่างราบรื่น = >และนี่เป็นเพียงรอบเดียวเท่านั้น! จากนั้นก็สามารถตามด้วยวงจรอื่นเพื่อให้ทุกอย่างกลับมาเหมือนเดิมได้! และสปินเนอร์ที่ตีกลับยังยอมรับรูปแบบ ที่แตกต่างกัน และ สลับกัน ในทิศทางขวาและซ้าย ซึ่งทำให้พวกมันสร้างผลคูณคาร์ทีเซียนของชุดค่าผสมทั้งหมด ซึ่งอาจสร้างรอบที่แตกต่างกันหลายสิบรอบจนกว่าพวกมันจะเริ่มทำซ้ำ!! -
และยิ่งกว่านั้น ฉันคิดว่าหนึ่งในความสำเร็จที่น่าประทับใจที่สุดที่ฉันได้รับในระบบแอนิเมชั่นนี้ (นอกเหนือจากคอมไพเลอร์สปินเนอร์เอง)... พวกมันจะให้เฟรมแอนิเมชั่นมากขึ้นเท่านั้นจนกว่ารอบปัจจุบันจะไม่หมดลง จากนั้น พวกมันก็หยุดเอง ! ใช่แล้ว รอบต่อไปยังไม่เริ่ม! พฤติกรรมนี้จะสร้างการหยุดพักอย่างเป็นธรรมชาติในตำแหน่งที่ถูกต้อง โดยที่ภาพเคลื่อนไหวจะไม่ถูกรบกวน ดังนั้นฉันจึงสามารถเชื่อมโยงกับแอนิเมชั่นอื่น ๆ ที่ฉันต้องการได้อย่างราบรื่น!!
สิ่งนี้มีผลกระทบที่ยอดเยี่ยมทุกรูปแบบ: ไซเคิลสามารถมีจำนวนเฟรมต่างกัน ความยาวหน้าจอต่างกัน ไม่จำเป็นต้องซิงโครไนซ์ สามารถสร้างซีเควนซ์ยาว ๆ ที่แตกต่างกันได้ด้วยตัวเอง พวกเขาสามารถร่วมมือกันเล่นไซเคิลตามลำดับหรือเคียงข้างกัน และฉัน สามารถทำให้คุณประหลาดใจกับการแสดงภาพเคลื่อนไหวที่แตกต่างกันโดยสิ้นเชิงหลายรายการพร้อมกันโดยไม่มีการรบกวนใดๆ เลย!
แทบจะเหมือนว่าพวกเขา... มีชีวิตอยู่ !! -
==> ใช่แล้ว นั่นคือที่มาของชื่อโครงการนี้!
ตอนนี้ ตัวกำเนิดของรอบและเฟรมเหล่านี้ถูกใช้หมดล่วงหน้าโดย Spinner Compiler ! นี่เป็นโปรเซสเซอร์ใหม่ที่ยอดเยี่ยมมากที่ฉันสร้างขึ้นโดยใช้ความพยายามของ Cell Architecture เพื่อให้แอนิเมชั่นทั้งหมดนี้ทำงานได้แม้ในที่ที่มีตัวอักษรกว้างหรือกลุ่มกราฟที่ซับซ้อน! เป็นเรื่องยากมากที่จะทำให้คลัสเตอร์เหล่านี้ค่อยๆ เข้าและออกจากเฟรมได้อย่างราบรื่น ในขณะเดียวกันก็ป้องกันไม่ให้คลัสเตอร์เหล่านี้ทำลายการเข้ารหัส Unicode และโดยเฉพาะอย่างยิ่งรักษาความยาวดั้งเดิมในทุกเฟรม! ใช่ อักขระหลายตัวเรียงตามลำดับสามารถแทนสัญลักษณ์อื่นที่แตกต่างไปจากเดิมอย่างสิ้นเชิง ดังนั้นจึงไม่สามารถแยกออกได้! พวกเขาต้องเข้าและออกจากเฟรมพร้อมกันตลอดเวลา ไม่เช่นนั้นกราฟจะไม่แสดงขึ้นมาเลย (เช่น อิโมจิ)!! เข้าสู่ คอมไพเลอร์สปินเนอร์ ......
ทำให้เกิดเรื่องเหลือเชื่อขึ้นได้!! เนื่องจากคอมไพเลอร์นี้สร้างข้อมูลเฟรมสปินเนอร์ทั้งหมดไว้ล่วงหน้า:
ดังนั้น ฉันสามารถรวบรวมแอนิเมชั่นทั้งหมดที่ พร้อมเล่น และทำมันให้เสร็จ ไม่มีค่าใช้จ่ายรันไทม์ เลย!! -
นอกจากนี้ เมื่อข้อมูลเฟรมสมบูรณ์ถูกคอมไพล์และคงอยู่ ฉันสามารถสร้างคำสั่งต่างๆ เพื่อ ปรับโครงสร้าง ข้อมูลนั้นได้ เช่น การเปลี่ยนรูปร่าง การแทนที่ตัวอักษร การเพิ่มการหยุดการมองเห็น (การทำซ้ำเฟรม) การสร้างเอฟเฟกต์การเด้งตามความต้องการของเนื้อหาใดๆ และแม้แต่การเปลี่ยนวงจร พร้อมกรอบ!!
แต่คุณจะเห็นผลกระทบเหล่านี้ได้อย่างไร? เอฟเฟกต์ที่คุณสร้างดูดีหรือไม่? หรือมันไม่ได้ผลอย่างที่คิด? ใช่ ตอนนี้คุณสามารถดูรอบและเฟรมที่สร้างขึ้นทั้งหมดได้ในเชิงวิเคราะห์ด้วยการแสดงที่สวยงามมาก!!
ฉันชอบสิ่งที่ฉันประสบความสำเร็จที่นี่หรือไม่มันอาจเป็นเครื่องมือที่สวยที่สุดที่ฉันเคยสร้างมา ... ดูเครื่องมือ check !!
มันยอดเยี่ยมถ้าฉันพูดอย่างนั้นใช่มั้ย และซอฟต์แวร์ที่ซับซ้อนมากที่ฉันภูมิใจลองดูที่รหัสหากคุณต้องการ
และเครื่องมือ check มีประสิทธิภาพมากขึ้น! ตัวอย่างเช่นคุณสามารถดู codepoints ของเฟรม !!! และอาจจะเห็นว่าทำไมรุ่นนี้ถึงเป็นเช่นนั้นยากและซับซ้อนมากที่จะทำ ...
ในสีแดงคุณจะเห็นกลุ่มกราฟที่ครอบครอง "ตำแหน่งเชิงตรรกะ" หนึ่งหรือสองตำแหน่งโดยไม่คำนึงถึงขนาดที่แท้จริงของพวกเขา ... นี่คือ "เซลล์" ของ สถาปัตยกรรมเซลล์ ใหม่ ...
ดูสิว่ามีการแสดงธงอิโมจิที่ยอดเยี่ยมแค่ไหน:
ธงดูเหมือนจะเคลื่อนที่ได้อย่างราบรื่นเพราะใช้ "ตัวละครครึ่ง"! เนื่องจากเป็นเครื่องถ่านกว้าง alive-progress รู้ว่ามันจะแสดงผลด้วย "สองตัวที่มองเห็นได้" และภาพเคลื่อนไหวจะพิจารณาสิ่งนี้ แต่ประกอบไปด้วยช่องว่างซึ่งครอบครองเพียงอันเดียว เมื่อมีการใช้พื้นหลังผสมสถานการณ์จะซับซ้อนกว่ามาก ...
ประเภทของโรงงานที่ฉันสร้างขึ้นคือ:
frames : วาดลำดับของตัวละครใด ๆ ที่จะเล่นตามเฟรมตามลำดับ;scrolling : สร้างการไหลที่ราบรื่นจากอีกด้านหนึ่งไปอีกด้านหนึ่งซ่อนตัวอยู่ข้างหลังหรือพันบนเส้นขอบที่มองไม่เห็น - อนุญาตให้ใช้วิชาทีละครั้งสร้างหลายรอบของตัวละครที่แตกต่างกัน;bouncing : คล้ายกับ scrolling แต่ทำให้แอนิเมชั่นเด้งกลับไปสู่จุดเริ่มต้นซ่อนตัวอยู่ข้างหลังหรือตีกลับทันทีตามพรมแดนที่มองไม่เห็นsequential ได้รับโรงงานจำนวนหนึ่งและเล่นเป็นหนึ่งหลังจากอื่น ๆ ตามลำดับ! อนุญาตให้แทรกแซงพวกเขาหรือไม่;alongside ได้รับโรงงานจำนวนหนึ่งและเล่นพร้อมกันทำไมต้องเลือกเมื่อคุณสามารถมีได้ทั้งหมด! อนุญาตให้เลือกเดือยของแอนิเมชั่นdelayed : รับโรงงานอื่น ๆ และคัดลอกหลายครั้งข้ามเฟรมบางส่วนมากขึ้นในแต่ละอัน! เอฟเฟกต์เจ๋งมากทำที่นี่!สำหรับรายละเอียดเพิ่มเติมโปรดดูเอกสารของพวกเขาซึ่งสมบูรณ์มาก
การปรับแต่งบาร์ไม่มีที่ไหนใกล้ที่เกี่ยวข้อง สมมติว่าพวกเขาเป็น "ทันที" วัตถุพาสซีฟ พวกเขาไม่สนับสนุนภาพเคลื่อนไหวเช่นพวกเขาจะสร้างการแปลแบบเดียวกันกับพารามิเตอร์เดียวกันเสมอ จำไว้ว่าสปินเนอร์เป็นเครื่องกำเนิดไฟฟ้าที่ไม่มีที่สิ้นสุดสามารถสร้างลำดับที่ยาวและซับซ้อนได้
บาร์ยังมีโรงงานเมตาใช้การปิดเพื่อจัดเก็บพารามิเตอร์สไตล์และรับพารามิเตอร์การทำงานเพิ่มเติม แต่จากนั้นโรงงานจริงไม่สามารถสร้างเนื้อหาใด ๆ ได้ด้วยตัวเอง มันยังคงต้องการพารามิเตอร์พิเศษจำนวนจุดลอยตัวระหว่าง 0 ถึง 1 ซึ่งเป็นเปอร์เซ็นต์ที่จะทำให้ตัวเองแสดงตัวเอง
alive_barคำนวณเปอร์เซ็นต์นี้โดยอัตโนมัติตามตัวนับและทั้งหมด แต่คุณสามารถส่งด้วยตัวเองเมื่ออยู่ในโหมดmanual!
บาร์ยังไม่มีคอมไพเลอร์บาร์ แต่พวกเขา มีเครื่องมือตรวจสอบ !! -
คุณยังสามารถผสมและจับคู่ถ่านกว้างและตัวถ่านปกติเช่นเดียวกับในสปินเนอร์! (และทุกอย่างยังคงสอดคล้องอย่างสมบูรณ์?)
ใช้เครื่องมือตรวจสอบเนื้อหาหัวใจของคุณ !! พวกเขามีสารพัดมากขึ้นรอคุณแม้กระทั่งภาพเคลื่อนไหวแบบเรียลไทม์!
สร้างแอนิเมชั่นที่น่าจับตามองและเจ๋งที่สุดที่คุณสามารถทำได้และส่งมาให้ฉัน!
ฉันกำลังคิดที่จะสร้างแพ็คเกจcontribบางชนิดด้วยสปินเนอร์และบาร์ที่ผู้ใช้ที่มีส่วนร่วม!
ว้าวถ้าคุณอ่านทุกอย่างจนถึงที่นี่ตอนนี้คุณควรมีความรู้ที่ดีเกี่ยวกับการใช้ alive-progress ! -
แต่รั้งตัวเองเพราะมีสิ่งที่น่าตื่นเต้นมากยิ่งขึ้นอยู่ข้างหน้า!
การบำรุงรักษาโครงการโอเพ่นซอร์สนั้นยากและใช้เวลานานและฉันได้ใช้ความพยายามมากและความพยายามในเรื่องนี้
หากคุณชื่นชมงานของฉันคุณสามารถสำรองฉันด้วยการบริจาค! ขอบคุณ ?
โอ้คุณต้องการหยุดชั่วคราวโดยสิ้นเชิงฉันได้ยินไหม? นี่เป็นแนวคิดนวนิยายที่น่าทึ่งไม่พบที่ใดก็ได้ Afaik
ด้วยสิ่งนี้คุณจะได้รับการดำเนินการในบางรายการ ด้วยตนเอง ตรงกลางของการประมวลผลอย่างต่อเนื่อง !!
ใช่คุณสามารถกลับไปที่พรอมต์และแก้ไขเปลี่ยนส่งสิ่งต่าง ๆ และบาร์จะ "จำ" ได้ที่ไหน ...
สมมติว่าคุณจำเป็นต้องกระทบยอดธุรกรรมการชำระเงิน (เคยทำที่นั่น) คุณต้องวนซ้ำพวกเขาหลายพันคนตรวจจับความผิดพลาดและแก้ไข การแก้ไขนี้ไม่ง่ายหรือไม่แน่นอนคุณต้องศึกษาแต่ละคนเพื่อทำความเข้าใจว่าต้องทำอะไร พวกเขาอาจหายไปจากผู้รับหรือมีจำนวนที่ไม่ถูกต้องหรือไม่ถูกซิงค์กับเซิร์ฟเวอร์ ฯลฯ มันยากที่จะจินตนาการถึงความเป็นไปได้ทั้งหมด
โดยทั่วไปคุณจะต้องปล่อยให้กระบวนการตรวจจับทำงานจนกว่าจะเสร็จสิ้นให้ผนวกเข้ากับรายการแต่ละรายการที่ไม่สอดคล้องกันที่พบและรออยู่นานจนกระทั่งคุณสามารถเริ่มแก้ไขได้ในที่สุด ... หรือพิมพ์และทำหน้าที่ผ่านเปลือกอื่น ฯลฯ แต่สิ่งเหล่านั้นมีข้อบกพร่องของตัวเอง ... ?
ตอนนี้มีวิธีที่ดีกว่า! เพียงหยุดกระบวนการตรวจจับจริงสักพัก! จากนั้นคุณเพียงแค่ต้องรอจนกว่าจะพบความผิดต่อไปและดำเนินการใกล้เวลาจริง!
ในการใช้กลไกการหยุดชั่วคราวคุณเพียงแค่เขียนฟังก์ชั่นดังนั้นรหัสสามารถ yield รายการที่คุณต้องการโต้ตอบด้วย คุณส่วนใหญ่อาจใช้หนึ่งในรหัสของคุณ แต่ใน ipython shell หรืออื่น ๆ ที่คุณอาจไม่ได้ ดังนั้นเพียงแค่ห่อรหัสการดีบักของคุณในฟังก์ชั่นจากนั้นป้อนภายในบริบท 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 () แค่นั้นแหละ! มันง่ายมาก! o/
ตอนนี้เรียกใช้ gen = reconcile_transactions() เพื่อสร้างอินสแตนซ์ตัวสร้างและเมื่อใดก็ตามที่คุณต้องการธุรกรรมที่ผิดพลาดครั้งต่อไปเพียงโทร next(gen, None) ! ฉันรักมัน...
แถบ alive-progress จะเริ่มต้นและทำงานตามปกติ แต่ทันทีที่พบความไม่สอดคล้องใด ๆ แถบจะหยุดชั่วคราวปิดเธรดรีเฟรชและจดจำสถานะที่แน่นอนและให้การทำธุรกรรมให้คุณโดยตรงตามพรอมต์! เกือบจะวิเศษ! -
In [11]: gen = reconcile_transactions()
In [12]: next(gen, None)
|█████████████████████ | 105/200 [52%] in 5s (18.8/s, eta: 4s)
Out[12]: Transaction<#123>
จากนั้นคุณสามารถตรวจสอบธุรกรรมด้วยทางลัด _ ปกติของ ipython (หรือเพียงแค่กำหนดโดยตรงด้วย t = next(gen, None) ) และคุณพร้อมที่จะแก้ไข!
เมื่อเสร็จแล้วให้เปิดใช้งานแถบใหม่ด้วยการโทร next เหมือนเดิม !! บาร์ปรากฏขึ้นอีกครั้งเปิดทุกอย่างกลับมาและดำเนินต่อไป เหมือนไม่เคยหยุด !! โอเคมันเป็นเวทมนตร์?
In [21]: next(gen, None)
|█████████████████████ | ▁▃▅ 106/200 [52%] in 5s (18.8/s, eta: 4s)
ล้างออกและทำซ้ำจนกว่าใบเสร็จสุดท้ายจะปรากฏขึ้นและจะไม่มีการทำธุรกรรมที่ผิดพลาดอีกต่อไป -
ดังนั้นคุณต้องตรวจสอบการดำเนินการคงที่โดยไม่มีลูปใช่ไหม?
มันจะทำงานได้อย่างแน่นอน! นี่คือตัวอย่างที่ไร้เดียงสา (เราจะทำได้ดีกว่าในอีกสักครู่):
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` มันไร้เดียงสาเพราะมันถือว่าทุกขั้นตอนใช้เวลาเท่ากัน แต่จริงๆแล้วแต่ละคนอาจใช้เวลาที่แตกต่างกันมาก คิดว่า read_file และ tokenize อาจจะเร็วมากซึ่งทำให้เปอร์เซ็นต์พุ่งสูงขึ้นถึง 50%จากนั้นหยุดเป็นเวลานานในขั้นตอน process ... คุณได้รับประเด็นมันสามารถทำลายประสบการณ์การใช้งานของผู้ใช้และสร้าง ETA ที่ทำให้เข้าใจผิดมาก
เพื่อปรับปรุงว่าคุณต้องแจกจ่ายเปอร์เซ็นต์ขั้นตอนของขั้นตอน! เนื่องจากคุณบอกกับ alive_bar มีสี่ขั้นตอนเมื่อขั้นตอนแรกเสร็จสมบูรณ์มันเข้าใจ 1/4 หรือ 25% ของการประมวลผลทั้งหมดเสร็จสิ้น ... ดังนั้นคุณต้องวัดระยะเวลาที่คุณใช้และใช้ โหมดแมนนวล นานเท่าใด เพิ่มเปอร์เซ็นต์บาร์ด้วยจำนวนที่เหมาะสมในแต่ละขั้นตอน!
คุณสามารถใช้โครงการโอเพ่นซอร์สอื่น ๆ ของฉันเกี่ยวกับเวลาเพื่อวัดระยะเวลาเหล่านี้ได้อย่างง่ายดาย! เพียงพยายามจำลองด้วยอินพุตตัวแทนบางอย่างเพื่อให้ได้ผลลัพธ์ที่ดีขึ้น บางอย่างชอบ:
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 } ' ) ไปที่นั่น! ตอนนี้คุณรู้ถึงการกำหนดเวลาสัมพัทธ์ของทุกขั้นตอนและสามารถใช้เพื่อปรับปรุงรหัสดั้งเดิมของคุณ! เพิ่งได้รับการกำหนดเวลาสะสมและวางไว้ในโหมดแมนนวล alive_bar !
ตัวอย่างเช่นหากการกำหนดเวลาที่คุณพบคือ 10%, 30%, 20%และ 40%คุณจะใช้ 0.1, 0.4, 0.6 และ 1.0 (อันสุดท้ายควรเป็น 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 stepแค่นั้นแหละ! ประสบการณ์ผู้ใช้และ ETA ควรได้รับการปรับปรุงอย่างมากในขณะนี้
ใช่คุณสามารถปรับความเร็วสปินเนอร์!
แถบ alive-progress มีข้อเสนอแนะภาพที่ยอดเยี่ยมของปริมาณงานปัจจุบันดังนั้นคุณจะ เห็นได้ว่า การประมวลผลของคุณเร็วแค่ไหนเมื่อสปินเนอร์ทำงานได้เร็วขึ้นหรือช้าลง
เพื่อให้สิ่งนี้เกิดขึ้นฉันได้รวบรวมและใช้เส้นโค้ง FPS สองสามเส้นเพื่อค้นหาเชิงประจักษ์ว่าอันไหนให้ความรู้สึกที่ดีที่สุดของความเร็ว:
(เวอร์ชันเชิงโต้ตอบ [ที่นี่] (https://www.desmos.com/calculator/ema05elsux))
กราฟแสดงลอการิทึม (สีแดง), พาราโบลา (สีน้ำเงิน) และเส้นโค้งเชิงเส้น (สีเขียว) นี่คือสิ่งที่ฉันเริ่มต้นด้วย มันไม่ใช่เรื่องง่ายที่ฉันได้ทำการทดสอบหลายสิบครั้งและไม่เคยพบสิ่งที่เป็นแรงบันดาลใจให้กับความรู้สึกของความเร็วที่ฉันกำลังมองหา สิ่งที่ดีที่สุดดูเหมือนจะเป็นลอการิทึม แต่มันก็ตอบสนองได้ไม่ดีด้วยจำนวนน้อย ฉันรู้ว่าฉันสามารถทำให้มันทำงานกับการบิดสองสามครั้งสำหรับตัวเลขเล็ก ๆ เหล่านั้นดังนั้นฉันจึงทดลองมากและปรับเส้นโค้งลอการิทึม (สีส้มจุด) จนกระทั่งในที่สุดฉันก็พบพฤติกรรมที่ฉันคาดหวัง! มันเป็นสิ่งที่ดูเหมือนจะให้การเปลี่ยนแปลงความเร็วรอบการรับรู้ที่ดีที่สุดตลอดทั้งสองสามถึงพันล้าน ... นั่นคือเส้นโค้งที่ฉันได้ตัดสินและเป็นแบบที่ใช้ในทุกโหมดและเงื่อนไข ในอนาคตและหากใครบางคนพบว่ามีประโยชน์เส้นโค้งนั้นสามารถกำหนดค่าได้
การสอบเทียบ alive-progress เริ่มต้นคือ 1,000,000 ในโหมดที่มีขอบเขตเช่นใช้เวลา 1 ล้านการวนซ้ำต่อวินาทีเพื่อให้บาร์รีเฟรชตัวเองที่ 60 เฟรมต่อวินาที ในโหมดที่ไม่มีขอบเขตด้วยตนเองมันคือ 1.0 (100%) ทั้งสองเปิดใช้งานช่วงการดำเนินงานที่กว้างใหญ่และโดยทั่วไปทำงานได้ค่อนข้างดี
ตัวอย่างเช่นดูที่เอฟเฟกต์การสอบเทียบที่แตกต่างกันเหล่านี้มีการเรียกใช้รหัสเดียวกันมากด้วยความเร็วเท่ากัน! สังเกตเห็นความรู้สึกที่สปินเนอร์ส่งผ่านไปยังผู้ใช้การประมวลผลนี้จะช้าหรือเร็วหรือไม่? และโปรดจำไว้ว่าไม่เพียง แต่สปินเนอร์สดชื่น แต่ทั้งเส้นพร้อมด้วยการแปลแท่งและวิดเจ็ตทั้งหมดดังนั้นทุกอย่างจะราบรื่นขึ้นหรือเฉื่อยชา:
ดังนั้นหากการประมวลผลของคุณแทบจะไม่ถึง
40รายการต่อวินาทีและคุณคิดว่ากำลังดำเนินalive-progressยังคงซบเซ ดีกว่าที่จะปล่อยให้ส่วนใหญ่อยู่เสมอและปรับเทียบกับบางสิ่งบางอย่างระหว่าง 50% ถึง 100% จากนั้นปรับแต่งจากที่นั่นเพื่อค้นหาสิ่งที่คุณชอบมากที่สุด! -
ภาพเคลื่อนไหว alive-progress อย่างน่าอัศจรรย์เหล่านี้ปฏิเสธที่จะแสดงหรือไม่?
Pycharm ยอดเยี่ยมฉันรักมัน! แต่ฉันจะไม่เข้าใจว่าทำไมพวกเขาจึงปิดการใช้งานการเลียนแบบเทอร์มินัลโดยค่าเริ่มต้น ... หากคุณใช้คอนโซลเอาท์พุทของ Pycharm โปรดเปิดใช้งานสิ่งนี้ในการกำหนดค่าการทำงานทั้งหมดของคุณ:
ฉันขอแนะนำให้คุณเข้าสู่
File>New Projects Setup>Run Configuration TemplatesเลือกPythonและเปิดใช้งานที่นั่นดังนั้นโครงการใหม่ที่คุณสร้างจะมีชุดนี้อยู่แล้ว
นอกจากนั้นเทอร์มินัลบางตัวยังรายงานตัวเองว่า "ไม่โต้ตอบ" เช่นเมื่อหมดเทอร์มินัลจริง (ตัวอย่างเช่น Pycharm และ Jupyter) ในท่อเชลล์ ( cat file.txt | python program.py ) หรือในพื้นหลัง กระบวนการ (ไม่เชื่อมต่อกับ TTY)
เมื่อ alive-progress พบว่าตัวเองอยู่ในเทอร์มินัลที่ไม่โต้ตอบมันจะปิดใช้งานภาพเคลื่อนไหวทุกชนิดโดยอัตโนมัติพิมพ์เฉพาะใบเสร็จสุดท้าย สิ่งนี้ทำขึ้นเพื่อหลีกเลี่ยงทั้งการส่งออกไปส่งออกและส่งสแปมไฟล์บันทึกของคุณด้วยการรีเฟรช alive-progress นับพัน
ดังนั้นเมื่อคุณรู้ว่ามันปลอดภัยคุณสามารถบังคับให้พวกเขาเห็น alive-progress ในทุกความรุ่งโรจน์! นี่คือข้อโต้แย้ง force_tty :
with alive_bar ( 1000 , force_tty = True ) as bar :
for i in range ( 1000 ):
time . sleep ( .01 )
bar ()ค่าที่ยอมรับคือ:
force_tty=True -> เปิดใช้งานภาพเคลื่อนไหวเสมอและตรวจจับสมุดบันทึก Jupyter อัตโนมัติ!force_tty=False -> ปิดใช้งานภาพเคลื่อนไหวเสมอโดยเก็บเฉพาะใบเสร็จสุดท้ายforce_tty=None (ค่าเริ่มต้น) -> ตรวจจับอัตโนมัติตามสถานะ tty ของเทอร์มินัล คุณสามารถตั้งค่าทั่วทั้งระบบโดยใช้ config_handler ดังนั้นคุณไม่จำเป็นต้องผ่านด้วยตนเองอีกต่อไป
โปรดทราบว่าโน๊ตบุ๊คคอนโซลและ Jupyter ของ Pycharm นั้นมีเครื่องมืออย่างหนักและมีค่าใช้จ่ายมากขึ้นดังนั้นผลลัพธ์อาจไม่เป็นของเหลวอย่างที่คุณคาดหวัง ยิ่งไปกว่านั้นสมุดบันทึก Jupyter ไม่รองรับรหัส Escape ANSI ดังนั้นฉันจึงต้องพัฒนาวิธีแก้ปัญหาบางอย่างเพื่อเลียนแบบฟังก์ชั่นเช่น "ล้างสาย" และ "ชัดเจนจาก
alive_bar" ... มักจะชอบเทอร์มินัลเต็มเปี่ยม
alive-progress ไม่ได้มีการพึ่งพาใด ๆ ตอนนี้มันมีสอง: หนึ่งคือเวลา (อีกโครงการที่น่าสนใจของฉันถ้าฉันพูดอย่างนั้นเอง) ซึ่งใช้ในการติดตามเวลาที่ใช้ในการรวบรวมสปินเนอร์และเพื่อสร้างการกระทำที่เป็นมิตรกับมนุษย์ อีกอันคือกราฟเพื่อตรวจจับการแบ่งคลัสเตอร์กราฟ (ฉันได้เปิดปัญหาที่นั่นถามเกี่ยวกับอนาคตและความถูกต้องของมันและผู้เขียนรับประกันว่าเขาตั้งใจจะอัปเดตโครงการในทุกรุ่น Unicode ใหม่);alive-progress ยังไม่มีชั้น Python เดียว! ตอนนี้มันมีเล็ก ๆ น้อย ๆ ด้วยเหตุผลที่เฉพาะเจาะจงมาก (เปลี่ยน callables, iterator adapters และ descriptors สำหรับวิดเจ็ต alive_bar )alive_bar เองก็เป็นเพียงฟังก์ชั่น! แม้ว่าจะเป็นธรรม แต่ก็เป็น "แค่" ฟังก์ชั่นที่ฉันเสียบปลั๊กหลายครั้งจากภายในเข้าไปในตัวเอง (โปรดจำไว้ว่าฟังก์ชั่น Python มี __dict__ เช่นเดียวกับคลาสที่ทำ?) alive_bar จะสังเกตเห็นการเปลี่ยนแปลงขนาดเทอร์มินัล แต่เพียงตัดทอนบรรทัดตามนั้น)contrib อย่างใดเพื่อให้วิธีง่ายๆในการแบ่งปันสปินเนอร์และแท่งเย็นจากผู้ใช้skippedstderr และไฟล์อื่น ๆ แทน stdoutmonitor elapsed stats
เสร็จสิ้นที่นี่
alive_it ตรวจจับการใช้งานที่ซ้อนกันของ Alive_Progress และส่งข้อความแสดงข้อผิดพลาดที่ชัดเจนขึ้นalive_itskipped , การตั้งค่าการกำหนด max_cols ใหม่สำหรับ JUPYTER, แก้ไขขนาดของเทอร์มินัลเมื่อใช้ Stderr รองรับ Python 3.11 อย่างเป็นทางการsys.stderr และไฟล์อื่น ๆ แทนที่จะเป็น sys.stdout ทำให้การประมาณอัตราการสืบค้นมากขึ้น ข้อมูลระบบช่วยเหลือในข้อผิดพลาดการกำหนดค่าmonitor ที่ปรับแต่งได้, และวิดเจ็ตหลัก stats , monitor_end ใหม่, elapsed_end , และวิดเจ็ elapsed หลักของ stats_end , การสนับสนุนที่ดีขึ้นสำหรับ Ctrl+C ซึ่งทำให้ alive_bar หยุดก่อนกำหนดก่อนกำหนดก่อนกำหนดก่อนกำหนดclick.echo() สนับสนุน; ประสิทธิภาพที่เร็วขึ้น การตรวจจับคอลัมน์เทอร์มินัลที่ปลอดภัยยิ่งขึ้น bar.current ทำหน้าที่เหมือนทรัพย์สิน; ลบ Python 3.6.check() เครื่องมือทั้งในสปินเนอร์และบาร์ การปรับปรุงเครื่องยนต์บาร์และสปินเนอร์ โหมดแอนิเมชั่นใหม่ในสปินเนอร์และลำดับ สปินเนอร์ในตัวใหม่บาร์และธีม เวลา Showtime แบบไดนามิกพร้อมธีมการป้องกันการเลื่อนและรูปแบบตัวกรอง ปรับปรุงการบันทึกสำหรับไฟล์ ตัวเลือกการกำหนดค่าใหม่หลายตัวสำหรับการปรับแต่งลักษณะที่ปรากฏ; ใหม่อะแดปเตอร์ตัววนซ้ำ alive_it ; ใช้ time.perf_counter() นาฬิกาความละเอียดสูง; ต้องใช้ Python 3.6+ (และสนับสนุน Python 3.9 และ 3.10 อย่างเป็นทางการ)bar.current() วิธี; NewLines ได้รับการพิมพ์บน Vanilla Python REPL; แถบถูกตัดทอนเป็น 80 ตัวอักษรบน windowsbar.text() เพื่อตั้งค่าข้อความสถานการณ์ได้ตลอดเวลาโดยไม่ต้องเพิ่มตำแหน่ง (พารามิเตอร์ 'text' decrecates ใน bar() ); การเพิ่มประสิทธิภาพประสิทธิภาพbackground แทน blank ซึ่งยอมรับสตริงที่มีขนาดโดยพลการและยังคงอยู่ในพื้นหลังจำลองแถบ "เหนือมัน"show_spinners และ show_bars , ยูทิลิตี้ใหม่ print_chars , show_bars ได้รับการสาธิตขั้นสูง (ลองอีกครั้ง!) alive_progress จะพยายามติดตาม Python เสมอดังนั้นเริ่มต้นจากเวอร์ชัน 2.0 ฉันจะวางการสนับสนุนสำหรับ Python ทุกรุ่นที่เข้าสู่ EOL ดูตารางเวลาของพวกเขาที่นี่
แต่ไม่ต้องกังวลถ้าคุณยังไม่สามารถโยกย้ายได้: alive_progress เวอร์ชันเป็นไม้ยืนต้นดังนั้นเพียงแค่ใช้รุ่นที่เหมาะกับคุณและคุณก็ดี
ฉันแค่ขอแนะนำอย่างยิ่งการตั้งค่าแพ็คเกจ alive_progress ในไฟล์ข้อกำหนด. txt ด้วยรูปแบบต่อไปนี้ สิ่งเหล่านี้จะดึงการสร้างล่าสุดก่อนหน้านี้ไปยังเวอร์ชันที่กำหนดดังนั้นหากฉันเคยปล่อยข้อผิดพลาดการแก้ไขข้อบกพร่องคุณจะได้รับเช่นกัน
❯ pip install -U " alive_progress<2 "❯ pip install -U " alive_progress<2.2 "❯ pip install -U " alive_progress<3.2 " ซอฟต์แวร์นี้ได้รับอนุญาตภายใต้ใบอนุญาต MIT ดูไฟล์ LICENSE ในไดเร็กทอรีการแจกจ่ายระดับบนสุดสำหรับข้อความลิขสิทธิ์ฉบับเต็ม
การบำรุงรักษาโครงการโอเพนซอร์สนั้นยากและใช้เวลานานและฉันได้ใช้ความพยายามมากและความพยายามในเรื่องนี้
หากคุณชื่นชมงานของฉันคุณสามารถสำรองฉันด้วยการบริจาค! ขอบคุณ ?
