os — שירותי ”מערכת הפעלה“ בסיסיים#

המודול os מכיל פונקציות לגישה למערכת קבצים ולעיגונה, להפניית טרמינל ולשכפולו, ואת הפונקציות uname ו-urandom.

פונקציות כלליות#

os.uname() → Tuple[str, str, str, str, str]#

מחזירה tuple (יכול להיות named tuple) המכיל מידע על המכונה הבסיסית ו/או מערכת ההפעלה שלה. ל-tuple חמישה שדות בסדר הבא, כל אחד מהם מחרוזת:

  • sysname – שם המערכת הבסיסית

  • nodename – שם הרשת (יכול להיות זהה ל-sysname)

  • release – גרסת המערכת הבסיסית

  • version – גרסת MicroPython ותאריך הבנייה

  • machine – מזהה לחומרה הבסיסית (למשל, לוח, מעבד)

os.urandom(n: int) → bytes#

מחזירה אובייקט bytes עם n בתים אקראיים. המקור מתאים מבחינה קריפטוגרפית בכל מצלמה נתמכת, אם כי המימוש משתנה לפי port:

  • מצלמות STM32 (M4, M7, H7, H7+, PT, N6) משתמשות בהתקן ה-RNG החומרתי של STM32.

  • מצלמות i.MX RT1062 (RT1060) משתמשות ב-TRNG החומרתי של השבב.

  • מצלמות Alif Ensemble (AE3) משתמשות בשירות האקראי החומרתי של ה-Secure Enclave.

  • Arduino Nano 33 BLE Sense משתמשת בהתקן ה-RNG החומרתי של ה-nRF52.

  • Arduino Nano RP2040 Connect אינה כוללת TRNG חומרתי; ה-PRNG של pico-sdk מאותחל בזרע וממוזג מחדש באופן רציף עם מקורות האנטרופיה שעל שבב ה-RP2040.

גישה למערכת קבצים#

os.chdir(path: str) → None#

שינוי הספרייה הנוכחית.

os.getcwd() → str#

קבלת הספרייה הנוכחית.

os.ilistdir(dir: str | None = None) → Iterator[Tuple]#

פונקציה זו מחזירה איטרטור שלאחר מכן מניב tuples המתאימים לרשומות בספרייה שהוא מפרט. ללא ארגומנט הוא מפרט את הספרייה הנוכחית, אחרת הוא מפרט את הספרייה הנתונה ב-dir.

ל-tuples יש את הצורה (name, type, inode[, size]):

  • name הוא מחרוזת (או bytes אם dir הוא אובייקט bytes) והוא שם הרשומה;

  • type הוא מספר שלם המציין את סוג הרשומה, כאשר 0x4000 מציין ספריות ו-0x8000 מציין קבצים רגילים;

  • inode הוא מספר שלם המתאים ל-inode של הקובץ, ויכול להיות 0 עבור מערכות קבצים שאין להן מושג כזה.

  • size הוא מספר שלם שעשוי להיכלל בהתאם לסוג מערכת הקבצים. עבור רשומות קבצים, size מייצג את גודל הקובץ או -1 אם אינו ידוע. משמעותו עבור רשומות ספריות אינה מוגדרת כרגע.

os.listdir(dir: str | None = None) → List[str]#

ללא ארגומנט, מפרטת את הספרייה הנוכחית. אחרת מפרטת את הספרייה הנתונה.

os.mkdir(path: str) → None#

יצירת ספרייה חדשה.

os.remove(path: str) → None#

הסרת קובץ.

הסרת קובץ. זהו כינוי ל-remove().

os.rmdir(path: str) → None#

הסרת ספרייה.

os.rename(old_path: str, new_path: str) → None#

שינוי שם קובץ.

os.stat(path: str) → Tuple#

קבלת מצב של קובץ או ספרייה.

os.statvfs(path: str) → Tuple#

קבלת מצב של מערכת קבצים.

מחזירה tuple עם מידע מערכת הקבצים בסדר הבא:

  • f_bsize – גודל בלוק של מערכת הקבצים

  • f_frsize – גודל פרגמנט

  • f_blocks – גודל מערכת הקבצים ביחידות f_frsize

  • f_bfree – מספר הבלוקים הפנויים

  • f_bavail – מספר הבלוקים הפנויים למשתמשים לא מורשים

  • f_files – מספר ה-inodes

  • f_ffree – מספר ה-inodes הפנויים

  • f_favail – מספר ה-inodes הפנויים למשתמשים לא מורשים

  • f_flag – דגלי עיגון

  • f_namemax – אורך שם הקובץ המרבי

פרמטרים הקשורים ל-inodes: f_files, f_ffree, f_favail והפרמטר f_flag עשויים להחזיר 0 משום שהם יכולים להיות לא זמינים במימוש ספציפי ל-port.

os.sync() → None#

סנכרון כל מערכות הקבצים.

os.sep: str#

מפריד רכיבי הנתיב שבו משתמשת מערכת הקבצים, המחרוזת '/'.

הפניית טרמינל ושכפולו#

os.dupterm(stream_object: Any, index: int = 0, /) → Any#

