BazelCon 2022 מגיע בין 16 ל-17 בנובמבר לניו יורק באינטרנט.
הירשמו עוד היום!

בכל העולם

קל לארגן דפים בעזרת אוספים אפשר לשמור ולסווג תוכן על סמך ההעדפות שלך.
אובייקטים, פונקציות ומודולים שרשומים בסביבה הגלובלית.

חברי מועדון

הכול

bool all(elements)

פונקציה זו מחזירה את הערך True אם כל הרכיבים מעריכים את הערך True או אם האוסף ריק. הרכיבים מומרים לבוליאני באמצעות הפונקציה בוליאני.
all(["hello", 3, True]) == True
all([-1, 0, 1]) == False

פרמטרים

פרמטר תיאור
elements חובה
מחרוזת או אוסף רכיבים.

בדיקת Analysis

None analysis_test(name, implementation, attrs=None, fragments=[], toolchains=[], attr_values={})

ניסיוני. ה-API הזה ניסיוני ועשוי להשתנות בכל שלב. אין צורך להסתמך עליה. ניתן להפעיל את התכונה על ידי הגדרה של --+experimental_analysis_test_call
יצירת יעד חדש של בדיקת ניתוח.

מספר התלויות העקיפות של הבדיקה מוגבל. המגבלה נקבעת באמצעות סימון --analysis_testing_deps_limit.

פרמטרים

פרמטר תיאור
name חובה
שם היעד. הוא צריך להיות מזהה Starlark, תואם לדפוס '[A-Za-z_][A-Za-z0-9_]*'.
implementation נדרשת
הפונקציה Starlark שמטמיעים את בדיקת הניתוח הזו. הוא חייב לכלול פרמטר אחד בדיוק: ctx. הפונקציה מופעלת בשלב הניתוח. הוא יכול לגשת למאפיינים שהוצהרו על ידי attrs ומאוכלסות באמצעות attr_values. ייתכן שפונקציית ההטמעה לא מתעדת פעולות. במקום זאת, האתר חייב לרשום תוצאת אישור/נכשל על ידי שליחת הערך AnalysisTestResultInfo .
attrs dict; or None; ברירת מחדל = ללא
מילון שמצהיר על המאפיינים. מעיינים בקריאה לכלל.מאפיינים יכולים להשתמש במעברים של הגדרות אישיות שהוגדרו באמצעות analysis_test_transition.
fragments sequence of strings; ברירת מחדל = []
רשימה של קטעי הגדרה שזמינים להטמעה של בדיקת הניתוח.
toolchains sequence; ברירת מחדל = []
קבוצת ערכות הכלים שנדרשת לבדיקה. קוראים את הקריאה לכלל.
attr_values dict of strings; ברירת מחדל = {}
מילון של ערכי מאפיינים שיש להעביר להטמעה.

Analysis_test_transition (מעבר_בדיקה_מעבר)

transition analysis_test_transition(settings)

יוצר מעבר להגדרות שיוחל על כלל בדיקה של ניתוח. ניתן להחיל את המעבר הזה רק על מאפיינים של כללים עם analysis_test = True. כללים כאלה מוגבלים ביכולות שלהם (לדוגמה, הגודל של עץ התלות שלהם מוגבל). לכן, מעברים שנוצרו באמצעות הפונקציה הזו מוגבלים בהיקף פוטנציאלי בהשוואה להעברות שנוצרו באמצעות מעבר.

המטרה העיקרית של הפונקציה היא לפשט את ספריית הליבה של Analysis Test Framework. מומלץ לעיין בתיעוד (או בהטמעה) של השיטות המומלצות.

פרמטרים

פרמטר תיאור
settings חובה
מילון שמכיל מידע על הגדרות התצורה, שיש להגדיר את העברת ההגדרות הזו. מפתחות הם תוויות והגדרות של גרסת build, שהם הערכים החדשים אחרי המעבר. כל ההגדרות האחרות לא השתנו. אפשר להשתמש בו כדי להצהיר על הגדרות תצורה ספציפיות שצריך להגדיר בבדיקת ניתוח כדי לעבור אותן.

הכול

bool any(elements)

מחזירה True אם לפחות רכיב אחד מבצע הערכה כ-True. הרכיבים מומרים לבוליאני באמצעות הפונקציה בוליאני.
any([-1, 0, 1]) == True
any([False, 0, ""]) == False

פרמטרים

פרמטר תיאור
elements חובה
מחרוזת או אוסף רכיבים.

ארכיון_override

None archive_override(module_name, urls, integrity='', strip_prefix='', patches=[], patch_strip=0)

