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.