שכפול או החלפה של טרמינל MicroPython (ה-REPL) על האובייקט דמוי ה-stream הנתון. הארגומנט stream_object חייב להיות אובייקט stream מקורי, או לרשת מ-io.IOBase ולממש את המתודות readinto() ו-write(). ה-stream צריך להיות במצב לא-חוסם ו-readinto() צריכה להחזיר None אם אין נתונים זמינים לקריאה.

לאחר קריאה לפונקציה זו, כל פלט הטרמינל משוכפל על stream זה, וכל קלט הזמין ב-stream מועבר לקלט הטרמינל.

הפרמטר index צריך להיות מספר שלם אי-שלילי ומציין איזו משבצת שכפול מוגדרת. port נתון עשוי לממש יותר ממשבצת אחת (משבצת 0 תהיה תמיד זמינה) ובמקרה זה קלט ופלט הטרמינל משוכפלים על כל המשבצות המוגדרות.

אם None מועבר כ-stream_object, השכפול מבוטל במשבצת הנתונה על ידי index.

הפונקציה מחזירה את האובייקט דמוי ה-stream הקודם במשבצת הנתונה.

os.dupterm_notify(obj_in: Any, /) → None#

הודעה ל-REPL של MicroPython שקלט זמין על אובייקט דמוי stream שנרשם קודם לכן באמצעות os.dupterm().

פונקציה זו צריכה להיקרא על ידי מימושי stream מותאמים אישית (למשל, UART, Bluetooth, או stream-ים אחרים של REPL שאינם USB) כדי ליידע את ה-REPL שקלט מוכן לקריאה. שימוש נכון מבטיח שתווים מיוחדים כגון Ctrl+C (המשמש להפעלת KeyboardInterrupt) יעובדו במהירות על ידי ה-REPL, ומאפשר התנהגות קטיעה צפויה עבור קוד המשתמש.

הפרמטר obj_in נעלם בידי os.dupterm_notify(), אך הוא נדרש כדי לאפשר קריאה ל-dupterm_notify ממטפל פסיקה כגון UART.irq().

דוגמה:

from machine import UART
import os
uart = UART(0)
os.dupterm(uart, 0)
uart.irq(os.dupterm_notify, machine.UART.IRQ_RX)

הערה

אם הפונקציה dupterm_notify() אינה נקראת, ייתכן שקלט מה-stream המותאם אישית לא יזוהה או יעובד עד לסקר (poll) ה-REPL הבא, דבר שעלול לעכב KeyboardInterrupt או אותות בקרה אחרים. זה חשוב במיוחד עבור UART, Bluetooth וחיבורי REPL אחרים שאינם סטנדרטיים, שבהם הודעה אוטומטית אינה מובטחת.

עיגון מערכת קבצים#

הפונקציות והמחלקות הבאות הועברו למודול vfs. הן מסופקות במודול זה רק לצורך תאימות לאחור והן יוסרו בגרסה 2 של MicroPython.

os.mount(fsobj: Any, mount_point: str, *, readonly: bool = False) → None#

עיגון אובייקט מערכת הקבצים fsobj במיקום ב-VFS הנתון על ידי המחרוזת mount_point. fsobj יכול להיות אובייקט VFS שיש לו מתודת mount(), או התקן בלוקים. אם זהו התקן בלוקים, סוג מערכת הקבצים מזוהה אוטומטית (נזרקת חריגה אם לא זוהתה מערכת קבצים). mount_point יכול להיות '/' כדי לעגן את fsobj בשורש, או '/<name>' כדי לעגן אותו בתת-ספרייה תחת השורש.

אם readonly הוא True, מערכת הקבצים מעוגנת לקריאה בלבד.

במהלך תהליך העיגון, המתודה mount() נקראת על אובייקט מערכת הקבצים.

תזרוק OSError(EPERM) אם mount_point כבר מעוגן.

os.mount() → List[Tuple[Any, str]]

ללא ארגומנטים ל-mount(), מחזירה רשימה של tuples המייצגים את כל נקודות העיגון הפעילות.

לרשימה המוחזרת יש את הצורה [(fsobj, mount_point), …].

os.umount(mount_point: str | Any) → None#

ביטול עיגון של מערכת קבצים. mount_point יכול להיות מחרוזת המציינת את מיקום העיגון, או אובייקט מערכת קבצים שעוגן קודם לכן. במהלך תהליך ביטול העיגון, המתודה umount() נקראת על אובייקט מערכת הקבצים.

תזרוק OSError(EINVAL) אם mount_point לא נמצא.

class os.VfsFat(block_dev: AbstractBlockDev)#

יצירת אובייקט מערכת קבצים המשתמש בפורמט מערכת הקבצים FAT. אחסון מערכת הקבצים FAT מסופק על ידי block_dev. אובייקטים שנוצרו על ידי בנאי זה ניתנים לעיגון באמצעות mount().

static mkfs(block_dev: AbstractBlockDev) → None#

בניית מערכת קבצים FAT על block_dev.

class os.VfsPosix(root: str | None = None)#

יצירת אובייקט מערכת קבצים הניגש למערכת הקבצים POSIX של המארח. אם root מצוין, הוא צריך להיות נתיב במערכת הקבצים של המארח שישמש כשורש של אובייקט ה-VfsPosix. אחרת נעשה שימוש בספרייה הנוכחית של מערכת הקבצים של המארח.

הערה

VfsPosix זמין רק ב-Unix port; הוא אינו קיים ב-OpenMV Cam.