ग्लोबल

ग्लोबल एनवायरमेंट में रजिस्टर किए गए ऑब्जेक्ट, फ़ंक्शन, और मॉड्यूल.

पैसे चुकाकर बने सदस्यों के लिए

सभी

bool all(elements)

अगर सभी एलिमेंट का आकलन सही के तौर पर किया जाता है या कलेक्शन खाली होता है, तो यह 'सही' दिखाता है. bool फ़ंक्शन का इस्तेमाल करके, एलिमेंट को बूलियन में बदला जाता है.
all(["hello", 3, True]) == True
all([-1, 0, 1]) == False

पैरामीटर

पैरामीटर ब्यौरा
elements ज़रूरी है
एक स्ट्रिंग या एलिमेंट का कलेक्शन.

analysis_test_transition

transition analysis_test_transition(settings)

विश्लेषण-टेस्ट नियम की डिपेंडेंसी पर लागू करने के लिए, कॉन्फ़िगरेशन ट्रांज़िशन बनाता है. यह ट्रांज़िशन सिर्फ़ analysis_test = True वाले नियमों की विशेषताओं पर लागू किया जा सकता है. ऐसे नियमों की क्षमताओं में पाबंदी होती है. उदाहरण के लिए, उनके डिपेंडेंसी ट्री का साइज़ सीमित होता है. इसलिए, ट्रांज़िशन की मदद से बनाए गए ट्रांज़िशन की तुलना में, इस फ़ंक्शन का इस्तेमाल करके किए जाने वाले ट्रांज़िशन सीमित होते हैं.

यह फ़ंक्शन मुख्य तौर पर, विश्लेषण टेस्ट फ़्रेमवर्क की मुख्य लाइब्रेरी को आसान बनाने के लिए डिज़ाइन किया गया है. सबसे सही तरीकों के लिए, इसके दस्तावेज़ या इसे लागू करने के तरीके देखें.

पैरामीटर

पैरामीटर ब्यौरा
settings ज़रूरी है
एक डिक्शनरी, जिसमें कॉन्फ़िगरेशन सेटिंग के बारे में ऐसी जानकारी हो जिसे इस कॉन्फ़िगरेशन ट्रांज़िशन से सेट किया जाना चाहिए. कुंजियां, बिल्ड सेटिंग लेबल होती हैं और वैल्यू, ट्रांज़िशन के बाद की नई वैल्यू होती हैं. अन्य सभी सेटिंग में कोई बदलाव नहीं हुआ है. इसका इस्तेमाल करके, कॉन्फ़िगरेशन की उन खास सेटिंग का एलान करें जिन्हें पास करने के लिए, विश्लेषण की जांच को सेट करना ज़रूरी है.

कोई भी

bool any(elements)

अगर कम से कम एक एलिमेंट का आकलन सही के तौर पर होता है, तो यह 'सही' दिखाता है. bool फ़ंक्शन का इस्तेमाल करके, एलिमेंट को बूलियन में बदला जाता है.
any([-1, 0, 1]) == True
any([False, 0, ""]) == False

पैरामीटर

पैरामीटर ब्यौरा
elements ज़रूरी है
एक स्ट्रिंग या एलिमेंट का कलेक्शन.

archive_override

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

इससे यह तय होता है कि यह डिपेंडेंसी किसी रजिस्ट्री के बजाय, किसी खास जगह पर मौजूद संग्रह फ़ाइल (zip, gzip वगैरह) से आनी चाहिए. यह डायरेक्टिव सिर्फ़ रूट मॉड्यूल में लागू होता है. दूसरे शब्दों में, अगर किसी मॉड्यूल का इस्तेमाल दूसरे लोग डिपेंडेंसी के तौर पर करते हैं, तो उसके अपने ओवरराइड को अनदेखा कर दिया जाता है.

पैरामीटर

पैरामीटर ब्यौरा
module_name ज़रूरी है
इस ओवरराइड को लागू करने के लिए, Bazel मॉड्यूल डिपेंडेंसी का नाम.
urls string; or Iterable of strings; ज़रूरी है
संग्रह के यूआरएल, http(s):// या file:// वाले यूआरएल हो सकते हैं.
integrity डिफ़ॉल्ट = ''
सबरिसॉर्स इंटिग्रिटी फ़ॉर्मैट में, संग्रहित फ़ाइल का सही चेकसम.
strip_prefix डिफ़ॉल्ट = ''
यह एक डायरेक्ट्री प्रीफ़िक्स है, जो निकाली गई फ़ाइलों से अलग करता है.
patches Iterable of strings; डिफ़ॉल्ट = []
इस मॉड्यूल पर लागू करने के लिए, पैच फ़ाइलों पर ले जाने वाले लेबल की सूची. पैच फ़ाइलें, टॉप लेवल प्रोजेक्ट के सोर्स ट्री में मौजूद होनी चाहिए. इन्हें सूची के क्रम में लागू किया जाता है.
patch_cmds Iterable of strings; डिफ़ॉल्ट = []
पैच लागू होने के बाद, Linux/Macos पर लागू किए जाने वाले बैश निर्देशों का क्रम.
patch_strip डिफ़ॉल्ट = 0
यह Unix पैच के --strip आर्ग्युमेंट के जैसा है.

आसपेक्ट

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 फ़ंक्शन, जिसमें दो पैरामीटर होते हैं: टारगेट (वह टारगेट जिस पर आसपेक्ट रेशियो लागू किया जाता है) और 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 default = False
अब इस्तेमाल में नहीं है, इसका इस्तेमाल नहीं किया जा सकता है और इसे हटा देना चाहिए.
doc डिफ़ॉल्ट = ''
आसपेक्ट की जानकारी, जिसे दस्तावेज़ जनरेट करने वाले टूल की मदद से लिया जा सकता है.
apply_to_generating_rules डिफ़ॉल्ट = गलत
सही होने पर, आउटपुट फ़ाइल पर आसपेक्ट रेशियो लागू करने पर, यह आउटपुट फ़ाइल के जनरेट करने के नियम पर लागू होगा.

उदाहरण के लिए, मान लें कि कोई आसपेक्ट, `deps` विशेषता के ज़रिए ट्रांज़िटिव रूप से लागू होता है और `ऐल्फ़ा` को टारगेट करने के लिए लागू किया जाता है. मान लीजिए कि `ऐल्फ़ा` में `deps = [':beta_ बदलें']`, जहां `बीटा_आउटपुट`, टारगेट `बीटा` का एक एलान किया गया आउटपुट है, तो मान लें कि `बीटा` में टारगेट `charley` और सिर्फ़ `deps=True` में से एक के रूप में लागू होगा. अगर `लागू_to_generting` के ज़रिए, True TRUE लागू होगा.

डिफ़ॉल्ट रूप से 'गलत' होता है.
exec_compatible_with sequence of strings; डिफ़ॉल्ट = []
एक्ज़ीक्यूशन प्लैटफ़ॉर्म पर लागू होने वाली पाबंदियों की एक सूची, जो इस पहलू के सभी मामलों पर लागू होती है.
exec_groups dict; or None; डिफ़ॉल्ट = कोई नहीं
एक्ज़ीक्यूशन ग्रुप के नाम (स्ट्रिंग) को बोलकर exec_group करें. अगर यह नीति सेट है, तो पहलुओं को एक ही इंस्टेंस में कई एक्ज़ीक्यूशन प्लैटफ़ॉर्म पर कार्रवाइयां करने की अनुमति देता है. ज़्यादा जानकारी के लिए, एक्ज़ीक्यूशन ग्रुप के दस्तावेज़ देखें.

bazel_dep

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

यह नीति अन्य Bazel मॉड्यूल पर डायरेक्ट डिपेंडेंसी का एलान करती है.

पैरामीटर

पैरामीटर ब्यौरा
name ज़रूरी है
डायरेक्ट डिपेंडेंसी के तौर पर जोड़े जाने वाले मॉड्यूल का नाम.
version डिफ़ॉल्ट = ''
मॉड्यूल का वह वर्शन जिसे डायरेक्ट डिपेंडेंसी के तौर पर जोड़ा जाना है.
max_compatibility_level डिफ़ॉल्ट = -1
मॉड्यूल को डायरेक्ट डिपेंडेंसी के तौर पर जोड़ने के लिए, ज़्यादा से ज़्यादा compatibility_level हो सकते हैं. मॉड्यूल के वर्शन का मतलब है, कम से कम काम करने वाला कम से कम काम करने वाला लेवल. साथ ही, अगर इस एट्रिब्यूट के बारे में नहीं बताया गया है, तो सबसे ज़्यादा वैल्यू को भी.
repo_name डिफ़ॉल्ट = ''
इस डिपेंडेंसी को दिखाने वाले एक्सटर्नल रेपो का नाम. डिफ़ॉल्ट रूप से यह मॉड्यूल का नाम होता है.
dev_dependency default = False
अगर सही है, तो मौजूदा मॉड्यूल के रूट मॉड्यूल के न होने पर या `--ignore_dev_dependency` चालू होने पर, इस डिपेंडेंसी को अनदेखा कर दिया जाएगा.

bind

None bind(name, actual=None)