מציינת שהתלות הזו צריכה להגיע מקובץ ארכיון (zip , gzip וכו') במיקום מסוים, ולא מרשם. במודול הזה אפשר להשתמש רק בהנחיה הזו. כלומר, אם מודול מציין שינויים, הוא לא יכול לשמש כתלות של אחרים.

פרמטרים

פרמטר תיאור
module_name נדרש
השם של תלות המודול ב-Bazel שעליו יחול השינוי הזה.
urls string; or Iterable of strings; נדרש
כתובות ה-URL של הארכיון; יכולות להיות http://s:// או כתובות URL של file:// .
integrity ברירת מחדל = ''
סכום ההמחאה הצפוי של קובץ הארכיון, בפורמט תקינות של משאבי משנה.
strip_prefix ברירת מחדל = ''
תחילית ספרייה להסרת הקבצים שחולצו.
patches Iterable of strings; ברירת מחדל = []
רשימת תוויות שמצביעה על קובצי תיקון שיחולו על המודול הזה. קובצי התיקון חייבים להיות קיימים בעץ המקור של הפרויקט ברמה העליונה. הן מסודרות לפי סדר הרשימה.
patch_strip ברירת מחדל = 0
זהה לארגומנט -striping של Unix issue.

אספקט

Aspect aspect(implementation, attr_aspects=[], attrs=None, required_providers=[], required_aspect_providers=[], provides=[], requires=[], fragments=[], host_fragments=[], toolchains=[], incompatible_use_toolchain_transition=False, doc='', *, apply_to_generating_rules=False, exec_compatible_with=[], exec_groups=None)

יוצר היבט חדש. התוצאה של הפונקציה הזו צריכה להיות מאוחסנת בערך גלובלי. לקבלת פרטים נוספים, קראו את המבוא להיבטים.

פרמטרים

פרמטר תיאור
implementation חובה
פונקציית Starlark שמטמיעה את ההיבט הזה, עם שני פרמטרים בדיוק: Target (היעד שעליו הוא חל) ו-ctx (ההקשר של הכלל שממנו נוצר היעד). מאפייני היעד זמינים דרך השדה ctx.rule. ההערכה של הפונקציה הזו מתבצעת בשלב הניתוח עבור כל החלה של היבט מסוים על יעד.
attr_aspects sequence of strings; ברירת מחדל = []
רשימה של שמות מאפיינים. ההיבט מופץ בהתאם לתלויות המצוינות במאפיינים של יעד עם השמות האלה. הערכים הנפוצים כאן כוללים deps ו-exports. הרשימה יכולה להכיל גם מחרוזת אחת ("*") שתפוצל עם כל התלות של יעד.
attrs dict; or None; ברירת מחדל = ללא
מילון שמצהיר על כל המאפיינים של ההיבט. הוא ממפה משם מאפיין לאובייקט מאפיין, כמו 'attr.label' או 'attr.string' (ראה מודול attr). מאפייני היבט זמינים לפונקציית ההטמעה כשדות של פרמטר ctx.

למאפיינים מרומזים שמתחילים ב-_ צריכים להיות ערכי ברירת מחדל, והם צריכים להיות מסוג label או label_list.

מאפיינים מפורשים חייבים להיות מסוג string, וחייבים להשתמש בהגבלה values. מאפיינים מפורשים מגבילים את ההיבט לשימוש רק בכללים עם מאפיינים בעלי אותו שם, סוג וערכים חוקיים בהתאם להגבלה.

required_providers ברירת מחדל = []
המאפיין הזה מאפשר להגביל את ההפצה רק ליעדים שהכללים שלהם מפרסמים את הספקים הנדרשים. הערך חייב להיות רשימה שמכילה ספקים בודדים או רשימות של ספקים, אך לא את שניהם. לדוגמה, הערך [[FooInfo], [BarInfo], [BazInfo, QuxInfo]] הוא ערך חוקי והערך [FooInfo, BarInfo, [BazInfo, QuxInfo]] אינו חוקי.

רשימה לא מלאה של ספקים יומרו באופן אוטומטי לרשימה שכוללת רשימה אחת של ספקים. כלומר, תתבצע המרה אוטומטית של [FooInfo, BarInfo] ל-[[FooInfo, BarInfo]].

כדי שיעדים מסוימים (למשל some_rule) יהיו גלויים להיבט כלשהו, some_rule חייב לפרסם את כל הספקים באחת מרשימות הספקים הנדרשות. לדוגמה, אם המאפיין required_providers של היבט הוא [[FooInfo], [BarInfo], [BazInfo, QuxInfo]], ההיבט הזה יכול לראות some_rule מטרות רק אם some_rule מספק FooInfo *או* BarInfo *או*, BazInfo *ו* QuxInfo.

required_aspect_providers ברירת מחדל = []
המאפיין הזה מאפשר לבדוק היבטים אחרים. הערך חייב להיות רשימה שמכילה ספקים בודדים או רשימות של ספקים, אך לא את שניהם. לדוגמה, הערך [[FooInfo], [BarInfo], [BazInfo, QuxInfo]] הוא ערך חוקי והערך [FooInfo, BarInfo, [BazInfo, QuxInfo]] אינו חוקי.

רשימה לא מלאה של ספקים יומרו באופן אוטומטי לרשימה שכוללת רשימה אחת של ספקים. כלומר, תתבצע המרה אוטומטית של [FooInfo, BarInfo] ל-[[FooInfo, BarInfo]].

כדי שה היבט אחר (למשל other_aspect) יהיה גלוי בהיבט הזה, other_aspect חייב לספק את כל הספקים מאחת מהרשימות לפחות. בדוגמה של [[FooInfo], [BarInfo], [BazInfo, QuxInfo]], היבט זה יוכל לראות other_aspect רק אם other_aspect מספק FooInfo *או* BarInfo *או* גם BazInfo *וגם* QuxInfo.

provides ברירת מחדל = []
רשימה של ספקים שפונקציית ההטמעה צריכה להחזיר.

זו שגיאה אם פונקציית ההטמעה משמיטה כל אחד מסוגי הספקים שמפורטים כאן מערך ההחזרה. עם זאת, פונקציית ההטמעה עשויה להחזיר ספקים נוספים שלא רשומים כאן.

כל רכיב ברשימה הוא אובייקט *Info שמוחזר על ידי provider(), אלא שספק קודם מיוצג על ידי שם המחרוזת שלו.

requires sequence of Aspects; ברירת מחדל = []
רשימת ההיבטים שצריך להפיץ לפני כן.
fragments sequence of strings; ברירת מחדל = []
רשימת שמות של קטעי תצורה שהיבט הזה דורש אותם בהגדרות התצורה של היעד.
host_fragments sequence of strings; ברירת מחדל = []
רשימת שמות של קטעי תצורה שההיבט דורש מהם הגדרה במארח.
toolchains sequence; ברירת מחדל = []
אם היא מוגדרת, קבוצת ערכות הכלים שהכלל הזה מחייב. הרשימה יכולה להכיל אובייקטים של מחרוזת, תווית או StarlarkToolchainTypeApi, בכל שילוב. ניתן למצוא ערכות כלים על ידי בדיקת הפלטפורמה הנוכחית, ומסופקות ליישום הכלל באמצעות ctx.toolchain.
incompatible_use_toolchain_transition ברירת מחדל = False
הוצאה משימוש, כבר לא בשימוש ויש להסיר אותה.
doc ברירת מחדל = ''
תיאור של היבט שניתן לחלץ באמצעות כלים ליצירת מסמכים.
apply_to_generating_rules ברירת מחדל = False
אם המדיניות מוגדרת כ-True, ההיבט יחול על קובץ הפלט שיוצר את קובץ הפלט.

לדוגמה, נניח שהיבטים מופצים באופן זמני באמצעות המאפיין 'Deps'.

False כברירת מחדל.

exec_compatible_with sequence of strings; ברירת מחדל = []
רשימה של אילוצים בפלטפורמת הביצוע שחלים על כל המופעים של ההיבט הזה.
exec_groups dict; or None; ברירת מחדל = ללא
היקף של שם קבוצת הביצוע (מחרוזת) עד exec_groups. אם המדיניות מוגדרת, היא מאפשרת להיבטים להריץ פעולות בפלטפורמות הפעלה מרובות במופע יחיד. מידע נוסף זמין בתיעוד של קבוצות ביצוע.

bazel_dep

None bazel_dep(name, version='', repo_name='', dev_dependency=False)

מצהיר על תלות ישירה במודול אחר של Bazel.

פרמטרים

פרמטר תיאור
name נדרש
שם המודול שיתווסף כתלות ישירה.
version ברירת מחדל = ''
גרסת המודול שתתווסף כתלות ישירה.
repo_name ברירת מחדל = ''
השם של ה-repo החיצוני שמייצג את התלות הזאת. זהו שם ברירת המחדל של המודול.
dev_dependency ברירת מחדל = False
אם הערך הוא TRUE, המערכת תתעלם מהתלויות אם המודול הנוכחי אינו המודול הבסיסי או אם האופרטור ' --ignore_dev_dependency' מופעל.

קישור

None bind(name, actual=None)

אזהרה: לא מומלץ להשתמש באפליקציה bind(). במאמר כדאי לשקול להסיר את הקישור לדיון ארוך על הבעיות והחלופות.

הוספת יעד בחבילה של //external.

פרמטרים

פרמטר תיאור
name נדרש
התווית שמתחת ל-'//external' כדי לשמש כשם הכינוי
actual string; or None; ברירת מחדל = ללא
התווית האמיתית שרוצים לקבל כינוי

בוליאני

bool bool(x=False)

הבונה של סוג הבוליאני. הפונקציה מחזירה False אם האובייקט הוא None, False, מחרוזת ריקה (""), המספר 0 או אוסף ריק (למשל (), []). אחרת, הפונקציה מחזירה True.

פרמטרים

פרמטר תיאור
x ברירת מחדל = False
המשתנה שיש להמיר.

שדה_תצורה

LateBoundDefault configuration_field(fragment, name)

מתייחס לערך ברירת מחדל מאוחר של מאפיין מסוג label. ערך הוא 'late-bound' אם יש צורך בבניית התצורה לפני קביעת הערך. כל מאפיין שמשתמש בו כערך צריך להיות פרטי.

שימוש לדוגמה:

הגדרת מאפיין כלל:

'_foo': attr.label(default=configuration_field(fragment='java', name='toolchain'))

גישה להטמעת כללים:

  def _rule_impl(ctx):
    foo_info = ctx.attr._foo
    ...

פרמטרים

פרמטר תיאור
fragment חובה
השם של קטע התצורה שמכיל את הערך של הערך מאוחר מדי.
name חובה
שם הערך שיש לקבל מקטע התצורה.

Depset

depset depset(direct=None, order="default", *, transitive=None)

יצירת Depex. הפרמטר direct הוא רשימה של רכיבים ישירים של המערך, והפרמטר transitive הוא רשימה של קווים תחתונים שהרכיבים שלהם הופכים לרכיבים עקיפים של הקיבוע שנוצר. הסדר שבו האלמנטים מוחזרים כאשר ההמרה מומרת לרשימה מוגדרת על ידי הפרמטר order. לקבלת מידע נוסף, קראו את הסקירה הכללית של Depset.

כל הרכיבים (ישירים ועקיפים) של ספירה חייבים להיות מאותו סוג, כפי שהתקבלו בביטוי type(x).

מאחר שקבוצה מבוססת גיבוב (hash) משמשת לביטול כפילויות במהלך איטרציה, כל הרכיבים של סכימה צריכים להיות מגובבים (hashed). עם זאת, מצב זה אינו נבדק באופן עקבי בכל המבנים. אפשר להשתמש בסימון --incompatible_always_check_depset_elements כדי להפעיל בדיקה עקבית. זו תהיה התנהגות ברירת המחדל בגרסאות עתידיות. כדאי לעיין בקטע בעיה 10313.

בנוסף, נכון לעכשיו הרכיבים לא חייבים להיות משתנים, אבל ההגבלה הזו תהיה רגועה יותר בעתיד.

הסדר של תיבת הדו-שיח שנוצרה צריך להיות תואם לסדר ההזמנות של transitive. ההזמנה הזו ("default") תואמת לכל הזמנה אחרת. כל שאר ההזמנות תואמות רק לעצמן.

הערה: תאימות לאחור/קדימה. הפונקציה הזו מקבלת כרגע פרמטר items למיקום. היא הוצאה משימוש ותוסר בעתיד, ולאחר הסרתה, direct תהפוך לפרמטר מיצוב יחיד של הפונקציה depset. לכן, שתי השיחות הבאות שוות ערך ומוכחות בעתיד:

depset(['a', 'b'], transitive = [...])
depset(direct = ['a', 'b'], transitive = [...])

פרמטרים

פרמטר תיאור
direct sequence; or None; ברירת מחדל = ללא
רשימה של רכיבים ישירים של קיזוז.
order default = "default"
אסטרטגיית המעבר למערך הנתונים החדש. כאן מופיעים הערכים האפשריים.
transitive sequence of depsets; or None; ברירת מחדל = ללא
רשימה של פרופסוטים שהרכיבים שלהם יהפכו לרכיבים עקיפים של המערך.

הכתבה

dict dict(pairs=[], **kwargs)

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

פרמטרים

פרמטר תיאור
pairs ברירת מחדל = []
הכתבה, או מסר חוזר שהרכיבים שלו הם באורך 2 (מפתח, ערך).
kwargs נדרש
מילון של ערכים נוספים.

dir

list dir(x)

מחזירה רשימה של מחרוזות: שמות המאפיינים והשיטות של אובייקט הפרמטר.

פרמטרים

פרמטר תיאור
x חובה
האובייקט לבדיקה.

מספור

list enumerate(list, start=0)

מחזירה רשימה של זוגות (זוגות דו-רכיביים), עם האינדקס (int) והפריט מרצף הקלט.
enumerate([24, 21, 84]) == [(0, 24), (1, 21), (2, 84)]

פרמטרים

פרמטר תיאור
list רצף קלט
נדרש.
start ברירת מחדל = 0
התחלת האינדקס.

קבוצת exec_group

exec_group exec_group(toolchains=[], exec_compatible_with=[], copy_from_rule=False)

יוצר קבוצת ביצוע שיכולה לשמש ליצירת פעולות עבור פלטפורמת ביצוע ספציפית במהלך הטמעת כלל.

פרמטרים

פרמטר תיאור
toolchains sequence; ברירת מחדל = []
קבוצת ערכות הכלים שקבוצת הביצוע הזו מחייבת. הרשימה יכולה להכיל אובייקטים של מחרוזת, תווית או StarlarkToolchainTypeApi, בכל שילוב.
exec_compatible_with sequence of strings; ברירת מחדל = []
רשימה של אילוצים בפלטפורמת הביצוע.
copy_from_rule ברירת מחדל = False
אם היא מוגדרת כ-true, קבוצת ה-exec הזו יורשת את גורמי הכלים והמגבלות של הכלל שאליו הקבוצה הזו מצורפת. אם המדיניות מוגדרת כמחרוזת אחרת, תוצג הודעת שגיאה.

נכשל

None fail(msg=None, attr=None, *args)

גורם לכשל בהפעלה.

פרמטרים

פרמטר תיאור
msg ברירת מחדל = ללא
הוצאה משימוש: במקומה יש להשתמש בארגומנטים מיקום. הטיעון הזה פועל כמו ארגומנט אובייקטיבי מרומז מוביל.
attr string; or None; ברירת מחדל = ללא
הוצאה משימוש. גורם לקידומת אופציונלית שמכילה את המחרוזת הזו ותתווסף להודעת השגיאה.
args חובה
רשימה של ערכים, בפורמט str והצטרפות באמצעות רווחים, שמופיעים בהודעת השגיאה.

מספר ממשי (float)

float float(x=unbound)

פונקציה זו מחזירה את x כערך צף.
  • אם הערך x כבר צף, float יחזיר אותו ללא שינוי.
  • אם x הוא בוליאני, float מחזירה את הערך 1.0 עבור True ואת 0.0 עבור False.
  • אם x הוא Int, float יחזיר את ערך הנקודה הצפה הקרובה ביותר ל-x, או שגיאה אם הגודל גדול מדי.
  • אם x הוא מחרוזת, הוא חייב להיות ליטרל חוקי של נקודה צפה, או להיות שווה (לא תלוי רישיות) ל-NaN, Inf או Infinity, ולפניו יכול להופיע סימן + או -.
כל ערך אחר גורם לשגיאה. ללא ארגומנט, float() יחזיר 0.0.

פרמטרים

פרמטר תיאור
x default = unbound
הערך להמרה.

Getattr

unknown getattr(x, name, default=unbound)

פונקציה זו מחזירה את השדה struct'של השם הנתון אם הוא קיים. אם לא, הוא מחזיר default (אם צוין) או מעלה שגיאה. getattr(x, "foobar") שווה ל-x.foobar.
getattr(ctx.attr, "myattr")
getattr(ctx.attr, "myattr", "mydefault")

פרמטרים

פרמטר תיאור
x חובה
המבנה שאליו ניתן לגשת למאפיין.
name חובה
השם של מאפיין המבנה.
default ברירת מחדל = לא מוגדר
ערך ברירת המחדל להחזרה אם למבנה אין מאפיין של השם הנתון.

git_override

None git_override(module_name, remote, commit='', patches=[], patch_strip=0)

מציינת שהתלות צריכה להתבצע ממחויבות מסוימת של מאגר Git. במודול הזה אפשר להשתמש רק בהנחיה הזו. כלומר, אם מודול מציין שינויים, הוא לא יכול לשמש כתלות של אחרים.

פרמטרים

פרמטר תיאור
module_name נדרש
השם של תלות המודול ב-Bazel שעליו יחול השינוי הזה.
remote נדרשת
כתובת ה-URL של מאגר Git המרוחק.
commit ברירת מחדל = ''
ההתחייבות שצריך לבדוק.
patches Iterable of strings; ברירת מחדל = []
רשימת תוויות שמצביעה על קובצי תיקון שיחולו על המודול הזה. קובצי התיקון חייבים להיות קיימים בעץ המקור של הפרויקט ברמה העליונה. הן מסודרות לפי סדר הרשימה.
patch_strip ברירת מחדל = 0
זהה לארגומנט -striping של Unix issue.

Heattr

bool hasattr(x, name)

פונקציה זו מחזירה את הערך True אם לאובייקט x יש מאפיין או שיטה של name הנתון, אחרת הוא False. דוגמה:
hasattr(ctx.attr, "myattr")

פרמטרים

פרמטר תיאור
x חובה
האובייקט לבדיקה.
name חובה
שם המאפיין.

לבצע גיבוב (hash)

int hash(value)

יש להחזיר ערך גיבוב (hash) עבור מחרוזת. כדי לחשב את הערך הזה, יש להשתמש באותו אלגוריתם כמו האלגוריתם Java's String.hashCode(). כלומר:
s[0] * (31^(n-1)) + s[1] * (31^(n-2)) + ... + s[n-1]
אין כרגע תמיכה בגיבוב ערכים מלבד מחרוזות.

פרמטרים

פרמטר תיאור
value נדרש
ערך מחרוזת לגיבוב.

int

int int(x, base=unbound)

פונקציה זו מחזירה את x כערך int.
  • אם x הוא כבר אינטג, int יחזיר אותו ללא שינוי.
  • אם x הוא בוליאני, int מחזירה את הערך 1 עבור True ואת 0 עבור False.
  • אם המחרוזת x היא מחרוזת, היא צריכה להיות בפורמט <sign><prefix><digits>. הערך של <sign> הוא "+", "-" או ריק (פורש כחיובי). <digits> הוא רצף של ספרות בין 0 ל-base עד 1, כאשר האותיות A-z (או שווה-ערך A-Z) משמשות כספרות ל-10-35. במקרה שבו base הוא 2/8/16, <prefix> הוא אופציונלי ועליו להיות 0b/0o/0x (או שווה ערך, 0B/0O/0X) בהתאמה; אם base הוא ערך אחר כלשהו מלבד בסיסים אלה או הערך המיוחד 0, הקידומת חייבת להיות ריקה. במקרה ש-base הוא 0, המחרוזת תפורש כליטרל מספר שלם, כלומר אחד מהבסיסים 2/8/10/16 ייבחר, בהתאם לקידומת אם ייעשה שימוש במשהו. אם הערך של base הוא 0, לא נעשה שימוש בקידומת כלשהי ויש יותר מספרה אחת, הספרה הראשית לא יכולה להיות 0; זאת כדי למנוע בלבול בין אוקטל ו עשרוני. הגודל של המספר המיוצג על ידי המחרוזת חייב להיות בטווח המותר של סוג ה-int.
  • אם הערך x הוא מספר צף, int מחזירה את הערך השלם של הצף, מעוגל כלפי אפס. שגיאה היא אם x אינו סופי (NaN או אינסוף).
הפונקציה הזו תיכשל אם הערך x יהיה מכל סוג אחר, או אם הערך הוא מחרוזת שלא תואמת לפורמט שלמעלה. בניגוד לפונקציה int ב-Python&#39, הפונקציה לא מאפשרת אפס ארגומנטים ולא מאפשרת להוסיף רווחים מיותרים לארגומנטים במחרוזת.

דוגמאות:

int("123") == 123
int("-123") == -123
int("+123") == 123
int("FF", 16) == 255
int("0xFF", 16) == 255
int("10", 0) == 10
int("-0x10", 0) == -16
int("-0x10", 0) == -16
int("123.456") == 123

פרמטרים

פרמטר תיאור
x נדרש
המחרוזת להמרה.
base ברירת מחדל = Unbound
הבסיס המשמש לפירוש ערך מחרוזת. ברירת המחדל היא 10. חייב להיות בין 2 ל-36 (כולל), או 0 כדי לזהות את הבסיס כאילו x היה ליטרל שלם. אין לציין את הפרמטר הזה אם הערך אינו מחרוזת.

Lens

int len(x)

מחזירה את האורך של מחרוזת, רצף (למשל רשימה או טול), הכתבה או איטרציה אחרת.

פרמטרים

פרמטר תיאור
x נדרש
הערך שלאורך הדיווח שלו.

list

list list(x=[])

פונקציה זו מחזירה רשימה חדשה עם אותם אלמנטים של הערך הנתון החוזר.
list([1, 2]) == [1, 2]
list((2, 3, 2)) == [2, 3, 2]
list({5: "a", 2: "b", 4: "c"}) == [5, 2, 4]

פרמטרים

פרמטר תיאור
x ברירת מחדל = []
האובייקט להמרה.

local_path_override

None local_path_override(module_name, path)

מציינת שתלויה בכך שספרייה מסוימת נמצאת בדיסק מקומי. במודול הזה אפשר להשתמש רק בהנחיה הזו. כלומר, אם מודול מציין שינויים, הוא לא יכול לשמש כתלות של אחרים.

פרמטרים

פרמטר תיאור
module_name נדרש
השם של תלות המודול ב-Bazel שעליו יחול השינוי הזה.
path נדרש
הנתיב לספרייה שבה נמצא המודול הזה.

מקס'

unknown max(*args)

מחזירה את הארגומנט הגדול ביותר מבין כל הארגומנטים הנתונים. אם מספקים רק ארגומנט אחד, הקובץ חייב להיות איטרציה לא ריקה.זו שגיאה אם הרכיבים לא ניתנים להשוואה (לדוגמה, אינטג עם מחרוזת) או אם לא מתקבלים ארגומנטים.
max(2, 5, 4) == 5
max([5, 6, 3]) == 6

פרמטרים

פרמטר תיאור
args נדרש
הרכיבים לבדיקה.

דקה

unknown min(*args)

מחזירה את הקטן ביותר מבין כל הארגומנטים הנתונים. אם מספקים רק ארגומנט אחד, הערך חייב להיות ריק. זוהי שגיאה אם רכיבים לא ניתנים להשוואה (לדוגמה, Int עם מחרוזת) או אם לא מתקבלים ארגומנטים.
min(2, 5, 4) == 2
min([5, 6, 3]) == 3

פרמטרים

פרמטר תיאור
args נדרש
הרכיבים לבדיקה.

מודול

None module(name='', version='', compatibility_level=0, execution_platforms_to_register=[], toolchains_to_register=[])

מצהיר על מאפיינים מסוימים של המודול Bazel המיוצג על ידי ה-Bazel repo. המאפיינים האלה הם מטא-נתונים חיוניים של המודול (כמו השם והגרסה), או שהם משפיעים על ההתנהגות של המודול הנוכחי ועל הגורמים התלויים בו.

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

פרמטרים

פרמטר תיאור
name ברירת מחדל = ''
שם המודול. ניתן להשמיט רק אם המודול הזה הוא המודול הבסיסי (כלומר, אם הוא לא תלוי במודול אחר). שם תקף של מודול חייב: 1) להכיל רק אותיות קטנות (a-z), ספרות (0-9), נקודות (.), מקפים (-) וקווים תחתונים (_); 2) להתחיל באות קטנה; 3) להסתיים באות קטנה או בספרה.
version default = ''
גרסת המודול. ניתן להשמיט רק אם המודול הזה הוא המודול הבסיסי (כלומר, אם הוא לא תלוי במודול אחר).
compatibility_level ברירת מחדל = 0
רמת התאימות של המודול. יש לשנות אותו בכל פעם שמתקבל שינוי משמעותי שאינו תואם. למעשה, היא ה&מירכאות; מודולים עם רמות תאימות שונות משתתפים בהגדרה של רזולוציית גרסה כאילו הם מודולים עם שמות שונים, אבל תרשים התלות הסופי לא יכול להכיל כמה מודולים עם שם זהה אבל רמות תאימות שונות (אלא אם multiple_version_override נמצא בפועל; כדאי לראות שם פרטים נוספים).
execution_platforms_to_register Iterable of strings; ברירת מחדל = []
רשימה של פלטפורמות הפעלה מוגדרות מראש שנרשמו כשהמודול הזה נבחר. צריכה להיות רשימה של תבניות יעד מוחלטות (למשל, החל מ-@ או //). מידע נוסף זמין בקטע רזולוציה של כלי עבודה.
toolchains_to_register Iterable of strings; ברירת מחדל = []
רשימה של ערכות כלים מוגדרות מראש להרשמה כאשר המודול הזה נבחר. צריכה להיות רשימה של תבניות יעד מוחלטות (למשל, החל מ-@ או //). מידע נוסף זמין בקטע רזולוציה של כלי עבודה.

מודול_תוסף

unknown module_extension(implementation, *, tag_classes={}, doc='')

יצירת תוסף מודול חדש. מאחסנים אותו בערך גלובלי כדי שניתן יהיה לייצא אותו ולהשתמש בו בקובץ MODULE.bazel.

פרמטרים

פרמטר תיאור
implementation חובה
הפונקציה שמטמיעה את תוסף המודול הזה. חובה להזין פרמטר אחד, module_ctx. הפונקציה מופעלת פעם אחת בתחילת ה-build כדי לקבוע את הקבוצה של מאגרי הנתונים הזמינים.
tag_classes ברירת מחדל = {}
מילון שמצהיר על כל סוגי התגים שבהם משתמש התוסף. היא ממפה את השם של רמת התג לאובייקט tag_class.
doc ברירת מחדל = ''
תיאור של תוסף המודול, שניתן לחלץ באמצעות כלים ליצירת מסמכים.

Multi_version_override

None multiple_version_override(module_name, versions, registry='')

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

פרמטרים

פרמטר תיאור
module_name נדרש
השם של תלות המודול ב-Bazel שעליו יחול השינוי הזה.
versions Iterable of strings; חובה
לציין במפורש את הגרסאות שמותר לקיים. הגרסאות האלה חייבות כבר להופיע בתרשים לפני בחירת התלות. תלות במודול הזה תהיה "משודרג" לגרסת התאימות ברמה הגבוהה ביותר באותה רמת תאימות, ואילו יחסי תלות עם גרסה גבוהה יותר מאשר כל גרסה מותרת באותה רמת תאימות יגרמו לשגיאה.
registry ברירת מחדל = ''
מבטל את הרישום של מודול זה; במקום למצוא את המודול הזה מרשימת ברירת המחדל של מרשמים, יש להשתמש במרשם הנתון.

הדפסה

None print(sep=" ", *args)

הדפסה של args כפלט ניפוי באגים. התחילית של השיחה תהיה המחרוזת "DEBUG" והמיקום (הקובץ ומספר השורה) של השיחה. הדרך המדויקת שבה הארגומנטים מומרים למחרוזות עשויה להיות שונה, ועשויה להשתנות בכל עת. ייתכן שיהיה הבדל בין הפורמט (ומפורט יותר) מהעיצוב של המאפיינים str() ו-repr().

לא מומלץ להשתמש ב-print בקוד הייצור בשל הספאם שנוצר על ידי המשתמשים. כשהוצאה משימוש, עדיף להשאיר שגיאה קשה בעת השימוש ב-fail() כשהדבר אפשרי.

פרמטרים

פרמטר תיאור
sep default = " "
מחרוזת המפריד בין האובייקטים, ברירת המחדל היא רווח (" ").
args נדרש
האובייקטים להדפסה.

provider

unknown provider(doc='', *, fields=None, init=None)

מגדיר סמל של ספק. כדי ליצור מכונה כזו, אפשר להתקשר אליה ישירות או להשתמש בה ישירות כמפתח לאחזור מופע של הספק מיעד. דוגמה:
MyInfo = provider()
...
def _my_library_impl(ctx):
    ...
    my_info = MyInfo(x = 2, y = 3)
    # my_info.x == 2
    # my_info.y == 3
    ...

במדריך מקיף בנושא כללים (ספקים) מוסבר איך להשתמש בספקים.

פונקציה זו מחזירה את הערך Provider שניתן לקריאה אם לא צוין init.

אם מצוין init, מחזירה 2 אלמנטים: ערך Provider שניתן לקריאה וערך בונה גולמי. לקבלת פרטים, ניתן לעיין בכללים (אתחול מותאם אישית של ספקים מותאמים אישית) ובדיון על הפרמטר init שבהמשך.

פרמטרים

פרמטר תיאור
doc ברירת מחדל = ''
תיאור של הספק שניתן לחלץ באמצעות כלים ליצירת מסמכים.
fields sequence of strings; or dict; or None; ברירת מחדל = ללא
אם צוין, הגבלה של קבוצת השדות המותרים.
הערכים האפשריים הם:
  • רשימת שדות:
    provider(fields = ['a', 'b'])

  • שם שדה במילון -> תיעוד:
    provider(
           fields = { 'a' : 'Documentation for a', 'b' : 'Documentation for b' })
כל השדות הם אופציונליים.
init callable; or None; ברירת מחדל = ללא
התקשרות חזרה אופציונלית לעיבוד מראש ולאימות ערכי השדות של הספק במהלך רגע. אם צוין init, הפונקציה provider() מחזירה 2 רכיבים: סמל הספק הרגיל ובונה גולמי.

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

הגדרת P בתור סמל הספק שנוצר על ידי התקשרות ל-provider(). באופן עקרוני, מופע של P נוצר על ידי פונקציית ברירת המחדל של constructor c(*args, **kwargs), שמבצעת את הפעולות הבאות:

  • אם השדה args לא ריק, אירעה שגיאה.
  • אם הפרמטר fields צוין כשביצוע קריאה אל provider(), ואם הפרמטר kwargs מכיל מפתח שלא צוין ב-fields, מתרחשת שגיאה.
  • אחרת, הפונקציה c מחזירה מופע חדש שכולל עבור כל רשומה של k: v ב-kwargs, שדה בשם k עם הערך v.
במקרה שבו המענה החוזר מסוג init לא, קריאה לפונקציה P עצמה פועלת כקריאה לפונקציית הבנייה המוגדרת כברירת מחדל c. כלומר, P(*args, **kwargs) מחזירה c(*args, **kwargs). לדוגמה,
MyInfo = provider()
m = MyInfo(foo = 1)
יהפוך את זה כך ש-m הוא MyInfo עם m.foo == 1.

אבל במקרים שבהם האפשרות init צוינה, במסגרת השיחה תתבצע באופן הבא: P(*args, **kwargs)

  1. הקריאה החוזרת (callback) מופעלת בתור init(*args, **kwargs), כלומר עם אותם ארגומנטים בדיוק כמו מיקומים ומילות מפתח שהועברו אל P.
  2. ערך ההחזרה של init צפוי להיות מילון d, שהמפתחות שלו הם מחרוזות שמות שדות. אם לא, תתרחש שגיאה.
  3. מופע חדש של P נוצר כאילו נוצר על ידי בנאי ברירת המחדל באמצעות ערכים של d' כארגומנטים של מילות מפתח, כמו בc(**d).

הערה: השלבים שלמעלה מרמזים על כך ששגיאה מתרחשת אם *args או **kwargs לא תואמים לחתימה של init' או שההערכה של init' הגוף נכשלה (אולי באמצעות קריאה ל-fail()), או אם ערך ההחזרה של init אינו מילון עם הסכימה הצפויה.

באופן הזה, הקריאה החוזרת (callback) של init מסכמת את בניית הספק הרגילה בכך שהיא מאפשרת שימוש בארגומנטים למיקום ובלוגיקה שרירותית לעיבוד מראש ולאימות. לא ניתן לעקוף את רשימת ההיתרים של fields.

כאשר מציינים את init, ערך ההחזרה של provider() הופך לצבע (P, r), שבו r הוא הבנייה הגולמית. למעשה, ההתנהגות של r היא בדיוק ההתנהגות של פונקציונלית ברירת המחדל c שפורטה למעלה. בדרך כלל, מערכת r משויכת למשתנה ששמו מופיע עם קו תחתון, כך שרק לקובץ .bzl הנוכחי יש גישה ישירה אליו:

MyInfo, _new_myinfo = provider(init = ...)

טווח

sequence range(start_or_stop, stop_or_none=None, step=1)

המדיניות יוצרת רשימה שבה הפריטים עוברים מ-start ל-stop, עם תוספת של step. אם מספקים ארגומנט בודד, הפריטים יהיו בין 0 לרכיב הזה.
range(4) == [0, 1, 2, 3]
range(3, 9, 2) == [3, 5, 7]
range(3, 0, -1) == [3, 2, 1]

פרמטרים

פרמטר תיאור
start_or_stop נדרש
ערך רכיב ההתחלה אם צוינה עצירה, אחרת ערך העצירה וההתחלה בפועל היא 0
stop_or_none int; or None; ברירת המחדל = ללא
האינדקס האופציונלי של הפריט הראשון לא להיכלל ברשימה המתקבלת. יצירת הרשימה תיפסק לפני שתגיעו אל stop.
step ברירת מחדל = 1
התוספת (ברירת המחדל היא 1). הוא יכול להיות שלילי.

enroll_execution_platforms()

None register_execution_platforms(*platform_labels)

רישום פלטפורמה שכבר מוגדרת כך ש-Bazel יכולה להשתמש בה בתור פלטפורמת ביצוע במהלך רזולוציה של Toolchain.

פרמטרים

פרמטר תיאור
platform_labels sequence of strings; חובה
התוויות של הפלטפורמות לרישום.

enroll_execution_platforms()

None register_execution_platforms(*platform_labels)

המדיניות מציינת פלטפורמות הפעלה שהוגדרו מראש להרשמה כאשר המודול הזה נבחר. צריכים להיות דפוסי יעד מוחלטים (כלומר, מתחילים ב-@ או ב-//). מידע נוסף זמין ברזולוציה של כלי הפיתוח.

פרמטרים

פרמטר תיאור
platform_labels sequence of strings; חובה
התוויות של הפלטפורמות לרישום.

record_toolchains()

None register_toolchains(*toolchain_labels)

רישום של רצועת כלים מוגדרת מראש כדי ש-Bazel יכולה להשתמש בה במהלך פתרון הבעיה ב-toolschain. דוגמאות להגדרה ולרישום ערכות הכלים.

פרמטרים

פרמטר תיאור
toolchain_labels sequence of strings; נדרש
התוויות של כלי הרכב כדי להירשם.

record_toolchains()

None register_toolchains(*toolchain_labels)

המדיניות הזו מציינת ערכות כלים מוגדרות מראש שנרשמות כשהמודול הזה נבחר. צריכים להיות דפוסי יעד מוחלטים (כלומר, מתחילים ב-@ או ב-//). מידע נוסף זמין ברזולוציה של כלי הפיתוח.

פרמטרים

פרמטר תיאור
toolchain_labels sequence of strings; נדרש
התוויות של כלי הרכב כדי להירשם.

מאגר_rule(הטמעה, אטרקציות, מקומיות, סביבה, הגדרה, רמוט, doc)

callable repository_rule(implementation, *, attrs=None, local=False, environ=[], configure=False, remotable=False, doc='')

יצירת כלל מאגר חדש. יש לאחסן אותו בערך גלובלי, כדי שניתן יהיה לטעון אותו ולקרוא אותו מקובץ ה-WORKSPACE.

פרמטרים

פרמטר תיאור
implementation נדרשת
הפונקציה שמיישמת את הכלל הזה. חייב להיות פרמטר אחד, repository_ctx. הפונקציה מופעלת במהלך שלב הטעינה של כל מופע של הכלל.
attrs dict; or None; ברירת מחדל = ללא
הצהרה לגבי כל המאפיינים של הכלל. הוא ממפה משם מאפיין לאובייקט מאפיין (עיינו במודול attr). מאפיינים שמתחילים ב-_ הם פרטיים ואפשר להשתמש בהם כדי להוסיף תלות מרומזת לתווית בקובץ (כלל מאגר לא יכול להיות תלוי בפריטי מידע שנוצרים בתהליך פיתוח (Artifact). המאפיין name נוסף באופן לא מפורש ואין לציין אותו.
local ברירת מחדל = False
מציין שהכלל הזה מאחזר את כל הנתונים מהמערכת המקומית, וצריך לבדוק אותו מחדש בכל אחזור.
environ sequence of strings; ברירת מחדל = []
מספקת רשימה של משתנה סביבה שהכלל במאגר הזה תלוי בו. אם משתנה סביבה ברשימה הזו משתנה, המאגר יאוחזר מחדש.
configure ברירת מחדל = False
מציין שהמאגר בודק את המערכת למטרת הגדרה
remotable ברירת מחדל = False
ניסיוני. הפרמטר הזה ניסיוני ועשוי להשתנות בכל שלב. אין צורך להסתמך עליה. ניתן להפעיל את התכונה על ידי הגדרה של ---experimental_repo_remote_exec
תאימות להפעלה מרחוק
doc ברירת מחדל = ''
תיאור של כלל המאגר שניתן לחלץ באמצעות כלים ליצירת מסמכים.

מאגר_rule(הטמעה, אטרקציות, מקומיות, סביבה, הגדרה, רמוט, doc)

callable repository_rule(implementation, *, attrs=None, local=False, environ=[], configure=False, remotable=False, doc='')

יצירת כלל מאגר חדש. יש לאחסן אותו בערך גלובלי, כדי שניתן יהיה לטעון אותו ולקרוא אותו מקובץ ה-WORKSPACE.

פרמטרים

פרמטר תיאור
implementation נדרשת
הפונקציה שמיישמת את הכלל הזה. חייב להיות פרמטר אחד, repository_ctx. הפונקציה מופעלת במהלך שלב הטעינה של כל מופע של הכלל.
attrs dict; or None; ברירת מחדל = ללא
הצהרה לגבי כל המאפיינים של הכלל. הוא ממפה משם מאפיין לאובייקט מאפיין (עיינו במודול attr). מאפיינים שמתחילים ב-_ הם פרטיים ואפשר להשתמש בהם כדי להוסיף תלות מרומזת לתווית בקובץ (כלל מאגר לא יכול להיות תלוי בפריטי מידע שנוצרים בתהליך פיתוח (Artifact). המאפיין name נוסף באופן לא מפורש ואין לציין אותו.
local ברירת מחדל = False
מציין שהכלל הזה מאחזר את כל הנתונים מהמערכת המקומית, וצריך לבדוק אותו מחדש בכל אחזור.
environ sequence of strings; ברירת מחדל = []
מספקת רשימה של משתנה סביבה שהכלל במאגר הזה תלוי בו. אם משתנה סביבה ברשימה הזו משתנה, המאגר יאוחזר מחדש.
configure ברירת מחדל = False
מציין שהמאגר בודק את המערכת למטרת הגדרה
remotable ברירת מחדל = False
ניסיוני. הפרמטר הזה ניסיוני ועשוי להשתנות בכל שלב. אין צורך להסתמך עליה. ניתן להפעיל את התכונה על ידי הגדרה של ---experimental_repo_remote_exec
תאימות להפעלה מרחוק
doc ברירת מחדל = ''
תיאור של כלל המאגר שניתן לחלץ באמצעות כלים ליצירת מסמכים.

ביטול

string repr(x)

המרת כל אובייקט לייצוג מחרוזת. זוהי פעולה יעילה לניפוי באגים.
repr("ab") == '"ab"'

פרמטרים

פרמטר תיאור
x נדרש
האובייקט להמרה.

הפוך

list reversed(sequence)

מחזירה רשימה חדשה שאינה מוקפאת ומכילה את הרכיבים של הרצף המקורי המקורי, בסדר הפוך.
reversed([3, 5, 4]) == [4, 5, 3]

פרמטרים

פרמטר תיאור
sequence נדרש
היפוך קבוע (למשל, רשימה) כדי לבטל.

כלל

callable rule(implementation, test=False, attrs=None, outputs=None, executable=False, output_to_genfiles=False, fragments=[], host_fragments=[], _skylark_testable=False, toolchains=[], incompatible_use_toolchain_transition=False, doc='', *, provides=[], exec_compatible_with=[], analysis_test=False, build_setting=None, cfg=None, exec_groups=None, compile_one_filetype=None, name=None)

יצירת כלל חדש, שניתן לקרוא לו קובץ BUILD או מאקרו כדי ליצור יעדים.

צריך להקצות כללים למשתנים גלובליים בקובץ bzl .השם של המשתנה הגלובלי הוא השם של הכלל.

כללי בדיקה חייבים להכיל שם שמסתיים ב-_test, ואילו הסיומת של כל הכללים האחרים לא יכולה לכלול את הסיומת הזו. (ההגבלה הזו חלה רק על כללים, לא על היעדים שלהם.)

פרמטרים

פרמטר תיאור
implementation חובה
הפונקציה Starlark שמטמיעים את הכלל הזה חייבת לכלול פרמטר אחד בדיוק: ctx. הפונקציה מופעלת במהלך שלב הניתוח עבור כל מופע של הכלל. היא יכולה לגשת למאפיינים שסופקו על ידי המשתמש. חובה ליצור פעולות כדי ליצור את כל הפלטים המוצהרים.
test ברירת מחדל = False
אם הכלל הזה הוא כלל בדיקה, כלומר, יכול להיות שהנושא הוא פקודה של blaze test. כל כללי הבדיקה נחשבים אוטומטית לניתנים להפעלה. אין צורך (ומומלץ) להגדיר כלל executable = True באופן מפורש עבור כלל בדיקה. מידע נוסף זמין בדף הכללים.
attrs dict; or None; ברירת מחדל = ללא
הצהרה לגבי כל המאפיינים של הכלל. הוא ממפה משם מאפיין לאובייקט מאפיין (עיינו במודול attr). מאפיינים שמתחילים ב-_ הם פרטיים ואפשר להשתמש בהם כדי להוסיף תלות מרומזת על תווית. המאפיין name נוסף באופן לא מפורש ואין לציין אותו. המאפיינים visibility, deprecation, tags, testonly וגם features נוספו באופן לא מפורש ולא ניתן לשנות אותם. לרוב הכללים נדרשים רק מספר מאפיינים. כדי להגביל את השימוש בזיכרון, פונקציית הכלל מגבילה את גודל המאפיינים.
outputs dict; or None; or function; ברירת מחדל = ללא
הוצאה משימוש. הפרמטר הזה הוצא משימוש ויוסר בקרוב. אין צורך להסתמך עליה. היא מושבתת אצל ---incompatible_no_rule_outputs_param. השתמשו בסימון הזה כדי לוודא שהקוד שלכם תואם להסרה המיידית שלו.
הפרמטר הזה הוצא משימוש. צריך להעביר את הכללים לשימוש ב-OutputGroupInfo או ב-attr.output במקום זאת.

סכימה להגדרת פלטים שהוצהרו מראש. בניגוד למאפיינים output ו-output_list, המשתמש לא מציין את התוויות של הקבצים האלה. בדף הכללים מפורט מידע נוסף על פלטים שהוצהרו מראש.

הערך של הארגומנט הזה הוא מילון או פונקציית קריאה חוזרת שיוצרת מילון. הקריאה החוזרת פועלת באופן דומה למאפייני תלות מחושבים: שמות הפרמטרים של הפונקציה תואמים למאפייני הכלל' כך, למשל, אם תעבירו את outputs = _my_func עם ההגדרה def _my_func(srcs, deps): ..., לפונקציה תהיה גישה למאפיינים srcs ו-deps. בין אם המילון מצוין באופן ישיר או באמצעות פונקציה, הוא מתורגם כך:

כל רשומה במילון יוצרת פלט מוצהר שבו המפתח הוא מזהה והערך הוא תבנית מחרוזת שקובעת את התווית של הפלט. בפונקציית ההטמעה של הכלל, המזהה הופך לשם השדה המשמש לגישה לפלט File ב-ctx.outputs. התווית של הפלט' כוללת את אותה החבילה כמו הכלל, והחלק לאחר החבילה מופק על ידי החלפת כל placeholder בטופס "%{ATTR}" במחרוזת שנוצרה מהערך של המאפיין ATTR:

  • מאפיינים מסוג מחרוזת מופיעים מילולית.
  • מאפיינים מסוג תווית הופכים לחלק מהתווית לאחר החבילה, פחות סיומת הקובץ. לדוגמה, התווית "//pkg:a/b.c" תהפוך ל-"a/b".
  • מאפיינים מסוג פלט הופכים לחלק מהתווית לאחר החבילה, כולל סיומת הקובץ (בדוגמה שלמעלה, "a/b.c").
  • כל המאפיינים מסוג רשימה (לדוגמה, attr.label_list) שבהם נעשה שימוש ב-placeholders צריכים לכלול רכיב אחד בלבד. ההמרה שלהם זהה לגרסה שלהם שלא מופיעה ברשימה (attr.label).
  • ייתכן שסוגי מאפיינים אחרים לא יופיעו ב-placeholders.
  • ה-placeholders המיוחדים שאינם מאפיינים %{dirname} ו-%{basename} מתרחבים לחלקים האלה של תווית הכלל, מלבד החבילה שלהם. לדוגמה, ב-"//pkg:a/b.c", השם החלופי הוא a והשם הבסיסי הוא b.c.

בפועל, ה-placeholder החלופי הנפוץ ביותר הוא "%{name}". לדוגמה, עבור יעד בשם "foo" הפלט של המילה {"bin": "%{name}.exe"} מצהיר מראש על פלט בשם foo.exe שאפשר לגשת אליו בפונקציית ההטמעה כ-ctx.outputs.bin.

executable ברירת מחדל = False
אם הכלל הזה נחשב לקובץ הפעלה, כלומר אם הוא עשוי להיות כפוף לפקודה blaze run. מידע נוסף זמין בדף הכללים.
output_to_genfiles ברירת מחדל = False
אם מוגדר כ-TRUE, הקבצים ייווצרו בספריית genfiles במקום בספריית bin. אין צורך להגדיר את הסימון הזה, אלא אם הוא דרוש לכם לתאימות לכללים קיימים (למשל, בעת יצירת קובצי כותרת עבור C++ ).
fragments sequence of strings; ברירת מחדל = []
רשימת שמות של קטעי תצורה שהכלל דורש בהגדרות התצורה שלהם.
host_fragments sequence of strings; ברירת מחדל = []
רשימת שמות של קטעי תצורה שהכלל דורש בהגדרה של המארח.
_skylark_testable ברירת מחדל = False
(ניסיוני)

אם כלל זה נכון, הכלל יחשוף את פעולות הבדיקה שלו לפי כללים שתלויים בו דרך ספק פעולות. בנוסף, הספק זמין לכלל עצמו על ידי קריאה לפונקציה ctx.created_actions() .

ניתן להשתמש באפשרות זו רק כדי לבדוק את התנהגות זמן הניתוח של כללי Starlark. יכול להיות שהסימון הזה יוסר בעתיד.
toolchains sequence; ברירת מחדל = []
אם היא מוגדרת, קבוצת ערכות הכלים שהכלל הזה מחייב. הרשימה יכולה להכיל אובייקטים של מחרוזת, תווית או StarlarkToolchainTypeApi, בכל שילוב. ניתן למצוא ערכות כלים על ידי בדיקת הפלטפורמה הנוכחית, ומסופקות ליישום הכלל באמצעות ctx.toolchain.
incompatible_use_toolchain_transition ברירת מחדל = False
הוצאה משימוש, כבר לא בשימוש ויש להסיר אותה.
doc ברירת מחדל = ''
תיאור של הכלל שניתן לחילוץ על ידי כלים ליצירת מסמכים.
provides ברירת מחדל = []
רשימה של ספקים שפונקציית ההטמעה צריכה להחזיר.

זו שגיאה אם פונקציית ההטמעה משמיטה כל אחד מסוגי הספקים שמפורטים כאן מערך ההחזרה. עם זאת, פונקציית ההטמעה עשויה להחזיר ספקים נוספים שלא רשומים כאן.

כל רכיב ברשימה הוא אובייקט *Info שמוחזר על ידי provider(), אלא שספק קודם מיוצג על ידי שם המחרוזת שלו.

exec_compatible_with sequence of strings; ברירת מחדל = []
רשימה של אילוצים בפלטפורמת הביצוע שחלים על כל היעדים של סוג הכלל הזה.
analysis_test ברירת מחדל = False
אם כלל זה נכון, הכלל הזה נחשב כבדיקת ניתוח.

הערה: כללי הבדיקה של Analytics מוגדרים בעיקר באמצעות תשתית המסופקת בספריות Corelark ליבה. לקבלת הנחיות, יש לעיין בקטע בדיקה.

אם כלל מוגדר ככלל לבדיקת ניתוח, הוא יורשה להשתמש במעברים של הגדרות אישיות שהוגדרו באמצעות analysis_test_transition במאפיינים שלו, אבל יופעל מספר הגבלות:

  • היעדים של הכלל הזה מוגבלים במספר יחסי התלות שלהם.
  • הכלל נחשב לכלל בדיקה (כפי שהוגדר test=True). הערך הזה מחליף את הערך test
  • ייתכן שפונקציית ההטמעה של הכלל לא מתעדת פעולות. במקום זאת, האתר חייב לרשום תוצאת אישור/נכשל על ידי שליחת הערך AnalysisTestResultInfo .
build_setting BuildSetting; or None; ברירת מחדל = ללא

אם היא מוגדרת, היא מתארת את הסוג של build setting הכלל הזה. אפשר לעיין במודול config. אם היא מוגדרת, מאפיין חובה בשם "build_setting_default" מתווסף באופן אוטומטי לכלל הזה, עם סוג שתואם לערך שמועבר כאן.
cfg ברירת מחדל = ללא
אם המדיניות מוגדרת, היא מפנה אל מעבר התצורה, הכלל יחול על ההגדרות האישיות שלה לפני הניתוח.
exec_groups dict; or None; ברירת מחדל = ללא
היקף של שם קבוצת הביצוע (מחרוזת) עד exec_groups. אם המדיניות מוגדרת, היא מאפשרת לכללים להריץ פעולות בכמה פלטפורמות הפעלה במסגרת יעד יחיד. מידע נוסף זמין בתיעוד של קבוצות ביצוע.
compile_one_filetype sequence of strings; or None; ברירת מחדל = ללא
בשימוש על ידי --RDFa_one_dependency: אם מספר כללים צורכים את הקובץ שצוין, עלינו לבחור בכלל הזה על פני אחרים.
name string; or None; ברירת מחדל = ללא
הוצאה משימוש: לא להשתמש.

השם של הכלל הזה, כפי שהוסבר על ידי Bazel ודווח בהקשרים כמו התחברות, native.existing_rule(...)[kind] ו-bazel query. בדרך כלל, זה זהה למזהה Starlark שמקושר לכלל הזה. לדוגמה, כלל שנקרא foo_library יוכרז כ-foo_library = rule(...) ויוצג בקובץ BUILD כ-foo_library(...).

אם הפרמטר הזה יושמט, השם של הכלל' מקבל את השם של המשתנה הגלובלי הראשון של Starlark שיהיה מקושר לכלל הזה במודול שלו. לכן, foo_library = rule(...) לא צריך לציין את הפרמטר הזה אם השם הוא foo_library.

ציון שם מפורש של כלל לא משנה את המקום שבו מותר ליצור את הכלל.

בחירה

unknown select(x, no_match_error='')

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

פרמטרים

פרמטר תיאור
x חובה
הצהרה שממופה תנאי התצורה לערכים. כל מפתח הוא תווית או מחרוזת תווית המזהה מופע של config_setting או של אילוץ ערך. בתיעוד בנושא פקודות מאקרו מוסבר מתי להשתמש בתווית במקום במחרוזת.
no_match_error ברירת מחדל = ''
אופציונלי בהתאמה אישית של שגיאה לדיווח אם אין תנאי תואם.

one_version_override

None single_version_override(module_name, version='', registry='', patches=[], patch_strip=0)

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

פרמטרים

פרמטר תיאור
module_name נדרש
השם של תלות המודול ב-Bazel שעליו יחול השינוי הזה.
version ברירת מחדל = ''
מבטל את הגרסה המוצהרת של המודול הזה בתרשים התלות. במילים אחרות, המודול הזה יהיה "מוצמד" לגרסת הביטול הזו. אפשר להשמיט את המאפיין הזה אם כולם רוצים לעקוף את המרשם או את התיקונים.
registry ברירת מחדל = ''
מבטל את הרישום של מודול זה; במקום למצוא את המודול הזה מרשימת ברירת המחדל של מרשמים, יש להשתמש במרשם הנתון.
patches Iterable of strings; ברירת מחדל = []
רשימת תוויות שמצביעה על קובצי תיקון שיחולו על המודול הזה. קובצי התיקון חייבים להיות קיימים בעץ המקור של הפרויקט ברמה העליונה. הן מסודרות לפי סדר הרשימה.
patch_strip ברירת מחדל = 0
זהה לארגומנט -striping של Unix issue.

מיון

list sorted(iterable, *, key=None, reverse=False)

מחזירה רשימה ממוינת חדשה שמכילה את כל רכיבי הרצף האיטרטיבי שסופק. אם מתרחשים רכיבי x או y, לא ניתן להשוות אותם באמצעות x < y. הרכיבים ממוינים בסדר עולה, אלא אם ארגומנט ההיפוך הוא True, ובמקרה זה הסדר יורד. המיון יציב: רכיבים שמשווים ביניהם שומרים על הסדר היחסי המקורי.
sorted([3, 5, 4]) == [3, 4, 5]

פרמטרים

פרמטר תיאור
iterable נדרש
הרצף החוזר של מיון.
key ברירת מחדל = ללא
פונקציה אופציונלית מופעלת על כל רכיב לפני ההשוואה.
reverse ברירת מחדל = False
החזרת התוצאות בסדר יורד.

שטר

string str(x)

ממירה אובייקט למחרוזת. זוהי פעולה יעילה לניפוי באגים.
str("ab") == "ab"
str(8) == "8"

פרמטרים

פרמטר תיאור
x נדרש
האובייקט להמרה.

tag_class

tag_class tag_class(attrs={}, *, doc='')

יצירה של אובייקט Tag_class חדש, מגדיר סכימת מאפיינים עבור מחלקת תגים, שהם אובייקטים של נתונים שניתן להשתמש בהם על ידי תוסף מודול.

פרמטרים

פרמטר תיאור
attrs ברירת מחדל = {}
מילון צריך להצהיר על כל המאפיינים של רמת התג הזו. הוא ממפה משם מאפיין לאובייקט מאפיין (עיינו במודול attr).
doc default = ''
תיאור של רמת התג שניתן לחלץ באמצעות כלים ליצירת מסמכים.

צבעוני

tuple tuple(x=())

מחזירה צבע מסוים עם אותם רכיבי ערך.
tuple([1, 2]) == (1, 2)
tuple((2, 3, 2)) == (2, 3, 2)
tuple({5: "a", 2: "b", 4: "c"}) == (5, 2, 4)

פרמטרים

פרמטר תיאור
x ברירת מחדל = ()
האובייקט להמרה.

סוג

string type(x)

מחזירה את שם הסוג של הארגומנט. פעולה זו שימושית לצורך ניפוי באגים ובדיקת סוגים. לדוגמה:
type(2) == "int"
type([1]) == "list"
type(struct(a = 2)) == "struct"
הפונקציה הזו עשויה להשתנות בעתיד. כדי לכתוב קוד שתואם ל-Python ולהיות עמיד בעתיד, אפשר להשתמש בו רק להשוואה בין ערכי החזרה:
if type(x) == type([]):  # if x is a list

פרמטרים

פרמטר תיאור
x חובה
האובייקט לבדיקה.

Use_extensions

module_extension_proxy use_extension(extension_bzl_file, extension_name, *, dev_dependency=False)

מחזירה אובייקט שרת proxy המייצג תוסף של מודול. ניתן להפעיל את השיטות שלו כדי ליצור תגים של תוסף מודול.

פרמטרים

פרמטר תיאור
extension_bzl_file חובה
תווית לקובץ Starlark שמגדיר את תוסף המודול.
extension_name חובה
השם של תוסף המודול. יש לייצא סמל בשם זה על ידי קובץ Starlark.
dev_dependency ברירת מחדל = False
אם הערך הוא TRUE, המערכת תתעלם מהשימוש בתוסף המודולים אם המודול הנוכחי אינו המודול הבסיסי או "`--ignore_dev_dependency" מופעל.

Use_repo

None use_repo(extension_proxy, *args, **kwargs)

מייבאת מיקום אחד או יותר שנוצרו על ידי תוסף המודול, אל היקף המודול הנוכחי.

פרמטרים

פרמטר תיאור
extension_proxy נדרש
אובייקט שרת proxy של תוסף מודול שהוחזר על ידי קריאה ל-use_extension.
args חובה
השמות של מאגר הנתונים לייבוא.
kwargs נדרש
המדיניות מציינת מיקום מסוים לייבוא אל המודול הנוכחי עם שמות שונים. המפתחות צריכים להיות השם לשימוש בהיקף הנוכחי, בעוד שהערכים צריכים להיות השמות המקוריים שמיוצאים על ידי תוסף המודול.

חשיפה

None visibility(value)

(ניסיוני. מופעל על ידי --experimental_bzl_visibility. ה-API של התכונה הזו עשוי להשתנות. רק חבילות שמופיעות ב---experimental_bzl_visibility_allowlist מורשות להתקשר לפונקציה הזו. בעיה ידועה: ייתכן שכרגע התכונה הזו לא פועלת ב-bzlmod.)

מגדיר את ניראות ה-bzl של מודול ה-bzl.

הנראות של bzl במודול .bzl (שאינה מיועדת לחשיפת יעד) קובעת אם קובץ load() מתוך קובץ ה- .bzl מותר מתוך קובצי BUILD ו- .bzl של חבילה מסוימת. הערכים המותרים כוללים:

  • "public" (ברירת מחדל): אפשר לטעון את קובץ ה- .bzl בכל מקום.
  • "private": את bzl ניתן לטעון רק על ידי קבצים באותה חבילה (חבילות משנה אינן כלולות).
  • רשימה של מפרטי חבילות (למשל ["//pkg1","//pkg2/subpkg/..."]): ניתן לטעון את הקובץ bzl. מפרטי חבילות יכולים להיות נתיבי חבילות או נתיבי חבילות עם "/..." בסוף, כדי לכלול את כל חבילות המשנה. בשלב זה, אין תמיכה בתבניות שבוטלו. כל מפרטי החבילות נמצאים במאגר הנוכחי. התחביר "@" אסור.

באופן כללי, קריאה אל visibility() מתבצעת בחלק העליון של קובץ ה- .bzl, מיד אחרי הדוחות של load(). (הסגנון לא טוב כדי להוסיף את ההצהרה הזו בשלב מאוחר יותר בקובץ או בשיטת עזר). ייתכן שהוא לא ייקרא יותר מפעם אחת לכל .bzl, או כאשר הקוד ברמה העליונה עם הסיומת .bzl' יסתיים.

חשוב לציין שלמודול bzl .שיש לו חשיפת bzl ציבורית אין בהכרח רמיזה שיעד הקובץ התואם שלו גלוי לציבור. כלומר, יש אפשרות load() להוסיף קובץ .bzl בלי להיות תלוי בו בfilegroup או ביעד אחר.

פרמטרים

פרמטר תיאור
value נדרש
רמת החשיפה של bzl להגדרה. יכול להיות "public", "private" או רשימת חבילות.

סביבת עבודה

None workspace(name)

ניתן להשתמש בפונקציה הזו רק בקובץ WORKSPACE, ויש להצהיר עליה לפני כל שאר הפונקציות בקובץ WORKSPACE. כל קובץ WORKSPACE צריך להכיל פונקציה workspace.

ההגדרה של השם של סביבת העבודה הזו. שמות של סביבות עבודה צריכים להיות תיאורי סגנון של חבילות Java, המופרדים בקו תחתון, לדוגמה: github.com/bazelbuild/bazel צריכים להשתמש ב-com_github_bazelbuild_bazel.

השם הזה משמש לספרייה שבה מאוחסנים קובצי הריצה של המאגר. לדוגמה, אם יש קובץריצה foo/bar במאגר המקומי, וקובץ WORKSPACE מכיל workspace(name = 'baz'), קובץ ה-runfile יהיה זמין בקטע mytarget.runfiles/baz/foo/bar. אם לא צוין שם של סביבת עבודה, קובץ הריצה יעבור סימולטנית ל-bar.runfiles/foo/bar.

שמות של כללי מאגר מרוחק חייבים להיות שמות חוקיים של סביבות עבודה. לדוגמה, יכול להיות שיש לך maven_jar(name = 'foo'), אבל לא maven_jar(name = 'foo%bar'), מפני ש-Bazel תנסה לכתוב קובץ WORKSPACE עבור maven_jar שמכיל את workspace(name = 'foo%bar').

פרמטרים

פרמטר תיאור
name חובה
השם של סביבת העבודה. השמות חייבים להתחיל באות ויכולים להכיל רק אותיות, מספרים, קווים תחתונים, קווים ונקודות.

zip

list zip(*args)

מחזירה list של tuple, כאשר טיפת ה-i-th מכילה את הרכיב ה-i-י מכל רצפי הארגומנטים או איטרציות. גודל הקלט הקצר ביותר ברשימה הוא. בארגומנט יחיד שניתן להחזיר, הוא מחזיר רשימה של קפיצה אחת. ללא ארגומנטים, הפונקציה תחזיר רשימה ריקה. דוגמאות:
zip()  # == []
zip([1, 2])  # == [(1,), (2,)]
zip([1, 2], [3, 4])  # == [(1, 3), (2, 4)]
zip([1, 2], [3, 4, 5])  # == [(1, 3), (2, 4)]

פרמטרים

פרמטר תיאור
args חובה
רשימות לדחיסה.