चेतावनी: bind() के इस्तेमाल का सुझाव नहीं दिया जाता. इसकी समस्याओं और उनके विकल्पों के बारे में लंबी चर्चा करने के लिए, बाइंड हटाने की कोशिश करें देखें.

//external पैकेज में टारगेट को एक उपनाम देता है.

पैरामीटर

पैरामीटर ब्यौरा
name ज़रूरी है
उपनाम के नाम के तौर पर दिखाने के लिए, '//external' में लगा लेबल
actual string; or None; डिफ़ॉल्ट = कोई नहीं
उपनाम बनाया जाने वाला असली लेबल

bool

bool bool(x=False)

बूल टाइप के लिए कंस्ट्रक्टर. अगर ऑब्जेक्ट None, False, खाली स्ट्रिंग (""), संख्या 0 या खाली कलेक्शन (जैसे, (), []) है, तो यह False दिखाता है. ऐसा न होने पर, यह True दिखाता है.

पैरामीटर

पैरामीटर ब्यौरा
x डिफ़ॉल्ट = गलत
वह वैरिएबल जिसे बदला जाना है.

configuration_field

LateBoundDefault configuration_field(fragment, name)

label टाइप की किसी एट्रिब्यूट के लिए, देर से तय की गई डिफ़ॉल्ट वैल्यू का रेफ़रंस देता है. अगर वैल्यू तय करने से पहले कॉन्फ़िगरेशन को बनाने की ज़रूरत होती है, तो वैल्यू 'लेट-बाउंड' होती है. इसे वैल्यू के तौर पर इस्तेमाल करने वाला कोई भी एट्रिब्यूट, निजी होना चाहिए.

इस्तेमाल के उदाहरण:

नियम की विशेषता तय करना: 

'_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)

depset बनाता है. direct पैरामीटर, डिपसेट के डायरेक्ट एलिमेंट की सूची है. वहीं, transitive पैरामीटर, डिपसेट की ऐसी सूची है जिसके एलिमेंट, बनाए गए डेपसेट के इनडायरेक्ट एलिमेंट बन जाते हैं. डिपसेट को सूची में बदलने के बाद एलिमेंट के दिखने का क्रम, order पैरामीटर से तय होता है. ज़्यादा जानकारी के लिए, डिसेट्स की खास जानकारी देखें.

किसी डिपसेट के सभी एलिमेंट (डायरेक्ट और इनडायरेक्ट) एक ही टाइप के होने चाहिए, जैसा कि एक्सप्रेशन type(x) से मिलता है.

हैश-आधारित सेट का इस्तेमाल इटरेशन के दौरान डुप्लीकेट हटाने के लिए किया जाता है. इसलिए, डिपसेट के सभी एलिमेंट हैश किए जा सकने वाले होने चाहिए. हालांकि, फ़िलहाल इस वैरिएंट की जांच सभी कंस्ट्रक्टर में लगातार नहीं की जाती है. लगातार जांच करने की सुविधा चालू करने के लिए, --insupported_always_check_depset_elements फ़्लैग इस्तेमाल करें; आने वाली रिलीज़ में डिफ़ॉल्ट रूप से यही कार्रवाई होगी; समस्या 10313 देखें.

इसके अलावा, एलिमेंट ऐसे होने चाहिए जिन्हें बदला न जा सके. हालांकि, आने वाले समय में इस पाबंदी में छूट दी जाएगी.

बनाए गए डेस्कसेट का क्रम, इसके transitive डिपसेट के क्रम के साथ काम करना चाहिए. "default" ऑर्डर किसी भी अन्य ऑर्डर के साथ काम करता है. अन्य सभी ऑर्डर सिर्फ़ खुद के ऑर्डर के साथ काम करते हैं.

पीछे/आगे काम करने की सुविधा के बारे में ध्यान दें. फ़िलहाल, यह फ़ंक्शन एक पोज़िशनल items पैरामीटर को स्वीकार करता है. यह अब सेवा में नहीं है और आने वाले समय में इसे हटा दिया जाएगा. साथ ही, इसके हटाए जाने के बाद, direct, depset फ़ंक्शन का सिर्फ़ पोज़िशनल पैरामीटर बन जाएगा. इसलिए, नीचे दिए गए दोनों कॉल एक जैसे हैं और आने वाले समय के लिए भी सुरक्षित हैं:

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

पैरामीटर

पैरामीटर ब्यौरा
direct sequence; or None; डिफ़ॉल्ट = कोई नहीं
किसी डिपसेट के डायरेक्ट एलिमेंट की सूची.
order डिफ़ॉल्ट = "डिफ़ॉल्ट"
नए डेटासेट के लिए ट्रैवर्सल रणनीति. संभावित वैल्यू देखने के लिए यहां जाएं.
transitive sequence of depsets; or None; डिफ़ॉल्ट = कोई नहीं
डेटा सेट की सूची जिसके एलिमेंट, डिपसेट के इनडायरेक्ट एलिमेंट बन जाएंगे.

dict

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

वैकल्पिक पोज़िशनल तर्क और कीवर्ड आर्ग्युमेंट के वैकल्पिक सेट का इस्तेमाल करके, शब्दकोश बनाया जा सकता है. ऐसे मामले में जहां एक ही 'की' कई बार दी गई है, आखिरी वैल्यू का इस्तेमाल किया जाएगा. कीवर्ड आर्ग्युमेंट के ज़रिए दी गई एंट्री, पोज़िशनल आर्ग्युमेंट के ज़रिए दी गई एंट्री के बाद मानी जाती हैं.

पैरामीटर

पैरामीटर ब्यौरा
pairs default = []
एक डिक्शनरी या बार-बार इस्तेमाल किया जा सकने वाला एलिमेंट, जिसके एलिमेंट की लंबाई 2 है (कुंजी, वैल्यू).
kwargs ज़रूरी है
अतिरिक्त एंट्री का शब्दकोश.

दिशा

list dir(x)

स्ट्रिंग की सूची दिखाता है: एट्रिब्यूट के नाम और पैरामीटर ऑब्जेक्ट के तरीके.

पैरामीटर

पैरामीटर ब्यौरा
x ज़रूरी है
वह ऑब्जेक्ट जिसकी जांच करनी है.

गिनती करें

list enumerate(list, start=0)

इंडेक्स (इंट) और इनपुट के क्रम से आइटम के साथ, जोड़ों (दो-एलिमेंट वाले टूपल) की सूची दिखाता है. 
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 default = False
अगर इस नीति को 'सही है' पर सेट किया जाता है, तो यह एक्सपोर्ट ग्रुप उस नियम के टूलचेन और कंस्ट्रेंट को इनहेरिट करता है जिससे यह ग्रुप जुड़ा है. अगर किसी दूसरी स्ट्रिंग पर सेट किया जाता है, तो आपको गड़बड़ी का मैसेज दिखेगा.

विफल रहा

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 और गलत के लिए 0.0 दिखाता है.
  • अगर x एक पूर्णांक है, तो float सबसे नज़दीकी सीमित फ़्लोटिंग-पॉइंट वैल्यू को x पर दिखाता है. अगर डाइमेंशन बहुत ज़्यादा है, तो गड़बड़ी की जानकारी दिखाता है.
  • अगर x एक स्ट्रिंग है, तो यह मान्य फ़्लोटिंग-पॉइंट लिटरल होनी चाहिए या यह NaN, Inf या Infinity के बराबर (छोटे-बड़े अक्षर को अनदेखा करते हुए) होनी चाहिए. इसके बाद, वैकल्पिक तौर पर + या - का निशान होना चाहिए.
किसी भी दूसरी वैल्यू की वजह से गड़बड़ी हो सकती है. बिना किसी तर्क के, float() 0.0 दिखाता है.

पैरामीटर

पैरामीटर ब्यौरा
x डिफ़ॉल्ट = अनबाउंड
बदली जाने वाली वैल्यू.

गेटैट

unknown getattr(x, name, default=unbound)

दिए गए नाम का स्ट्रक्चर फ़ील्ड मौजूद होने पर वह दिखाता है. अगर ऐसा नहीं है, तो यह 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_cmds=[], patch_strip=0)

इस नीति से तय होता है कि किसी Git रिपॉज़िटरी (डेटा स्टोर करने की जगह) की तय सीमा से डिपेंडेंसी आनी चाहिए. यह डायरेक्टिव सिर्फ़ रूट मॉड्यूल में लागू होता है. दूसरे शब्दों में, अगर किसी मॉड्यूल का इस्तेमाल दूसरे लोग डिपेंडेंसी के तौर पर करते हैं, तो उसके अपने ओवरराइड को अनदेखा कर दिया जाता है.

पैरामीटर

पैरामीटर ब्यौरा
module_name ज़रूरी है
इस ओवरराइड को लागू करने के लिए, Bazel मॉड्यूल डिपेंडेंसी का नाम.
remote ज़रूरी है
रिमोट Git रिपॉज़िटरी का यूआरएल.
commit default = ''
वह प्रतिबद्धता, जिसके लिए चेक आउट किया जाना चाहिए.
patches Iterable of strings; डिफ़ॉल्ट = []
इस मॉड्यूल पर लागू करने के लिए, पैच फ़ाइलों पर ले जाने वाले लेबल की सूची. पैच फ़ाइलें, टॉप लेवल प्रोजेक्ट के सोर्स ट्री में मौजूद होनी चाहिए. इन्हें सूची के क्रम में लागू किया जाता है.
patch_cmds Iterable of strings; डिफ़ॉल्ट = []
पैच लागू होने के बाद, Linux/Macos पर लागू किए जाने वाले बैश निर्देशों का क्रम.
patch_strip डिफ़ॉल्ट = 0
यह Unix पैच के --strip आर्ग्युमेंट के जैसा है.

hasattr

bool hasattr(x, name)

अगर ऑब्जेक्ट x में, दिए गए name का कोई एट्रिब्यूट या तरीका है, तो 'सही' दिखाता है. ऐसा नहीं होने पर 'गलत' दिखाता है. उदाहरण:
hasattr(ctx.attr, "myattr")

पैरामीटर

पैरामीटर ब्यौरा
x ज़रूरी है
वह ऑब्जेक्ट जिसकी जांच करनी है.
name ज़रूरी है
एट्रिब्यूट का नाम.

हैश

int hash(value)

स्ट्रिंग के लिए हैश वैल्यू दिखती है. इसकी गणना, उसी एल्गोरिदम का इस्तेमाल करके की जाती है जिसका इस्तेमाल Java के String.hashCode() के लिए किया जाता है. इस एल्गोरिदम का नाम है: 
s[0] * (31^(n-1)) + s[1] * (31^(n-2)) + ... + s[n-1]
स्ट्रिंग के अलावा, वैल्यू को हैश करने की सुविधा फ़िलहाल काम नहीं करती.

पैरामीटर

पैरामीटर ब्यौरा
value ज़रूरी है
हैश करने के लिए स्ट्रिंग वैल्यू.

int

int int(x, base=unbound)

पूर्णांक मान के रूप में x देता है.
  • अगर x पहले से ही एक पूर्णांक है, तो int इसमें कोई बदलाव नहीं करता है.
  • अगर x कोई बूल है, तो int 'सही' के लिए 1 और गलत के लिए 0 दिखाता है.
  • अगर x एक स्ट्रिंग है, तो इसका <sign><prefix><digits> फ़ॉर्मैट होना ज़रूरी है. <sign>, "+", "-" या खाली है (इसे पॉज़िटिव के तौर पर समझा जाएगा). <digits>, 0 से base - 1 तक के अंकों का क्रम होता है. इसमें 10 से 35 तक के अक्षरों a-z या इसके बराबर, A-Z को अंकों के तौर पर इस्तेमाल किया जाता है. ऐसे मामले में जहां 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 कोई और टाइप है या वैल्यू ऐसी स्ट्रिंग है जो ऊपर दिए गए फ़ॉर्मैट के मुताबिक नहीं है, तो यह फ़ंक्शन काम नहीं करता. Python के int फ़ंक्शन के उलट, यह फ़ंक्शन शून्य आर्ग्युमेंट की अनुमति नहीं देता. साथ ही, स्ट्रिंग आर्ग्युमेंट के लिए ग़ैर-ज़रूरी खाली सफ़ेद जगह की अनुमति नहीं देता.

उदाहरण:

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 डिफ़ॉल्ट = अनबाउंड
स्ट्रिंग की वैल्यू को समझाने के लिए इस्तेमाल किया गया बेस, डिफ़ॉल्ट रूप से 10 होता है. यह 2 से 36 (दोनों शामिल) के बीच होना चाहिए या 0 से होना चाहिए, ताकि यह पता लगाया जा सके कि x एक पूर्णांक लिटरल था. अगर वैल्यू कोई स्ट्रिंग नहीं है, तो यह पैरामीटर नहीं देना चाहिए.

len

int len(x)

किसी स्ट्रिंग, क्रम (जैसे कि सूची या टपल), डिक्शनरी या बार-बार इस्तेमाल किए जा सकने वाले अन्य विकल्पों की लंबाई दिखाता है.

पैरामीटर

पैरामीटर ब्यौरा
x ज़रूरी है
वह वैल्यू जिसकी रिपोर्ट की लंबाई है.

सूची

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 default = []
वह ऑब्जेक्ट जिसे बदलना है.

local_path_override

None local_path_override(module_name, path)

इस नीति से यह तय होता है कि लोकल डिस्क पर किसी खास डायरेक्ट्री से डिपेंडेंसी आनी चाहिए. यह डायरेक्टिव सिर्फ़ रूट मॉड्यूल में लागू होता है. दूसरे शब्दों में, अगर किसी मॉड्यूल का इस्तेमाल दूसरे लोग डिपेंडेंसी के तौर पर करते हैं, तो उसके अपने ओवरराइड को अनदेखा कर दिया जाता है.

पैरामीटर

पैरामीटर ब्यौरा
module_name ज़रूरी है
इस ओवरराइड को लागू करने के लिए, Bazel मॉड्यूल डिपेंडेंसी का नाम.
path ज़रूरी है
उस डायरेक्ट्री का पाथ जहां यह मॉड्यूल है.

ज़्यादा से ज़्यादा

unknown max(*args)

दिए गए सभी तर्कों में से सबसे बड़ा एक देता है. अगर सिर्फ़ एक आर्ग्युमेंट दिया गया हो, तो उसे खाली नहीं छोड़ा जा सकता.यह एक गड़बड़ी है, अगर एलिमेंट की तुलना नहीं की जा सकती (उदाहरण के लिए, स्ट्रिंग के साथ int) या कोई आर्ग्युमेंट नहीं दिया गया हो. 
max(2, 5, 4) == 5
max([5, 6, 3]) == 6

पैरामीटर

पैरामीटर ब्यौरा
args ज़रूरी है
वे एलिमेंट जिनकी जांच करनी है.

मि

unknown min(*args)

दिए गए सभी तर्कों में से सबसे छोटा एक देता है. अगर सिर्फ़ एक आर्ग्युमेंट दिया गया है, तो उसे बार-बार खाली नहीं छोड़ा जा सकता. अगर एलिमेंट की तुलना नहीं की जा सकती है (उदाहरण के लिए, स्ट्रिंग के साथ पूर्णांक) या कोई आर्ग्युमेंट नहीं दिया गया है, तो यह एक गड़बड़ी है. 
min(2, 5, 4) == 2
min([5, 6, 3]) == 3

पैरामीटर

पैरामीटर ब्यौरा
args ज़रूरी है
वे एलिमेंट जिनकी जांच करनी है.

मॉड्यूल

None module(name='', version='', compatibility_level=0, repo_name='', bazel_compatibility=[])

यह नीति, Bazel मॉड्यूल की कुछ प्रॉपर्टी का एलान करती है. इन प्रॉपर्टी को मौजूदा Bazel रेपो से दिखाया जाता है. ये प्रॉपर्टी या तो मॉड्यूल (जैसे कि नाम और वर्शन) का ज़रूरी मेटाडेटा होती हैं या फिर मौजूदा मॉड्यूल और इससे जुड़े दूसरे मॉड्यूल के व्यवहार पर असर डालती हैं.

इसे ज़्यादा से ज़्यादा एक बार कॉल किया जाना चाहिए. अगर यह मॉड्यूल रूट मॉड्यूल है, तो ही इसे हटाया जा सकता है (जैसे कि अगर वह किसी दूसरे मॉड्यूल पर निर्भर न हो).

पैरामीटर

पैरामीटर ब्यौरा
name डिफ़ॉल्ट = ''
मॉड्यूल का नाम. इस मॉड्यूल को सिर्फ़ तब छोड़ा जा सकता है, जब यह रूट मॉड्यूल हो (जैसा कि तब है, जब वह किसी दूसरे मॉड्यूल पर निर्भर न हो). मॉड्यूल का मान्य नाम: 1) सिर्फ़ अंग्रेज़ी के छोटे अक्षरों (a-z), अंक (0-9), बिंदु (.), हाइफ़न (-), और अंडरस्कोर (_) होने चाहिए; 2) अंग्रेज़ी के छोटे अक्षर से शुरू होने चाहिए; 3) अंग्रेज़ी के छोटे अक्षर या अंक से खत्म होने चाहिए.
version डिफ़ॉल्ट = ''
मॉड्यूल का वर्शन. इस मॉड्यूल को सिर्फ़ तब छोड़ा जा सकता है, जब यह रूट मॉड्यूल हो (जैसा कि तब है, जब वह किसी दूसरे मॉड्यूल पर निर्भर न हो).
compatibility_level डिफ़ॉल्ट = 0
मॉड्यूल के साथ काम करने का लेवल; जब भी कोई बड़ा बदलाव किया जा सके, तो इसे बदलना चाहिए. यह SumVer के मामले में, मॉड्यूल का "मुख्य वर्शन" है. हालांकि, यह वर्शन स्ट्रिंग में एम्बेड नहीं होता, बल्कि यह एक अलग फ़ील्ड के तौर पर मौजूद होता है. अलग-अलग कम्पैटबिलटी लेवल वाले मॉड्यूल, वर्शन रिज़ॉल्यूशन में इस तरह से शामिल होते हैं, जैसे कि वे अलग-अलग नाम वाले मॉड्यूल हों. हालांकि, फ़ाइनल डिपेंडेंसी ग्राफ़ में एक ही नाम वाले अलग-अलग मॉड्यूल वाले कई मॉड्यूल नहीं हो सकते. ऐसा तब तक होता है, जब तक multiple_version_override लागू न हो. ज़्यादा जानकारी के लिए, वहां देखें.
repo_name डिफ़ॉल्ट = ''
इस मॉड्यूल को दिखाने वाली रिपॉज़िटरी का नाम, जैसा कि मॉड्यूल में दिखता है. डिफ़ॉल्ट रूप से, रेपो का नाम मॉड्यूल का नाम होता है. यह ऐसे प्रोजेक्ट के माइग्रेशन को आसान बनाने के लिए तय किया जा सकता है जो अपने लिए ऐसे रेपो नाम का इस्तेमाल कर रहे हैं जो उसके मॉड्यूल के नाम से अलग है.
bazel_compatibility Iterable of strings; डिफ़ॉल्ट = []
bazel वर्शन की सूची, जिसमें उपयोगकर्ताओं को यह बताने की सुविधा मिलती है कि इस मॉड्यूल के साथ Bazel के कौनसे वर्शन काम करते हैं. इससे डिपेंडेंसी रिज़ॉल्यूशन पर कोई असर नहीं पड़ता. हालांकि, bzlmod इस जानकारी का इस्तेमाल यह देखने के लिए करेगा कि आपका मौजूदा Bazel वर्शन काम करता है या नहीं. इस वैल्यू का फ़ॉर्मैट, कुछ कंस्ट्रेंट वैल्यू की एक स्ट्रिंग है, जिसे कॉमा लगाकर अलग किया गया है. तीन कंस्ट्रेंट काम करते हैं: <=X.X.X: Bazel वर्शन, X.X.X के बराबर या उससे पुराना होना चाहिए. इसका इस्तेमाल तब किया जाता है, जब नए वर्शन में कोई ऐसा बदलाव होता है जो काम नहीं करता. >=X.X.X: Bazel वर्शन, X.X.X के बराबर या उससे नया होना चाहिए.इसका इस्तेमाल तब किया जाता है, जब आप कुछ ऐसी सुविधाओं पर निर्भर होते हैं जो सिर्फ़ X.X.X से उपलब्ध हैं. -X.X.X: Bazel वर्शन X.X.X के साथ काम नहीं करता है. इसका इस्तेमाल तब किया जाता है जब X.X.X में कोई ऐसा बग होता है जो आपके काम में रुकावट पैदा करता है, लेकिन बाद के वर्शन में इसे ठीक कर दिया जाता है.

module_extension

unknown module_extension(implementation, *, tag_classes={}, doc='', environ=[], os_dependent=False, arch_dependent=False)

नया मॉड्यूल एक्सटेंशन बनाता है. इसे ग्लोबल वैल्यू में सेव करें, ताकि इसे MODULE.bazel फ़ाइल में एक्सपोर्ट और इस्तेमाल किया जा सके.

पैरामीटर

पैरामीटर ब्यौरा
implementation ज़रूरी है
वह फ़ंक्शन जो इस मॉड्यूल एक्सटेंशन को लागू करता है. एक ही पैरामीटर होना चाहिए, module_ctx. इस फ़ंक्शन को बिल्ड की शुरुआत में एक बार कॉल किया जाता है, ताकि उपलब्ध डेटा स्टोर करने की जगहों का सेट तय किया जा सके.
tag_classes default = {}
यह एक डिक्शनरी है, जो एक्सटेंशन में इस्तेमाल की गई सभी टैग क्लास के बारे में जानकारी देता है. यह टैग क्लास के नाम से tag_class ऑब्जेक्ट पर मैप करता है.
doc डिफ़ॉल्ट = ''
मॉड्यूल एक्सटेंशन की जानकारी, जिसे दस्तावेज़ जनरेट करने वाले टूल की मदद से हासिल किया जा सकता है.
environ sequence of strings; default = []
एनवायरमेंट वैरिएबल की सूची देता है, जिस पर यह मॉड्यूल एक्सटेंशन निर्भर करता है. अगर उस सूची के एनवायरमेंट वैरिएबल में बदलाव होता है, तो एक्सटेंशन का फिर से आकलन किया जाएगा.
os_dependent डिफ़ॉल्ट = गलत है
यह बताता है कि यह एक्सटेंशन, ओएस पर निर्भर है या नहीं
arch_dependent default = False
यह बताता है कि यह एक्सटेंशन आर्किटेक्चर पर निर्भर है या नहीं

multiple_version_override

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

इस नीति से यह तय होता है कि किसी रजिस्ट्री से अब भी डिपेंडेंसी आनी चाहिए, लेकिन इसके एक से ज़्यादा वर्शन को एक साथ इस्तेमाल किया जा सकता है. ज़्यादा जानकारी के लिए, दस्तावेज़ देखें. यह डायरेक्टिव सिर्फ़ रूट मॉड्यूल में लागू होता है. दूसरे शब्दों में, अगर किसी मॉड्यूल का इस्तेमाल दूसरे लोग डिपेंडेंसी के तौर पर करते हैं, तो उसके अपने ओवरराइड को अनदेखा कर दिया जाता है.

पैरामीटर

पैरामीटर ब्यौरा
module_name ज़रूरी है
इस ओवरराइड को लागू करने के लिए, Bazel मॉड्यूल डिपेंडेंसी का नाम.
versions Iterable of strings; ज़रूरी है
साफ़ तौर पर, उन वर्शन के बारे में बताता है जिन्हें एक साथ रखा जा सकता है. ये वर्शन, डिपेंडेंसी ग्राफ़ में पहले से ही मौजूद होने चाहिए. इस मॉड्यूल के आधार पर, डिपेंडेंसी को "अपग्रेड" कर दिया जाएगा. साथ ही, यह एक ही लेवल वाले और अपग्रेड किए गए सबसे नए वर्शन पर "अपग्रेड" कर दिया जाएगा. वहीं, जिन डिपेंडेंसी के पास वर्शन की सुविधा के लिए, काम करने के एक ही लेवल वाले दूसरे वर्शन की तुलना में नया वर्शन है उनमें गड़बड़ी हो सकती है.
registry default = ''
इस मॉड्यूल के लिए रजिस्ट्री को बदल देता है; रजिस्ट्री की डिफ़ॉल्ट सूची से इस मॉड्यूल को ढूंढने के बजाय, दी गई रजिस्ट्री का इस्तेमाल किया जाना चाहिए.

प्रिंट करें

None print(sep=" ", *args)

args को डीबग आउटपुट के तौर पर प्रिंट करता है. इसे "DEBUG" स्ट्रिंग और इस कॉल की जगह (फ़ाइल और लाइन नंबर) के साथ जोड़ा जाएगा. आर्ग्युमेंट को स्ट्रिंग में बदलने का सटीक तरीका तय नहीं है. यह किसी भी समय बदल सकता है. खास तौर पर, यह str() और repr() के फ़ॉर्मैटिंग से अलग (और ज़्यादा ब्यौरे वाले) हो सकता है.

प्रोडक्शन कोड में print का इस्तेमाल करने की सलाह नहीं दी जाती है, क्योंकि उपयोगकर्ताओं के लिए यह स्पैम बना रहा है. किसी सुविधा को बंद करने के लिए, जब भी हो सके, fail() का इस्तेमाल करते समय तेज़ गड़बड़ी का सुझाव दें.

पैरामीटर

पैरामीटर ब्यौरा
sep default = " "
ऑब्जेक्ट के बीच में सेपरेटर स्ट्रिंग, डिफ़ॉल्ट रूप से स्पेस (" ") होती है.
args ज़रूरी है
प्रिंट किए जाने वाले ऑब्जेक्ट.

कंपनी

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
    ...

सेवा देने वाली कंपनियों का इस्तेमाल करने के तरीके के बारे में पूरी जानकारी देने वाली गाइड के लिए नियम (सेवा देने वाली कंपनियां) देखें.

अगर init बताया नहीं गया है, तो Provider कॉल करने लायक मान दिखाता है.

अगर init के बारे में बताया गया है, तो यह दो एलिमेंट का टपल दिखाता है: 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() दो एलिमेंट का टपल दिखाता है: सामान्य प्रोवाइडर सिंबल और रॉ कंस्ट्रक्टर.

इसके बाद, सटीक जानकारी दी गई है. सहज तरीके से चर्चा करने और इस्तेमाल के उदाहरण के लिए, नियम (सेवा देने वाली कंपनियों को अपनी ज़रूरत के हिसाब से शुरू करना) देखें.

P को, सेवा देने वाली कंपनी का सिंबल बनने दें, जिसे provider() को कॉल करने पर बनाया गया हो. आम तौर पर, P का इंस्टेंस, कंस्ट्रक्टर के डिफ़ॉल्ट फ़ंक्शन c(*args, **kwargs) को कॉल करके जनरेट किया जाता है, जो ये काम करता है:

  • अगर args खाली नहीं है, तो गड़बड़ी होती है.
  • अगर provider() को कॉल करते समय fields पैरामीटर दिया गया था और kwargs में कोई ऐसी कुंजी मौजूद है जो fields की सूची में नहीं है, तो गड़बड़ी होती है.
  • ऐसा नहीं होने पर, c एक नया इंस्टेंस दिखाता है, जिसमें kwargs में हर k: v एंट्री के लिए, v वैल्यू वाला k नाम का फ़ील्ड होता है.
इस मामले में जहां init कॉलबैक नहीं दिया गया है, वहां P सिंबल पर किया गया कॉल, डिफ़ॉल्ट कंस्ट्रक्टर फ़ंक्शन c के लिए कॉल के तौर पर काम करता है. दूसरे शब्दों में, P(*args, **kwargs) c(*args, **kwargs) देता है. उदाहरण के लिए,
MyInfo = provider()
m = MyInfo(foo = 1)
सीधे तौर पर इसे बना देगा, ताकि m, m.foo == 1 के साथ एक MyInfo इंस्टेंस हो.

हालांकि, जहां init बताया गया है, वहां कॉल P(*args, **kwargs) इसके बजाय नीचे दिए गए चरण पूरे करेगा:

  1. कॉलबैक को init(*args, **kwargs) के तौर पर शुरू किया गया है. इसका मतलब है कि उसी पोज़िशन और कीवर्ड आर्ग्युमेंट के साथ, जिन्हें P को पास किया गया था.
  2. init की रिटर्न वैल्यू एक डिक्शनरी, d होनी चाहिए, जिसकी कुंजियां फ़ील्ड के नाम वाली स्ट्रिंग होती हैं. अगर ऐसा नहीं है, तो गड़बड़ी होती है.
  3. d की एंट्री के साथ, डिफ़ॉल्ट कंस्ट्रक्टर को कॉल करने पर, P का एक नया इंस्टेंस जनरेट होता है, जैसे कि कीवर्ड आर्ग्युमेंट के तौर पर c(**d).

ध्यान दें: ऊपर दिए गए चरणों से यह पता चलता है कि गड़बड़ी तब होती है, जब *args या **kwargs, init के हस्ताक्षर से मेल नहीं खाते हैं या init के मुख्य भाग का आकलन नहीं हो पाता है (शायद fail() को कॉल करके), या init की रिटर्न वैल्यू, सही स्कीमा के साथ डिक्शनरी न हो.

इस तरह, 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)

step की बढ़ोतरी का इस्तेमाल करके, ऐसी सूची बनाता है जिसमें आइटम start से stop पर जाते हैं. अगर एक तर्क दिया जाता है, तो आइटम की रेंज 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 है). यह नकारात्मक हो सकता है.

register_execution_platforms()

None register_execution_platforms(*platform_labels)

पहले से तय प्लैटफ़ॉर्म को रजिस्टर करें, ताकि टूलचेन रिज़ॉल्यूशन के दौरान, Bazel इसे एक्ज़ीक्यूशन प्लैटफ़ॉर्म के तौर पर इस्तेमाल कर सके.

पैरामीटर

पैरामीटर ब्यौरा
platform_labels sequence of strings; ज़रूरी है
रजिस्टर करने के लिए प्लैटफ़ॉर्म के लेबल.

register_execution_platforms(dev_dependency)

None register_execution_platforms(dev_dependency=False, *platform_labels)

इस मॉड्यूल के चुने जाने पर, पहले से तय किए गए एक्ज़ीक्यूशन प्लैटफ़ॉर्म के बारे में बताता है, ताकि उन्हें रजिस्टर किया जा सके. इसमें ऐब्सलूट टारगेट पैटर्न होने चाहिए. यानी, @ या // से शुरू होना चाहिए. ज़्यादा जानकारी के लिए, टूलचेन रिज़ॉल्यूशन देखें.

पैरामीटर

पैरामीटर ब्यौरा
dev_dependency default = False
सही होने पर, अगर मौजूदा मॉड्यूल रूट मॉड्यूल नहीं है या `-ignore_dev_dependency` चालू है, तो प्रोग्राम चलाने वाले प्लैटफ़ॉर्म रजिस्टर नहीं किए जाएंगे.
platform_labels sequence of strings; ज़रूरी है
रजिस्टर करने के लिए प्लैटफ़ॉर्म के लेबल.

register_toolchains()

None register_toolchains(*toolchain_labels)

पहले से तय टूलचेन को रजिस्टर करें, ताकि Bazel टूलचेन रिज़ॉल्यूशन के दौरान इसका इस्तेमाल कर सके. टूलचेन तय करने और टूलचेन रजिस्टर करने के उदाहरण देखें.

पैरामीटर

पैरामीटर ब्यौरा
toolchain_labels sequence of strings; ज़रूरी है
रजिस्टर करने के लिए टूलचेन के लेबल.

register_toolchains(dev_dependency)

None register_toolchains(dev_dependency=False, *toolchain_labels)

इस मॉड्यूल के चुने जाने पर, पहले से तय किए गए टूलचेन को रजिस्टर किया जाता है. इसमें ऐब्सलूट टारगेट पैटर्न होने चाहिए. यानी, @ या // से शुरू होना चाहिए. ज़्यादा जानकारी के लिए, टूलचेन रिज़ॉल्यूशन देखें.

पैरामीटर

पैरामीटर ब्यौरा
dev_dependency डिफ़ॉल्ट = गलत
सही होने पर, अगर मौजूदा मॉड्यूल, रूट मॉड्यूल नहीं है या `--ignore_dev_dependency` चालू है, तो टूलचेन रजिस्टर नहीं होंगे.
toolchain_labels sequence of strings; ज़रूरी है
रजिस्टर करने के लिए टूलचेन के लेबल.

repository_rule

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

डेटा स्टोर करने की जगह का नया नियम बनाता है. इसे ग्लोबल वैल्यू में सेव करें, ताकि इसे Workspace फ़ाइल से लोड और कॉल किया जा सके.

पैरामीटर

पैरामीटर ब्यौरा
implementation ज़रूरी है
वह फ़ंक्शन जो इस नियम को लागू करता है. एक ही पैरामीटर होना चाहिए, repository_ctx. फ़ंक्शन को नियम के हर इंस्टेंस के लिए, लोड होने के दौरान कॉल किया जाता है.
attrs dict; or None; डिफ़ॉल्ट = कोई नहीं
नियम की सभी विशेषताओं के बारे में बताने के लिए डिक्शनरी. यह एट्रिब्यूट के नाम से एट्रिब्यूट ऑब्जेक्ट पर मैप करता है (attr मॉड्यूल देखें). _ से शुरू होने वाले एट्रिब्यूट निजी होते हैं. इनका इस्तेमाल किसी फ़ाइल में किसी लेबल पर इंप्लिसिट डिपेंडेंसी जोड़ने के लिए किया जा सकता है. डेटा स्टोर करने की जगह का नियम, जनरेट किए गए आर्टफ़ैक्ट पर निर्भर नहीं कर सकता. name एट्रिब्यूट को इंप्लिसिट तरीके से जोड़ा गया है और यह बताया नहीं जाना चाहिए.
local default = False
बताता है कि यह नियम लोकल सिस्टम से सब कुछ फ़ेच करता है. साथ ही, हर फ़ेच के समय इसका फिर से आकलन किया जाना चाहिए.
environ sequence of strings; डिफ़ॉल्ट = []
एनवायरमेंट वैरिएबल की सूची देता है, जिस पर यह रिपॉज़िटरी का यह नियम निर्भर करता है. अगर उस सूची में मौजूद किसी एनवायरमेंट वैरिएबल में बदलाव होता है, तो डेटा स्टोर करने की जगह को फिर से फ़ेच किया जाएगा.
configure डिफ़ॉल्ट = गलत
इससे पता चलता है कि डेटा स्टोर करने की जगह, कॉन्फ़िगरेशन के लिए सिस्टम की जांच करती है
remotable डिफ़ॉल्ट = गलत
प्रयोग के तौर पर उपलब्ध. इस पैरामीटर पर एक्सपेरिमेंट जारी है और इसे किसी भी समय बदला जा सकता है. कृपया इस पर निर्भर न रहें. इसे ---experimental_repo_remote_exec
रिमोट एक्ज़ीक्यूशन के साथ काम करता है सेट करके, एक्सपेरिमेंट के तौर पर चालू किया जा सकता है
doc डिफ़ॉल्ट = ''
रिपॉज़िटरी के नियम की जानकारी, जिसे दस्तावेज़ जनरेट करने वाले टूल की मदद से लिया जा सकता है.

Repr

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 डिफ़ॉल्ट = गलत
क्या यह नियम, टेस्ट करने के लिए बना नियम है. इसका मतलब है कि क्या इस नियम पर blaze test निर्देश लागू हो सकता है. जांच के सभी नियम अपने-आप लागू माने जाते हैं. जांच के नियम के लिए, executable = True को साफ़ तौर पर सेट करना ज़रूरी नहीं है. साथ ही, ऐसा करने की सलाह नहीं दी जाती. ज़्यादा जानकारी के लिए, नियम पेज देखें.
attrs dict; or None; डिफ़ॉल्ट = कोई नहीं
नियम की सभी विशेषताओं के बारे में बताने के लिए डिक्शनरी. यह एट्रिब्यूट के नाम से एट्रिब्यूट ऑब्जेक्ट पर मैप करता है (attr मॉड्यूल देखें). _ से शुरू होने वाले एट्रिब्यूट निजी होते हैं. इनका इस्तेमाल किसी लेबल पर इंप्लिसिट डिपेंडेंसी जोड़ने के लिए किया जा सकता है. name एट्रिब्यूट को इंप्लिसिट तरीके से जोड़ा गया है और यह बताया नहीं जाना चाहिए. visibility, deprecation, tags, testonly, और features एट्रिब्यूट इंप्लिसिट तरीके से जोड़े गए हैं और उन्हें ओवरराइड नहीं किया जा सकता. ज़्यादातर नियमों में कुछ ही विशेषताओं की ज़रूरत होती है. मेमोरी के इस्तेमाल को सीमित करने के लिए, नियम फ़ंक्शन attr के साइज़ पर सीमा लागू करता है.
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 एट्रिब्यूट का ऐक्सेस होता है. डिक्शनरी के बारे में सीधे तौर पर बताया गया हो या फ़ंक्शन के ज़रिए, इसका इस तरह से मतलब निकाला जाता है.

डिक्शनरी में हर एंट्री, पहले से तय किया गया एक आउटपुट बनाती है. इसमें कुंजी एक आइडेंटिफ़ायर होती है और वैल्यू एक स्ट्रिंग टेंप्लेट होती है, जो आउटपुट का लेबल तय करती है. नियम लागू करने वाले फ़ंक्शन में, आइडेंटिफ़ायर, फ़ील्ड का नाम बन जाता है. इसका इस्तेमाल, ctx.outputs में आउटपुट के File को ऐक्सेस करने के लिए किया जाता है. आउटपुट के लेबल में वही पैकेज होता है जो नियम के मुताबिक होता है. साथ ही, पैकेज बनाने के बाद वाला हिस्सा, "%{ATTR}" फ़ॉर्म के हर प्लेसहोल्डर को एट्रिब्यूट ATTR की वैल्यू से बनी स्ट्रिंग से बदलता है:

  • स्ट्रिंग टाइप किए गए एट्रिब्यूट को हूबहू बदल दिया जाता है.
  • लेबल के साथ दिए गए एट्रिब्यूट, पैकेज के बाद फ़ाइल एक्सटेंशन को घटाकर, लेबल का हिस्सा बन जाते हैं. उदाहरण के लिए, "//pkg:a/b.c" लेबल "a/b" हो जाता है.
  • आउटपुट टाइप वाले एट्रिब्यूट, पैकेज के बाद लेबल का हिस्सा बन जाते हैं. इसमें फ़ाइल एक्सटेंशन भी शामिल है (ऊपर दिए गए उदाहरण के लिए, "a/b.c").
  • प्लेसहोल्डर में इस्तेमाल किए गए, सूची के टाइप वाले सभी एट्रिब्यूट (उदाहरण के लिए, attr.label_list) में बिलकुल एक एलिमेंट होना चाहिए. उनका कन्वर्ज़न, बिना सूची वाले वर्शन (attr.label) के जैसा ही है.
  • हो सकता है कि प्लेसहोल्डर में दूसरी तरह के एट्रिब्यूट न दिखें.
  • बिना एट्रिब्यूट वाले खास प्लेसहोल्डर %{dirname} और %{basename}, नियम के लेबल के उन हिस्सों तक बड़े हो जाते हैं जिनमें उसका पैकेज शामिल नहीं होता है. उदाहरण के लिए, "//pkg:a/b.c" में, दिशा नाम a है और बेसनेम b.c है.

व्यावहारिक तौर पर, सबसे सामान्य प्रतिस्थापन प्लेसहोल्डर "%{name}" है. उदाहरण के लिए, "foo" नाम के टारगेट के लिए, आउटपुट डिक्शन {"bin": "%{name}.exe"} में, foo.exe नाम के एक आउटपुट के बारे में पहले से बताया गया है. इसे लागू करने वाले फ़ंक्शन में ctx.outputs.bin के तौर पर ऐक्सेस किया जा सकता है.

executable default = False
क्या इस नियम को एक्ज़ीक्यूटेबल माना जा सकता है. इसका मतलब है कि क्या इस नियम पर blaze run निर्देश लागू हो सकता है. ज़्यादा जानकारी के लिए, नियम पेज देखें.
output_to_genfiles default = False
सही होने पर, फ़ाइलें बिन डायरेक्ट्री के बजाय, genfiles डायरेक्ट्री में जनरेट की जाएंगी. जब तक मौजूदा नियमों (जैसे, C++ के लिए हेडर फ़ाइलें जनरेट करते समय) के साथ काम करने के लिए इसकी ज़रूरत न हो, तब तक इस फ़्लैग को सेट न करें.
fragments sequence of strings; डिफ़ॉल्ट = []
कॉन्फ़िगरेशन फ़्रैगमेंट के नामों की सूची, जिनके टारगेट कॉन्फ़िगरेशन में नियम ज़रूरी है.
host_fragments sequence of strings; डिफ़ॉल्ट = []
कॉन्फ़िगरेशन फ़्रैगमेंट के नामों की सूची, जो नियम के लिए होस्ट कॉन्फ़िगरेशन में ज़रूरी है.
_skylark_testable डिफ़ॉल्ट = गलत
(प्रयोग के तौर पर उपलब्ध)

सही होने पर, इस नियम में अपनी कार्रवाइयों की जांच ऐसे नियमों के हिसाब से की जाएगी जो इस पर निर्भर हैं. इसके लिए, उन्हें Actions की सेवा देने वाली कंपनी की मदद लेनी होगी. सेवा देने वाली कंपनी, ctx.created_actions() को कॉल करके नियम के लिए भी उपलब्ध होती है.

इसका इस्तेमाल सिर्फ़ Starlark के नियमों के विश्लेषण-समय के व्यवहार की जांच करने के लिए किया जाना चाहिए. आने वाले समय में यह फ़्लैग हटाया जा सकता है.
toolchains sequence; डिफ़ॉल्ट = []
अगर यह सेट है, तो इस नियम के लिए टूलचेन के सेट की ज़रूरत होती है. सूची में स्ट्रिंग, लेबल या StarlarkToolchainTypeApi ऑब्जेक्ट को किसी भी कॉम्बिनेशन में शामिल किया जा सकता है. टूलचेन, मौजूदा प्लैटफ़ॉर्म की जांच करके मिलेंगे और उन्हें ctx.toolchain के ज़रिए नियम लागू करने के लिए उपलब्ध कराया जाएगा.
incompatible_use_toolchain_transition default = False
अब इस्तेमाल में नहीं है, इसका इस्तेमाल नहीं किया जा सकता है और इसे हटा देना चाहिए.
doc डिफ़ॉल्ट = ''
नियम से जुड़ी ऐसी जानकारी जिसे दस्तावेज़ बनाने वाले टूल की मदद से लिया जा सकता है.
provides डिफ़ॉल्ट = []
उन कंपनियों की सूची जिन्हें लागू करने वाले फ़ंक्शन को दिखाना ज़रूरी है.

अगर लागू करने वाला फ़ंक्शन, रिटर्न वैल्यू से यहां दी गई सूची में शामिल किसी भी कंपनी को छोड़ देता है, तो यह एक गड़बड़ी है. हालांकि, लागू करने वाला फ़ंक्शन, सेवा देने वाली ऐसी कंपनियां भी दिखा सकता है जो यहां दी गई सूची में शामिल नहीं हैं.

सूची का हर एलिमेंट एक *Info ऑब्जेक्ट है, जिसे provider() दिखाता है. हालांकि, इसमें लेगसी प्रोवाइडर को उसके स्ट्रिंग नाम से दिखाया जाता है.

exec_compatible_with sequence of strings; डिफ़ॉल्ट = []
एक्ज़ीक्यूशन प्लैटफ़ॉर्म पर लागू होने वाली पाबंदियों की एक सूची, जो इस तरह के नियम के सभी टारगेट पर लागू होती है.
analysis_test डिफ़ॉल्ट = गलत
सही होने पर, इस नियम को विश्लेषण की जांच के तौर पर माना जाता है.

ध्यान दें: विश्लेषण जांच के नियमों को मुख्य रूप से Starlark की मुख्य लाइब्रेरी में उपलब्ध इंफ़्रास्ट्रक्चर का इस्तेमाल करके तय किया जाता है. दिशा-निर्देशों के लिए जांच देखें.

अगर कोई नियम, विश्लेषण से जुड़े टेस्ट के नियम के तौर पर तय किया गया है, तो उसे अपने एट्रिब्यूट पर 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_group करें. अगर यह नीति सेट है, तो इससे नियमों को एक ही टारगेट में, कई निष्पादन प्लैटफ़ॉर्म पर कार्रवाइयां करने की अनुमति मिलती है. ज़्यादा जानकारी के लिए, एक्ज़ीक्यूशन ग्रुप के दस्तावेज़ देखें.
compile_one_filetype sequence of strings; or None; डिफ़ॉल्ट = कोई नहीं
इसका इस्तेमाल करता है --compile_one_डिपेंडेंसी: अगर एक से ज़्यादा नियम तय की गई फ़ाइल का इस्तेमाल करते हैं, तो क्या हमें दूसरे नियम के बजाय इस नियम को चुनना चाहिए.
name string; or None; डिफ़ॉल्ट = कोई नहीं
अब काम नहीं करता. इस पैरामीटर के इस्तेमाल पर रोक लगा दी गई है और इसे जल्द ही हटा दिया जाएगा. कृपया इस पर निर्भर न रहें. यह --+incompatible_remove_rule_name_parameter के साथ बंद है. इस फ़्लैग का इस्तेमाल करके यह पुष्टि करें कि आपका कोड, तुरंत हटाए जाने के लिए इस्तेमाल किया जा सकता है या नहीं.
अब काम नहीं करता: इस्तेमाल न करें.

इस नियम का नाम, जैसा कि Bazel ने समझा और इसे लॉग करने, native.existing_rule(...)[kind], और bazel query जैसे कॉन्टेक्स्ट में रिपोर्ट किया. आम तौर पर, यह स्टारलार्क आइडेंटिफ़ायर जैसा ही होता है, जो इस नियम के लिए बाध्य होता है. उदाहरण के लिए, foo_library नाम के नियम को आम तौर पर foo_library = rule(...) के तौर पर तय किया जाएगा और BUILD फ़ाइल में foo_library(...) के तौर पर इंस्टैंशिएट किया जाएगा.

अगर यह पैरामीटर हटाया जाता है, तो नियम का नाम Starlark के पहले ग्लोबल वैरिएबल के नाम पर सेट हो जाता है, ताकि यह नियम अपने एलान किए गए .bzl मॉड्यूल के अंदर ही इस नियम से जुड़ सके. इसलिए, अगर नाम foo_library है, तो foo_library = rule(...) को इस पैरामीटर के बारे में बताने की ज़रूरत नहीं है.

किसी नियम के लिए साफ़ तौर पर नाम देने से, नियम को इंस्टैंशिएट करने की अनुमति नहीं मिलती.

चुनें

unknown select(x, no_match_error='')

select() एक हेल्पर फ़ंक्शन है, जो नियम एट्रिब्यूट को कॉन्फ़िगर किया जा सकता है बनाता है. ज़्यादा जानकारी के लिए एनसाइक्लोपीडिया बनाएं देखें.

पैरामीटर

पैरामीटर ब्यौरा
x ज़रूरी है
यह एक ऐसा लिखवाना जो वैल्यू के लिए कॉन्फ़िगरेशन की शर्तों को मैप करता है. हर कुंजी एक लेबल या लेबल स्ट्रिंग होती है, जो config_setting या कंस्ट्रेंट_वैल्यू इंस्टेंस की पहचान करती है. स्ट्रिंग के बजाय लेबल का इस्तेमाल कब करना चाहिए, यह जानने के लिए मैक्रो से जुड़ा दस्तावेज़ देखें.
no_match_error डिफ़ॉल्ट = ''
अगर कोई भी शर्त मेल नहीं खाती है, तो कस्टम गड़बड़ी की जानकारी देना ज़रूरी नहीं है.

single_version_override

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

इससे यह पता चलता है कि किसी डिपेंडेंसी को अब भी रजिस्ट्री से आना चाहिए, लेकिन उसके वर्शन को पिन किया जाना चाहिए या उसकी रजिस्ट्री को बदल दिया जाना चाहिए या लागू किए गए पैच की सूची को बदला जाना चाहिए. यह डायरेक्टिव सिर्फ़ रूट मॉड्यूल में लागू होता है. दूसरे शब्दों में, अगर किसी मॉड्यूल का इस्तेमाल दूसरे लोग डिपेंडेंसी के तौर पर करते हैं, तो उसके अपने ओवरराइड को अनदेखा कर दिया जाता है.

पैरामीटर

पैरामीटर ब्यौरा
module_name ज़रूरी है
इस ओवरराइड को लागू करने के लिए, Bazel मॉड्यूल डिपेंडेंसी का नाम.
version default = ''
डिपेंडेंसी ग्राफ़ में इस मॉड्यूल के एलान किए गए वर्शन को बदल देता है. दूसरे शब्दों में, इस मॉड्यूल को बदलने वाले इस वर्शन में "पिन" किया जाएगा. अगर कोई व्यक्ति रजिस्ट्री या पैच को ओवरराइड करना चाहता है, तो इस एट्रिब्यूट को छोड़ा जा सकता है.
registry default = ''
इस मॉड्यूल के लिए रजिस्ट्री को बदल देता है; रजिस्ट्री की डिफ़ॉल्ट सूची से इस मॉड्यूल को ढूंढने के बजाय, दी गई रजिस्ट्री का इस्तेमाल किया जाना चाहिए.
patches Iterable of strings; डिफ़ॉल्ट = []
इस मॉड्यूल पर लागू करने के लिए, पैच फ़ाइलों पर ले जाने वाले लेबल की सूची. पैच फ़ाइलें, टॉप लेवल प्रोजेक्ट के सोर्स ट्री में मौजूद होनी चाहिए. इन्हें सूची के क्रम में लागू किया जाता है.
patch_cmds Iterable of strings; डिफ़ॉल्ट = []
पैच लागू होने के बाद, Linux/Macos पर लागू किए जाने वाले बैश निर्देशों का क्रम.
patch_strip डिफ़ॉल्ट = 0
यह Unix पैच के --strip आर्ग्युमेंट के जैसा है.

क्रम से लगाया गया

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

क्रम से लगाई गई नई सूची देता है जिसमें दिए गए फिर से इस्तेमाल किए जा सकने वाले क्रम के सभी एलिमेंट शामिल होते हैं. अगर एलिमेंट x और y के किसी जोड़े की तुलना x < y का इस्तेमाल करके नहीं की जाती है, तो गड़बड़ी हो सकती है. एलिमेंट को बढ़ते क्रम में लगाया जाता है. ऐसा तब तक होता है, जब तक रिवर्स आर्ग्युमेंट 'सही' न हो. ऐसे मामले में, एलिमेंट का क्रम घटते क्रम में लगाया जाता है. क्रम से लगाने का तरीका स्थिर होता है: जिन एलिमेंट की तुलना एक जैसी होती है वे अपने मूल क्रम में बने रहते हैं. 
sorted([3, 5, 4]) == [3, 4, 5]

पैरामीटर

पैरामीटर ब्यौरा
iterable ज़रूरी है
क्रम से लगाने के लिए दोहराया जा सकने वाला क्रम.
key डिफ़ॉल्ट = कोई नहीं
तुलना से पहले, हर एलिमेंट के लिए एक वैकल्पिक फ़ंक्शन लागू किया जाता है.
reverse डिफ़ॉल्ट = गलत
घटते क्रम में नतीजे दिखाता है.

str

string str(x)

किसी भी ऑब्जेक्ट को स्ट्रिंग में बदलता है. यह डीबग करने के लिए काम का है.
str("ab") == "ab"
str(8) == "8"

पैरामीटर

पैरामीटर ब्यौरा
x ज़रूरी है
बदला जाने वाला ऑब्जेक्ट.

tag_class

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

एक नया tag_class ऑब्जेक्ट बनाता है, जो टैग की क्लास के लिए एट्रिब्यूट स्कीमा को तय करता है. ये ऐसे डेटा ऑब्जेक्ट होते हैं जिनका इस्तेमाल किसी मॉड्यूल एक्सटेंशन से किया जा सकता है.

पैरामीटर

पैरामीटर ब्यौरा
attrs default = {}
इस टैग क्लास के सभी एट्रिब्यूट के बारे में बताने वाला डिक्शनरी. यह एट्रिब्यूट के नाम से एट्रिब्यूट ऑब्जेक्ट पर मैप करता है (attr मॉड्यूल देखें).
doc डिफ़ॉल्ट = ''
टैग क्लास की जानकारी, जिसे दस्तावेज़ जनरेट करने वाले टूल की मदद से निकाला जा सकता है.

tuple

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 default = ()
वह ऑब्जेक्ट जिसे बदलना है.

टाइप करें

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_extension

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

यह फ़ंक्शन किसी मॉड्यूल एक्सटेंशन को दिखाने वाला प्रॉक्सी ऑब्जेक्ट दिखाता है. मॉड्यूल एक्सटेंशन टैग बनाने के लिए, इसके तरीकों का इस्तेमाल किया जा सकता है.

पैरामीटर

पैरामीटर ब्यौरा
extension_bzl_file ज़रूरी है
Starlark फ़ाइल के लिए लेबल, जो मॉड्यूल एक्सटेंशन के बारे में बताता है.
extension_name ज़रूरी है
इस्तेमाल किए जाने वाले मॉड्यूल एक्सटेंशन का नाम. इस नाम के चिह्न को Starlark फ़ाइल के ज़रिए एक्सपोर्ट किया जाना चाहिए.
dev_dependency default = False
सही होने पर, अगर मौजूदा मॉड्यूल रूट मॉड्यूल नहीं है या `--ignore_dev_dependency` चालू है, तो मॉड्यूल एक्सटेंशन के इस इस्तेमाल को अनदेखा कर दिया जाएगा.
isolate डिफ़ॉल्ट = गलत
प्रयोग के तौर पर उपलब्ध. इस पैरामीटर पर एक्सपेरिमेंट जारी है और इसे किसी भी समय बदला जा सकता है. कृपया इस पर निर्भर न रहें. इसे ---experimental_isolated_extension_usages
सही होने पर, सेट करके एक्सपेरिमेंट के लिए चालू किया जा सकता है. अगर सही है, तो मॉड्यूल एक्सटेंशन के इस इस्तेमाल को इस और अन्य मॉड्यूल दोनों में किसी भी अन्य इस्तेमाल से अलग कर दिया जाएगा. इस इस्तेमाल के लिए बनाए गए टैग, अन्य इस्तेमाल पर असर नहीं डालते. साथ ही, इस इस्तेमाल के लिए एक्सटेंशन से जनरेट किए गए डेटा स्टोर करने की जगहें, एक्सटेंशन से जनरेट किए गए अन्य डेटा स्टोर करने की जगहों से अलग होंगे.

फ़िलहाल, इस पैरामीटर पर प्रयोग जारी है और यह सिर्फ़ --experimental_isolated_extension_usages फ़्लैग के साथ उपलब्ध है.

use_repo

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

दिए गए मॉड्यूल एक्सटेंशन से जनरेट किए गए एक या उससे ज़्यादा रिपोज़ को, मौजूदा मॉड्यूल के स्कोप में इंपोर्ट करता है.

पैरामीटर

पैरामीटर ब्यौरा
extension_proxy ज़रूरी है
use_extension कॉल से मिला मॉड्यूल एक्सटेंशन प्रॉक्सी ऑब्जेक्ट, जो मिला है.
args ज़रूरी है
इंपोर्ट करने के लिए डेटा स्टोर के नाम.
kwargs ज़रूरी है
इससे मौजूदा मॉड्यूल के स्कोप में अलग-अलग नामों से इंपोर्ट करने के लिए, कुछ डेटा स्टोर करने की जगहों के बारे में पता चलता है. मौजूदा स्कोप में इस्तेमाल करने के लिए कुंजियों का नाम होना चाहिए, जबकि वैल्यू, मॉड्यूल एक्सटेंशन से एक्सपोर्ट किए गए मूल नाम होने चाहिए.

किसे दिखे

None visibility(value)

यह नीति, फ़िलहाल शुरू किए जा रहे .bzl मॉड्यूल की लोड विज़िबिलिटी सेट करती है.

किसी मॉड्यूल की लोड विज़िबिलिटी यह तय करती है कि अन्य BUILD और .bzl फ़ाइलें लोड हो सकती हैं या नहीं. यह मौजूदा .bzl सोर्स फ़ाइल के टारगेट व्यू से अलग है. इससे यह तय होता है कि फ़ाइल, अन्य टारगेट पर डिपेंडेंसी के तौर पर दिख सकती है या नहीं. लोड देखने की अनुमति, पैकेज के लेवल पर काम करती है: किसी मॉड्यूल को लोड करने के लिए, फ़ाइल लोड होने वाली फ़ाइल, ऐसे पैकेज में होनी चाहिए जिसे मॉड्यूल को देखने की अनुमति दी गई है. मॉड्यूल हमेशा अपने पैकेज में ही लोड किया जा सकता है, भले ही वह किसे दिखे.

हर .bzl फ़ाइल में visibility() को सिर्फ़ एक बार कॉल किया जा सकता है. साथ ही, इसे सिर्फ़ टॉप लेवल पर कॉल किया जा सकता है, किसी फ़ंक्शन में नहीं. सबसे सही तरीका यह है कि इस कॉल को load() स्टेटमेंट के ठीक नीचे रखा जाए और तर्क तय करने के लिए ज़रूरी कोई लॉजिक दिया जाए.

अगर फ़्लैग --check_bzl_visibility को 'गलत है' पर सेट किया गया है, तो लोड दिखने के दौरान नीति का उल्लंघन होने पर चेतावनियां भेजी जाएंगी, लेकिन बिल्ड फ़ेल नहीं होगा.

पैरामीटर

पैरामीटर ब्यौरा
value ज़रूरी है
पैकेज स्पेसिफ़िकेशन वाली स्ट्रिंग की सूची या पैकेज स्पेसिफ़िकेशन के लिए एक स्ट्रिंग.

पैकेज की जानकारी, package_group के फ़ॉर्मैट का ही होती है. हालांकि, पैकेज के लिए नेगेटिव पैकेज की खास बातों की अनुमति नहीं है. इसका मतलब है कि किसी खास जानकारी में ये फ़ॉर्म हो सकते हैं:

  • "//foo": पैकेज //foo
  • "//foo/...": पैकेज //foo और इसके सभी सबपैकेज.
  • "public" या "private": क्रम से सभी पैकेज या कोई पैकेज नहीं

"@" सिंटैक्स की अनुमति नहीं है; सभी स्पेसिफ़िकेशन की व्याख्या, मौजूदा मॉड्यूल के रिपॉज़िटरी के हिसाब से की जाती है.

अगर value स्ट्रिंग की सूची है, तो इस मॉड्यूल को दिखने वाले पैकेज का सेट, हर स्पेसिफ़िकेशन के तहत दिखाए गए पैकेज का ग्रुप होता है. (खाली सूची का वही असर होता है जो private का होता है.) अगर value एक सिंगल स्ट्रिंग है, तो इसे सिंगलटन सूची [value] माना जाता है.

ध्यान दें कि --incompatible_package_group_has_public_syntax और --incompatible_fix_package_group_reporoot_syntax फ़्लैग का इस तर्क पर कोई असर नहीं होता. "public" और "private" वैल्यू हमेशा उपलब्ध होती हैं. साथ ही, "//..." को हमेशा "डेटा स्टोर करने की मौजूदा जगह में मौजूद सभी पैकेज" के तौर पर माना जाता है.

कार्यस्थान

None workspace(name)

इस फ़ंक्शन का इस्तेमाल सिर्फ़ WORKSPACE फ़ाइल में किया जा सकता है. साथ ही, WORKSPACE फ़ाइल में मौजूद दूसरे सभी फ़ंक्शन से पहले इस फ़ंक्शन का एलान करना ज़रूरी है. हर WORKSPACE फ़ाइल में workspace फ़ंक्शन होना चाहिए.

इस फ़ाइल फ़ोल्डर के लिए नाम सेट करता है. फ़ाइल फ़ोल्डर के नाम, प्रोजेक्ट की Java-पैकेज-स्टाइल की जानकारी होनी चाहिए.साथ ही, उसे सेपरेटर के तौर पर इस्तेमाल करना चाहिए. जैसे, github.com/bazelbuild/bazel को com_github_bazelbuild_bazel का इस्तेमाल करना चाहिए.

यह नाम उस डायरेक्ट्री के लिए इस्तेमाल किया जाता है जिसमें डेटा स्टोर करने की जगह की रनफ़ाइलें सेव की जाती हैं. उदाहरण के लिए, अगर लोकल डेटा स्टोर करने की जगह में रनफ़ाइल foo/bar है और SPACESPACE फ़ाइल में workspace(name = 'baz') है, तो रनफ़ाइल mytarget.runfiles/baz/foo/bar में उपलब्ध होगी. अगर फ़ाइल फ़ोल्डर का कोई नाम नहीं दिया गया है, तो रनफ़ाइल को bar.runfiles/foo/bar से सिंक किया जाएगा.

रिमोट रिपॉज़िटरी के नियम के नाम, फ़ाइल फ़ोल्डर के मान्य नाम होने चाहिए. उदाहरण के लिए, आपके पास maven_jar(name = 'foo') हो सकता है, लेकिन maven_jar(name = 'foo%bar') नहीं, क्योंकि Bazel maven_jar के लिए एक ऐसी Workspace फ़ाइल लिखने की कोशिश करेगा जिसमें workspace(name = 'foo%bar') हो.

पैरामीटर

पैरामीटर ब्यौरा
name फ़ाइल फ़ोल्डर का नाम
ज़रूरी है. नाम की शुरुआत अक्षर से होनी चाहिए और उनमें सिर्फ़ अक्षर, संख्याएं, अंडरस्कोर, डैश, और बिंदु शामिल किए जा सकते हैं.

zip

list zip(*args)

tuple का list देता है, जहां i-वें टपल में हर तर्क क्रम या फिर से इस्तेमाल किए जा सकने वाले एलिमेंट का i-वां एलिमेंट शामिल होता है. सूची में सबसे छोटे इनपुट का साइज़ होता है. एक बार दोहराए जा सकने वाले तर्क के साथ, यह 1-टपल की सूची दिखाता है. बिना किसी आर्ग्युमेंट के, यह एक खाली सूची दिखाता है. उदाहरण:
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 ज़िप करने के लिए
सूचियाँ ज़रूरी हैं.