ग्लोबल

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

सदस्य

all
analysis_test_transition
any
archive_override
aspect
bazel_dep
bind
bool
configuration_field
depset
dict
dir
enumerate
exec_group
fail
फ़्लोट
getattr
git_override
hasattr
hash
int
len
list
local_path_override
max
min
मॉड्यूल
module_extension
multiple_version_override
print
provider
रेंज
register_execution_platforms()
register_execution_platforms(dev_dependency)
register_toolchains()
register_toolchains(dev_dependency)
repository_rule
repr
रिवर्स किया गया
rule
select
single_version_override
sorted
str
tag_class
टपल
टाइप
use_extension
use_repo
visibility
workspace
zip

सभी

bool all(elements)

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

all(["hello", 3, True]) == True
all([-1, 0, 1]) == False

पैरामीटर

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

analysis_test_transition

transition analysis_test_transition(settings)

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

इस फ़ंक्शन को मुख्य तौर पर, Analysis Test Framework की मुख्य लाइब्रेरी को बेहतर बनाने के लिए डिज़ाइन किया गया है. सबसे सही तरीके जानने के लिए, इसका दस्तावेज़ (या इसे लागू करने का तरीका) देखें.

पैरामीटर

पैरामीटर ब्यौरा

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

पैरामीटर	ब्यौरा
`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`	default = '' संग्रह की फ़ाइल का अनुमानित चेकसम, सबरीसोर्स इंटिग्रिटी फ़ॉर्मैट में.
`strip_prefix`	default = '' यह एक डायरेक्ट्री प्रीफ़िक्स है, जिसे निकाली गई फ़ाइलों से हटाया जाता है.
`patches`	`Iterable of strings`; default = [] यह इस मॉड्यूल के लिए लागू की जाने वाली पैच फ़ाइलों की सूची है. पैच फ़ाइलें, टॉप लेवल प्रोजेक्ट के सोर्स ट्री में मौजूद होनी चाहिए. ये सूची में दिए गए क्रम के हिसाब से लागू होते हैं.
`patch_cmds`	`Iterable of strings`; default = [] पैच लागू होने के बाद, Linux/Macos पर लागू होने वाले बैश कमांड का क्रम.
`patch_strip`	default = 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 फ़ंक्शन है, जो इस आसपेक्ट को लागू करता है. इसमें दो पैरामीटर होते हैं: Target (वह टारगेट जिस पर आसपेक्ट लागू किया जाता है) और ctx (वह नियम कॉन्टेक्स्ट जिससे टारगेट बनाया जाता है). टारगेट के एट्रिब्यूट, `ctx.rule` फ़ील्ड के ज़रिए उपलब्ध होते हैं. विश्लेषण के दौरान, इस फ़ंक्शन का आकलन किया जाता है. ऐसा, किसी टारगेट के लिए किसी आसपेक्ट को हर बार लागू करने के लिए किया जाता है.
`attr_aspects`	`sequence of strings`; default = [] List of attribute names. यह आसपेक्ट इन नामों वाले टारगेट के एट्रिब्यूट में बताई गई डिपेंडेंसी के साथ लागू होता है. आम तौर पर, `deps` और `exports` वैल्यू का इस्तेमाल किया जाता है. सूची में एक स्ट्रिंग `"*"` भी शामिल हो सकती है, ताकि इसे टारगेट की सभी डिपेंडेंसी के साथ लागू किया जा सके.
`attrs`	`dict; or None`; default = None यह एक डिक्शनरी है, जिसमें पहलू के सभी एट्रिब्यूट की जानकारी होती है. यह किसी एट्रिब्यूट के नाम को एट्रिब्यूट ऑब्जेक्ट से मैप करता है. जैसे, `attr.label` या `attr.string` (attr मॉड्यूल देखें). एसपेक्ट एट्रिब्यूट, लागू करने वाले फ़ंक्शन के लिए `ctx` पैरामीटर के फ़ील्ड के तौर पर उपलब्ध होते हैं. `_` से शुरू होने वाले ऐसे एट्रिब्यूट जिनकी वैल्यू का साफ़ तौर पर पता नहीं चलता है उनकी वैल्यू डिफ़ॉल्ट होनी चाहिए. साथ ही, इनका टाइप `label` या `label_list` होना चाहिए. ऐसे एट्रिब्यूट जिनकी वैल्यू का पता साफ़ तौर पर चलता है, उनका टाइप `string` होना चाहिए. साथ ही, उनमें `values` पाबंदी का इस्तेमाल होना चाहिए. ऐसे एट्रिब्यूट जिनकी वैल्यू का पता साफ़ तौर पर चलता है, आसपेक्ट को सिर्फ़ उन नियमों के साथ इस्तेमाल करने की पाबंदी लगाते हैं जिनमें पाबंदी के हिसाब से एक ही नाम, टाइप, और मान्य वैल्यू वाले एट्रिब्यूट हों.
`required_providers`	default = [] इस एट्रिब्यूट की मदद से, आसपेक्ट को सिर्फ़ उन टारगेट तक सीमित किया जा सकता है जिनके नियमों में, ज़रूरी सेवा देने वाली कंपनियों का विज्ञापन होता है. यह वैल्यू, सेवा देने वाली कंपनियों की एक सूची होनी चाहिए. इसमें सेवा देने वाली कंपनियों की सूची या अलग-अलग कंपनियों की जानकारी शामिल हो सकती है, लेकिन दोनों नहीं. उदाहरण के लिए, `[[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`	default = [] इस एट्रिब्यूट की मदद से, इस आसपेक्ट को दूसरे आसपेक्ट की जांच करने की अनुमति मिलती है. यह वैल्यू, सेवा देने वाली कंपनियों की एक सूची होनी चाहिए. इसमें सेवा देने वाली कंपनियों की सूची या अलग-अलग कंपनियों की जानकारी शामिल हो सकती है, लेकिन दोनों नहीं. उदाहरण के लिए, `[[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`	default = [] सेवा देने वाली उन कंपनियों की सूची जिन्हें लागू करने वाले फ़ंक्शन को दिखाना चाहिए. अगर लागू करने वाले फ़ंक्शन में, यहां दी गई सूची में शामिल किसी भी तरह के प्रोवाइडर को रिटर्न वैल्यू से हटा दिया जाता है, तो यह गड़बड़ी होती है. हालांकि, लागू करने वाले फ़ंक्शन की रिटर्न वैल्यू में ऐसे अन्य प्रोवाइडर भी मिल सकते हैं जो यहां नहीं दिए गए हैं. सूची का हर एलिमेंट, `provider()` से मिला `*Info` ऑब्जेक्ट होता है. हालांकि, लेगसी प्रोवाइडर को उसके स्ट्रिंग नाम से दिखाया जाता है.
`requires`	`sequence of Aspects`; default = [] इस आसपेक्ट से पहले, लागू किए जाने वाले आसपेक्ट की सूची.
`fragments`	`sequence of strings`; default = [] उन कॉन्फ़िगरेशन फ़्रैगमेंट के नामों की सूची जिनकी टारगेट कॉन्फ़िगरेशन में, आसपेक्ट को ज़रूरत होती है.
`host_fragments`	`sequence of strings`; default = [] कॉन्फ़िगरेशन के उन फ़्रैगमेंट के नामों की सूची जिनकी होस्ट कॉन्फ़िगरेशन में, आसपेक्ट को ज़रूरत होती है.
`toolchains`	`sequence`; डिफ़ॉल्ट = [] अगर सेट किया जाता है, तो इस नियम के लिए ज़रूरी टूल चेन का सेट. इस सूची में, स्ट्रिंग, लेबल या StarlarkToolchainTypeApi ऑब्जेक्ट, किसी भी कॉम्बिनेशन में शामिल हो सकते हैं. मौजूदा प्लैटफ़ॉर्म की जांच करके टूल चेन ढूंढे जाएंगे और `ctx.toolchain` के ज़रिए नियम लागू करने के लिए उपलब्ध कराए जाएंगे.
`incompatible_use_toolchain_transition`	default = False इस्तेमाल नहीं किया जाता. इसे हटा दिया जाना चाहिए.
`doc`	default = '' दस्तावेज़ जनरेट करने वाले टूल से निकाले जा सकने वाले आसपेक्ट की जानकारी.
`apply_to_generating_rules`	default = False अगर यह 'सही' है, तो आउटपुट फ़ाइल पर लागू किए जाने पर, आसपेक्ट उसकी बजाय आउटपुट फ़ाइल को जनरेट करने वाले नियम पर लागू होगा. उदाहरण के लिए, मान लें कि कोई आसपेक्ट, एट्रिब्यूट `deps` के ज़रिए ट्रांज़िटिव तौर पर प्रसारित होता है और इसे टारगेट `alpha` पर लागू किया जाता है. मान लें कि `alpha` में `deps = [':beta_output']` है, जहां `beta_output`, टारगेट `beta` का तय किया गया आउटपुट है. मान लें कि `beta` में, अपने एक `deps` के तौर पर टारगेट `charlie` है. अगर आसपेक्ट के लिए `apply_to_generating_rules=True` है, तो आसपेक्ट `alpha`, `beta`, और `charlie` के ज़रिए प्रसारित होगा. अगर यह False है, तो आसपेक्ट सिर्फ़ `alpha` पर प्रसारित होगा. डिफ़ॉल्ट रूप से, यह 'गलत' पर सेट होता है.
`exec_compatible_with`	`sequence of strings`; default = [] यह, एक्ज़ीक्यूशन प्लैटफ़ॉर्म पर मौजूद उन पाबंदियों की सूची है जो इस आसपेक्ट के सभी इंस्टेंस पर लागू होती हैं.
`exec_groups`	`dict; or None`; डिफ़ॉल्ट = None एक डिक्शनरी, जिसमें एक्ज़ीक्यूशन ग्रुप का नाम (स्ट्रिंग) `exec_group` में बदला जाता है. अगर यह सेट है, तो आसपेक्ट, एक ही इंस्टेंस में कई एक्ज़ीक्यूशन प्लैटफ़ॉर्म पर ऐक्शन चला सकता है. ज़्यादा जानकारी के लिए, एक्ज़ीक्यूशन ग्रुप का दस्तावेज़ देखें.

bazel_dep

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

यह Bazel के किसी दूसरे मॉड्यूल पर सीधी निर्भरता का एलान करता है.

पैरामीटर

पैरामीटर	ब्यौरा
`name`	ज़रूरी है यह उस मॉड्यूल का नाम है जिसे सीधे तौर पर डिपेंडेंसी के तौर पर जोड़ा जाना है.
`version`	default = '' The version of the module to be added as a direct dependency.
`max_compatibility_level`	default = -1 यह मॉड्यूल के लिए, ज़्यादा से ज़्यादा `compatibility_level` है. इसे सीधे तौर पर डिपेंडेंसी के तौर पर जोड़ा जा सकता है. मॉड्यूल के वर्शन से, कम से कम compatibility_level का पता चलता है. अगर इस एट्रिब्यूट की वैल्यू नहीं दी गई है, तो ज़्यादा से ज़्यादा compatibility_level का भी पता चलता है.
`repo_name`	default = '' The name of the external repo representing this dependency. यह मॉड्यूल का डिफ़ॉल्ट नाम होता है.
`dev_dependency`	default = False अगर यह सही पर सेट है, तो इस डिपेंडेंसी को अनदेखा कर दिया जाएगा. ऐसा तब होगा, जब मौजूदा मॉड्यूल रूट मॉड्यूल न हो या `--ignore_dev_dependency` चालू हो.

बाइंड

None bind(name, actual=None)

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

इस एनोटेशन का इस्तेमाल करके, //external पैकेज में किसी टारगेट को उपनाम दिया जाता है.

पैरामीटर

पैरामीटर	ब्यौरा
`name`	ज़रूरी है '//external' के तहत मौजूद लेबल, जिसका इस्तेमाल उपनाम के तौर पर किया जाएगा
`actual`	`string; or None`; default = None The real label to be aliased

बूल

bool bool(x=False)

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

पैरामीटर

पैरामीटर	ब्यौरा
`x`	default = False यह वैरिएबल, कन्वर्ज़न के लिए होता है.

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 पैरामीटर, depset के डायरेक्ट एलिमेंट की सूची है. वहीं, transitive पैरामीटर, उन depset की सूची है जिनके एलिमेंट, बनाए गए depset के इनडायरेक्ट एलिमेंट बन जाते हैं. depset को सूची में बदलने पर, एलिमेंट किस क्रम में दिखाए जाते हैं, यह order पैरामीटर से तय होता है. ज़्यादा जानकारी के लिए, Depsets की खास जानकारी देखें.

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

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

इसके अलावा, फ़िलहाल एलिमेंट में बदलाव करने की गुंजाइश नहीं होनी चाहिए. हालांकि, आने वाले समय में इस पाबंदी को हटा दिया जाएगा.

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

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

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

पैरामीटर

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

dict

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

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

पैरामीटर

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

dir

list dir(x)

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

पैरामीटर

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

गिनती करना

list enumerate(list, start=0)

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

enumerate([24, 21, 84]) == [(0, 24), (1, 21), (2, 84)]

पैरामीटर

पैरामीटर	ब्यौरा
`list`	ज़रूरी है इनपुट क्रम.
`start`	default = 0 स्टार्ट इंडेक्स.

exec_group

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

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

पैरामीटर

पैरामीटर	ब्यौरा
`toolchains`	`sequence`; default = [] यह टूल चेन का वह सेट होता है जो इस एक्ज़ीक्यूशन ग्रुप के लिए ज़रूरी होता है. इस सूची में, स्ट्रिंग, लेबल या StarlarkToolchainTypeApi ऑब्जेक्ट, किसी भी कॉम्बिनेशन में शामिल हो सकते हैं.
`exec_compatible_with`	`sequence of strings`; default = [] यह, एक्ज़ीक्यूशन प्लैटफ़ॉर्म पर पाबंदियों की सूची होती है.
`copy_from_rule`	default = False अगर इसे 'सही है' पर सेट किया जाता है, तो यह एक्ज़ीक्यूशन ग्रुप, उस नियम की टूलचेन और शर्तों को इनहेरिट करता है जिससे यह ग्रुप अटैच है. किसी अन्य स्ट्रिंग पर सेट करने पर, गड़बड़ी दिखेगी.

फ़ेल

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

इससे गड़बड़ी होने पर, स्क्रिप्ट नहीं चल पाती.

पैरामीटर

पैरामीटर	ब्यौरा
`msg`	default = None Deprecated: use positional arguments instead. यह आर्ग्युमेंट, लीडिंग पोज़ीशनल आर्ग्युमेंट की तरह काम करता है.
`attr`	`string; or None`; default = None अब इस्तेमाल नहीं किया जा सकता. इस स्ट्रिंग को गड़बड़ी के मैसेज में जोड़ने के लिए, एक वैकल्पिक प्रीफ़िक्स बनाता है.
`args`	ज़रूरी है यह वैल्यू की एक सूची है. इसे debugPrint (जो डिफ़ॉल्ट रूप से str के बराबर होता है) का इस्तेमाल करके फ़ॉर्मैट किया जाता है. साथ ही, इसे खाली जगहों की मदद से जोड़ा जाता है. यह सूची, गड़बड़ी के मैसेज में दिखती है.

फ़्लोट

float float(x=unbound)

x को फ़्लोट वैल्यू के तौर पर दिखाता है.

अगर x पहले से ही फ़्लोट है, तो float इसे बिना किसी बदलाव के दिखाता है.
अगर x एक बूल है, तो float, सही के लिए 1.0 और गलत के लिए 0.0 दिखाता है.
अगर x एक पूर्णांक है, तो float, x के सबसे करीब फ़ाइनाइट फ़्लोटिंग-पॉइंट वैल्यू दिखाता है. अगर मैग्नीट्यूड बहुत बड़ा है, तो गड़बड़ी दिखाता है.
अगर x एक स्ट्रिंग है, तो यह एक मान्य फ़्लोटिंग-पॉइंट लिटरल होना चाहिए. इसके अलावा, यह NaN, Inf या Infinity के बराबर होना चाहिए. हालांकि, इसमें केस का अंतर हो सकता है. साथ ही, इसके पहले + या - का चिह्न होना ज़रूरी नहीं है.

कोई अन्य वैल्यू डालने पर गड़बड़ी होती है. कोई आर्ग्युमेंट न होने पर, float() 0.0 दिखाता है.

पैरामीटर

पैरामीटर	ब्यौरा
`x`	default = unbound बदलने के लिए वैल्यू.

getattr

unknown getattr(x, name, default=unbound)

अगर दिए गए नाम का स्ट्रक्चर फ़ील्ड मौजूद है, तो उसे दिखाता है. अगर ऐसा नहीं होता है, तो यह default (अगर तय किया गया है) दिखाता है या गड़बड़ी का मैसेज दिखाता है. getattr(x, "foobar"), x.foobar के बराबर है.

getattr(ctx.attr, "myattr")
getattr(ctx.attr, "myattr", "mydefault")

पैरामीटर

पैरामीटर	ब्यौरा
`x`	ज़रूरी है वह स्ट्रक्चर जिसका एट्रिब्यूट ऐक्सेस किया गया है.
`name`	ज़रूरी है स्ट्रक्चर एट्रिब्यूट का नाम.
`default`	default = unbound अगर स्ट्रक्चर में दिए गए नाम का एट्रिब्यूट नहीं है, तो डिफ़ॉल्ट वैल्यू दिखाई जाएगी.

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`; default = [] यह इस मॉड्यूल के लिए लागू की जाने वाली पैच फ़ाइलों की सूची है. पैच फ़ाइलें, टॉप लेवल प्रोजेक्ट के सोर्स ट्री में मौजूद होनी चाहिए. ये सूची में दिए गए क्रम के हिसाब से लागू होते हैं.
`patch_cmds`	`Iterable of strings`; default = [] पैच लागू होने के बाद, Linux/Macos पर लागू होने वाले बैश कमांड का क्रम.
`patch_strip`	default = 0 यह Unix पैच के --strip तर्क के जैसा ही है.

hasattr

bool hasattr(x, name)

अगर ऑब्जेक्ट x में, दिए गए name का एट्रिब्यूट या तरीका मौजूद है, तो यह फ़ंक्शन True दिखाता है. अगर ऐसा नहीं है, तो False दिखाता है. उदाहरण:

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

पैरामीटर	ब्यौरा
`x`	ज़रूरी है बदलाव के लिए स्ट्रिंग.
`base`	default = unbound यह वह आधार है जिसका इस्तेमाल स्ट्रिंग वैल्यू को समझने के लिए किया जाता है. इसकी डिफ़ॉल्ट वैल्यू 10 होती है. यह 2 से 36 (दोनों शामिल हैं) के बीच होना चाहिए. इसके अलावा, अगर `x` को पूर्णांक लिटरल के तौर पर पहचानना है, तो इसे 0 पर सेट करें. अगर वैल्यू स्ट्रिंग नहीं है, तो यह पैरामीटर नहीं दिया जाना चाहिए.

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 की तुलना string से करना) या कोई आर्ग्युमेंट नहीं दिया गया है, तो गड़बड़ी होगी.

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`	default = '' मॉड्यूल का नाम. इसे सिर्फ़ तब हटाया जा सकता है, जब यह मॉड्यूल रूट मॉड्यूल हो. इसका मतलब है कि अगर यह किसी दूसरे मॉड्यूल पर निर्भर नहीं है. मॉड्यूल का मान्य नाम ऐसा होना चाहिए: 1) इसमें सिर्फ़ अंग्रेज़ी के छोटे अक्षर (a-z), अंक (0-9), बिंदु (.), हाइफ़न (-), और अंडरस्कोर (_) शामिल हों; 2) इसकी शुरुआत अंग्रेज़ी के छोटे अक्षर से हो; 3) इसका आखिरी वर्ण अंग्रेज़ी का छोटा अक्षर या अंक हो.
`version`	default = '' मॉड्यूल का वर्शन. इसे सिर्फ़ तब हटाया जा सकता है, जब यह मॉड्यूल रूट मॉड्यूल हो. इसका मतलब है कि अगर यह किसी दूसरे मॉड्यूल पर निर्भर नहीं है.
`compatibility_level`	default = 0 मॉड्यूल का कंपैटिबिलिटी लेवल. जब भी कोई ऐसा बदलाव किया जाता है जो पुराने सिस्टम के साथ काम नहीं करता है, तब इसे बदला जाना चाहिए. यह SemVer के हिसाब से मॉड्यूल का "मेजर वर्शन" है. हालांकि, यह वर्शन स्ट्रिंग में एम्बेड नहीं किया गया है, बल्कि एक अलग फ़ील्ड के तौर पर मौजूद है. अलग-अलग कंपैटबिलिटी लेवल वाले मॉड्यूल, वर्शन रिज़ॉल्यूशन में इस तरह हिस्सा लेते हैं जैसे वे अलग-अलग नाम वाले मॉड्यूल हों. हालांकि, फ़ाइनल डिपेंडेंसी ग्राफ़ में एक ही नाम वाले, लेकिन अलग-अलग कंपैटबिलिटी लेवल वाले कई मॉड्यूल नहीं हो सकते. ऐसा तब तक नहीं हो सकता, जब तक `multiple_version_override` लागू न हो. ज़्यादा जानकारी के लिए, यहां देखें.
`repo_name`	default = '' यह मॉड्यूल को दिखाने वाली रिपॉज़िटरी का नाम है. यह नाम मॉड्यूल को दिखता है. डिफ़ॉल्ट रूप से, रेपो का नाम मॉड्यूल का नाम होता है. इसे उन प्रोजेक्ट के लिए तय किया जा सकता है जो अपने लिए ऐसे रेपो के नाम का इस्तेमाल कर रहे हैं जो उसके मॉड्यूल के नाम से अलग है. इससे माइग्रेशन की प्रोसेस आसान हो जाती है.
`bazel_compatibility`	`Iterable of strings`; default = [] 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`	default = '' मॉड्यूल एक्सटेंशन की जानकारी, जिसे दस्तावेज़ जनरेट करने वाले टूल से निकाला जा सकता है.
`environ`	`sequence of strings`; default = [] इससे, एनवायरमेंट वैरिएबल की वह सूची मिलती है जिस पर यह मॉड्यूल एक्सटेंशन निर्भर करता है. अगर उस सूची में कोई एनवायरमेंट वैरिएबल बदलता है, तो एक्सटेंशन का फिर से आकलन किया जाएगा.
`os_dependent`	default = False इससे पता चलता है कि यह एक्सटेंशन ओएस पर निर्भर करता है या नहीं
`arch_dependent`	default = False इससे पता चलता है कि यह एक्सटेंशन आर्किटेक्चर पर निर्भर करता है या नहीं

multiple_version_override

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

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

पैरामीटर

पैरामीटर	ब्यौरा
`module_name`	ज़रूरी है यह Bazel मॉड्यूल डिपेंडेंसी का नाम है, जिस पर इस ओवरराइड को लागू करना है.
`versions`	`Iterable of strings`; ज़रूरी है इससे साफ़ तौर पर यह पता चलता है कि कौनसे वर्शन एक साथ मौजूद हो सकते हैं. ये वर्शन, डिपेंडेंसी ग्राफ़ में पहले से मौजूद होने चाहिए. इस मॉड्यूल पर निर्भरता रखने वाले मॉड्यूल को, उसी कंपैटिबिलिटी लेवल पर, अनुमति वाले सबसे नए वर्शन में "अपग्रेड" कर दिया जाएगा. वहीं, जिन मॉड्यूल का वर्शन, उसी कंपैटिबिलिटी लेवल पर अनुमति वाले किसी भी वर्शन से नया है उनमें गड़बड़ी होगी.
`registry`	default = '' Overrides the registry for this module; instead of finding this module from the default list of registries, the given registry should be used.

प्रिंट करें

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

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

अगर init नहीं दिया गया है, तो यह Provider की कॉल की जा सकने वाली वैल्यू दिखाता है.

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

पैरामीटर

पैरामीटर ब्यौरा

doc default = ''
सेवा देने वाली कंपनी की जानकारी, जिसे दस्तावेज़ जनरेट करने वाले टूल से निकाला जा सकता है.

पैरामीटर	ब्यौरा
`doc`	default = '' सेवा देने वाली कंपनी की जानकारी, जिसे दस्तावेज़ जनरेट करने वाले टूल से निकाला जा सकता है.
`fields`	`sequence of strings; or dict; or None`; डिफ़ॉल्ट = None अगर यह तय होता है, तो अनुमति वाले फ़ील्ड के सेट पर पाबंदी लगा दी जाती है. इन वैल्यू का इस्तेमाल किया जा सकता है: फ़ील्ड की सूची: provider(fields = ['a', 'b']) डिक्शनरी फ़ील्ड का नाम -> दस्तावेज़: provider( fields = { 'a' : 'Documentation for a', 'b' : 'Documentation for b' }) सभी फ़ील्ड में जानकारी देना ज़रूरी नहीं है.
`init`	`callable; or None`; default = None प्रोवाइडर के फ़ील्ड की वैल्यू को पहले से प्रोसेस करने और इंस्टैंशिएशन के दौरान उनकी पुष्टि करने के लिए, एक वैकल्पिक कॉलबैक. अगर `init` दिया गया है, तो `provider()` दो एलिमेंट का ट्यूपल दिखाता है: सामान्य प्रोवाइडर सिंबल और रॉ कन्स्ट्रक्टर. यहां सटीक जानकारी दी गई है. आसान शब्दों में जानकारी और इस्तेमाल के उदाहरणों के लिए, नियम (प्रोवाइडर का कस्टम तरीके से शुरू होना) देखें. मान लें कि `P`, सेवा देने वाली कंपनी का सिंबल है जिसे `provider()` को कॉल करके बनाया गया है. कॉन्सेप्ट के हिसाब से, `P` का एक इंस्टेंस जनरेट करने के लिए, डिफ़ॉल्ट कंस्ट्रक्टर फ़ंक्शन `c(args, kwargs)` को कॉल किया जाता है. यह फ़ंक्शन ये काम करता है: अगर `args` खाली नहीं है, तो गड़बड़ी होती है. अगर `provider()` को कॉल करते समय `fields` पैरामीटर तय किया गया था और `kwargs` में कोई ऐसा बटन है जो `fields` में मौजूद नहीं था, तो गड़बड़ी होती है. इसके अलावा, `c` एक नया इंस्टेंस दिखाता है. इसमें `kwargs` में मौजूद हर `k: v` एंट्री के लिए, `k` नाम का एक फ़ील्ड होता है. इसकी वैल्यू `v` होती है. अगर `init` को कॉलबैक न किया गया हो, तो सिंबल `P` को कॉल करने पर, डिफ़ॉल्ट कंस्ट्रक्टर फ़ंक्शन `c` को कॉल किया जाता है. दूसरे शब्दों में, `P(args, *kwargs)` `c(args, *kwargs)` दिखाता है. उदाहरण के लिए, MyInfo = provider() m = MyInfo(foo = 1) , इसे सीधे बना देगा, ताकि `m` को `m.foo == 1` वाला `MyInfo` इंस्टेंस बनाया जा सके. हालांकि, अगर `init` की जानकारी दी गई है, तो कॉल `P(args, *kwargs)` ये चरण पूरे करेगा: कॉलबैक को `init(args, kwargs)` के तौर पर लागू किया जाता है. इसका मतलब है कि इसमें वही पोज़ीशनल और कीवर्ड आर्ग्युमेंट होते हैं जो `P` को पास किए गए थे. `init` की रिटर्न वैल्यू, `d` डिक्शनरी होनी चाहिए. इसकी कुंजियां, फ़ील्ड के नाम वाली स्ट्रिंग होती हैं. अगर ऐसा नहीं होता है, तो गड़बड़ी होती है. `P` का एक नया इंस्टेंस जनरेट होता है. यह ऐसे होता है जैसे `d` की एंट्री को कीवर्ड आर्ग्युमेंट के तौर पर इस्तेमाल करके, डिफ़ॉल्ट कंस्ट्रक्टर को कॉल किया गया हो. जैसे, `c(d)` में दिखाया गया है. ध्यान दें: ऊपर दिए गए चरणों का मतलब है कि अगर `args` या `kwargs`, `init` के हस्ताक्षर से मेल नहीं खाता है या `init` के मुख्य हिस्से का आकलन नहीं किया जा सका (शायद जान-बूझकर `fail()` को कॉल करके) या अगर `init` की रिटर्न वैल्यू, अनुमानित स्कीमा वाला शब्दकोश नहीं है, तो गड़बड़ी होती है. इस तरह, `init` कॉलबैक, सामान्य प्रोवाइडर कंस्ट्रक्शन को सामान्य बनाता है. इसके लिए, यह पोज़िशनल आर्ग्युमेंट और प्रीप्रोसेसिंग और पुष्टि करने के लिए मनमुताबिक लॉजिक का इस्तेमाल करने की अनुमति देता है. इससे, अनुमति वाले `fields` की सूची को बायपास* नहीं किया जा सकता. `init` तय करने पर, `provider()` की रिटर्न वैल्यू ट्यूपल `(P, r)` बन जाती है. यहां `r`, रॉ कंस्ट्रक्टर है. असल में, `r` का काम ठीक वैसा ही होता है जैसा ऊपर बताए गए डिफ़ॉल्ट कन्स्ट्रक्टर फ़ंक्शन `c` का होता है. आम तौर पर, `r` ऐसे वैरिएबल से बंधा होता है जिसका नाम अंडरस्कोर से शुरू होता है, ताकि सिर्फ़ मौजूदा .bzl फ़ाइल का ही सीधे तौर पर ऐक्सेस हो: MyInfo, _new_myinfo = provider(init = ...)

fields

sequence of strings; or dict; or None; डिफ़ॉल्ट = None
अगर यह तय होता है, तो अनुमति वाले फ़ील्ड के सेट पर पाबंदी लगा दी जाती है.
इन वैल्यू का इस्तेमाल किया जा सकता है:

फ़ील्ड की सूची:
```
provider(fields = ['a', 'b'])
```
डिक्शनरी फ़ील्ड का नाम -> दस्तावेज़:
```
provider(
       fields = { 'a' : 'Documentation for a', 'b' : 'Documentation for b' })
```

सभी फ़ील्ड में जानकारी देना ज़रूरी नहीं है.

init

callable; or None; default = None
प्रोवाइडर के फ़ील्ड की वैल्यू को पहले से प्रोसेस करने और इंस्टैंशिएशन के दौरान उनकी पुष्टि करने के लिए, एक वैकल्पिक कॉलबैक. अगर init दिया गया है, तो provider() दो एलिमेंट का ट्यूपल दिखाता है: सामान्य प्रोवाइडर सिंबल और रॉ कन्स्ट्रक्टर.

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

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

अगर args खाली नहीं है, तो गड़बड़ी होती है.
अगर provider() को कॉल करते समय fields पैरामीटर तय किया गया था और kwargs में कोई ऐसा बटन है जो fields में मौजूद नहीं था, तो गड़बड़ी होती है.
इसके अलावा, c एक नया इंस्टेंस दिखाता है. इसमें kwargs में मौजूद हर k: v एंट्री के लिए, k नाम का एक फ़ील्ड होता है. इसकी वैल्यू v होती है.

अगर init को कॉलबैक न किया गया हो, तो सिंबल P को कॉल करने पर, डिफ़ॉल्ट कंस्ट्रक्टर फ़ंक्शन c को कॉल किया जाता है. दूसरे शब्दों में, P(*args, **kwargs) c(*args, **kwargs) दिखाता है. उदाहरण के लिए,

MyInfo = provider()
m = MyInfo(foo = 1)

, इसे सीधे बना देगा, ताकि m को m.foo == 1 वाला MyInfo इंस्टेंस बनाया जा सके.

हालांकि, अगर init की जानकारी दी गई है, तो कॉल P(*args, **kwargs) ये चरण पूरे करेगा:

कॉलबैक को init(*args, **kwargs) के तौर पर लागू किया जाता है. इसका मतलब है कि इसमें वही पोज़ीशनल और कीवर्ड आर्ग्युमेंट होते हैं जो P को पास किए गए थे.
init की रिटर्न वैल्यू, d डिक्शनरी होनी चाहिए. इसकी कुंजियां, फ़ील्ड के नाम वाली स्ट्रिंग होती हैं. अगर ऐसा नहीं होता है, तो गड़बड़ी होती है.
P का एक नया इंस्टेंस जनरेट होता है. यह ऐसे होता है जैसे d की एंट्री को कीवर्ड आर्ग्युमेंट के तौर पर इस्तेमाल करके, डिफ़ॉल्ट कंस्ट्रक्टर को कॉल किया गया हो. जैसे, 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)

इस फ़ंक्शन से एक ऐसी सूची बनती है जिसमें आइटम 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`; default = None नतीजे के तौर पर मिली सूची में शामिल नहीं किए जाने वाले पहले आइटम का इंडेक्स; सूची जनरेट करने की प्रोसेस, `stop` तक पहुंचने से पहले ही रुक जाती है.
`step`	default = 1 इंक्रीमेंट (डिफ़ॉल्ट वैल्यू 1 है). यह नेगेटिव हो सकता है.

register_execution_platforms()

None register_execution_platforms(*platform_labels)

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

पैरामीटर

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

register_execution_platforms(dev_dependency)

None register_execution_platforms(dev_dependency=False, *platform_labels)

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

पैरामीटर

पैरामीटर	ब्यौरा
`dev_dependency`	default = False If true, the execution platforms will not be registered if the current module is not the root module or `--ignore_dev_dependency` is enabled.
`platform_labels`	`sequence of strings`; required रजिस्टर करने के लिए प्लैटफ़ॉर्म के लेबल.

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`	default = False If true, the toolchains will not be registered if the current module is not the root module or `--ignore_dev_dependency` is enabled.
`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`; डिफ़ॉल्ट = None नियम के सभी एट्रिब्यूट की जानकारी देने वाली डिक्शनरी. यह किसी एट्रिब्यूट के नाम को एट्रिब्यूट ऑब्जेक्ट से मैप करता है. attr मॉड्यूल देखें. `_` से शुरू होने वाले एट्रिब्यूट निजी होते हैं. इनका इस्तेमाल, किसी फ़ाइल में लेबल पर लागू होने वाली डिपेंडेंसी जोड़ने के लिए किया जा सकता है. डेटाबेस का नियम, जनरेट किए गए आर्टफ़ैक्ट पर निर्भर नहीं हो सकता. `name` एट्रिब्यूट अपने-आप जुड़ जाता है और इसकी वैल्यू सबमिट करने की ज़रूरत नहीं होती.
`local`	default = False यह बताते हैं कि यह नियम, सबकुछ स्थानीय सिस्टम से फ़ेच करता है और हर फ़ेच के बाद, इसका फिर से आकलन किया जाना चाहिए.
`environ`	`sequence of strings`; default = [] इससे, एनवायरमेंट वैरिएबल की सूची मिलती है, जिस पर यह डेटाबेस नियम निर्भर करता है. अगर उस सूची में कोई एनवायरमेंट वैरिएबल बदलता है, तो डेटाबेस को फिर से फ़ेच किया जाएगा.
`configure`	default = False यह बताते हैं कि डेटाबेस, कॉन्फ़िगरेशन के मकसद से सिस्टम की जांच करता है
`remotable`	default = False एक्सपेरिमेंट के तौर पर उपलब्ध है. यह पैरामीटर एक्सपेरिमेंट के तौर पर उपलब्ध है. इसमें कभी भी बदलाव किया जा सकता है. कृपया इसके भरोसे न रहें. इसे एक्सपेरिमेंट के तौर पर चालू किया जा सकता है. इसके लिए, `---experimental_repo_remote_exec` को सेट करना होगा. यह रिमोट एक्ज़ीक्यूशन के साथ काम करता है
`doc`	default = '' डेटाबेस के नियम की जानकारी, जिसे दस्तावेज़ जनरेट करने वाले टूल से निकाला जा सकता है.

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`	default = False यह नियम, जांच के लिए बनाया गया है या नहीं. इसका मतलब है कि क्या यह `blaze test` निर्देश का विषय हो सकता है. सभी टेस्ट नियमों को अपने-आप एक्ज़ीक्यूटेबल माना जाता है. किसी टेस्ट नियम के लिए, `executable = True` को साफ़ तौर पर सेट करना ज़रूरी नहीं है और ऐसा करने का सुझाव भी नहीं दिया जाता. ज़्यादा जानकारी के लिए, नियमों का पेज देखें.
`attrs`	`dict; or None`; default = None नियम के सभी एट्रिब्यूट की जानकारी देने वाली डिक्शनरी. यह किसी एट्रिब्यूट के नाम को एट्रिब्यूट ऑब्जेक्ट से मैप करता है. attr मॉड्यूल देखें. `_` से शुरू होने वाले एट्रिब्यूट निजी होते हैं. इनका इस्तेमाल, किसी लेबल पर लागू होने वाली डिपेंडेंसी को जोड़ने के लिए किया जा सकता है. `name` एट्रिब्यूट अपने-आप जुड़ जाता है और इसकी वैल्यू सबमिट करने की ज़रूरत नहीं होती. `visibility`, `deprecation`, `tags`, `testonly`, और `features` एट्रिब्यूट अपने-आप जुड़ जाते हैं और इन्हें बदला नहीं जा सकता. ज़्यादातर नियमों के लिए, कुछ ही एट्रिब्यूट की ज़रूरत होती है. मेमोरी के इस्तेमाल को सीमित करने के लिए, नियम फ़ंक्शन, attrs के साइज़ पर सीमा लगाता है.
`outputs`	`dict; or None; or function`; default = None Deprecated. यह पैरामीटर अब काम नहीं करता. इसे जल्द ही हटा दिया जाएगा. कृपया इसके भरोसे न रहें. `---incompatible_no_rule_outputs_param` के साथ, यह बंद है. इस फ़्लैग का इस्तेमाल करके पुष्टि करें कि आपके कोड, इस जल्द ही हटाए जाने वाले फ़ैसले से कोई दिक्कत नहीं होगी. इस पैरामीटर का इस्तेमाल बंद कर दिया गया है. इसके बजाय, `OutputGroupInfo` या `attr.output` का इस्तेमाल करने के लिए, नियमों को माइग्रेट करें. पहले से तय किए गए आउटपुट को तय करने के लिए स्कीमा. `output` और `output_list` एट्रिब्यूट के उलट, उपयोगकर्ता इन फ़ाइलों के लिए लेबल तय नहीं करता. पहले से बताए गए आउटपुट के बारे में ज़्यादा जानने के लिए, नियमों का पेज देखें. इस आर्ग्युमेंट की वैल्यू, कोई डिक्शनरी या डिक्शनरी बनाने वाली कोई कॉलबैक फ़ंक्शन होती है. कॉलबैक, कैलकुलेट किए गए डिपेंडेंसी एट्रिब्यूट की तरह ही काम करता है: फ़ंक्शन के पैरामीटर के नाम, नियम के एट्रिब्यूट से मैच किए जाते हैं. उदाहरण के लिए, अगर आपने परिभाषा `def _my_func(srcs, deps): ...` के साथ `outputs = _my_func` पास किया है, तो फ़ंक्शन के पास `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"` में dirname, `a` है और basename, `b.c` है. आम तौर पर, बदले जाने वाले वैल्यू के लिए सबसे ज़्यादा इस्तेमाल किया जाने वाला प्लेसहोल्डर `"%{name}"` होता है. उदाहरण के लिए, "foo" नाम के टारगेट के लिए, आउटपुट dict `{"bin": "%{name}.exe"}`, `foo.exe` नाम के एक आउटपुट को पहले से तय करती है. इसे लागू करने वाले फ़ंक्शन में `ctx.outputs.bin` के तौर पर ऐक्सेस किया जा सकता है.
`executable`	default = False यह तय करता है कि इस नियम को लागू किया जा सकता है या नहीं. इसका मतलब है कि क्या यह `blaze run` निर्देश का विषय हो सकता है. ज़्यादा जानकारी के लिए, नियमों का पेज देखें.
`output_to_genfiles`	default = False अगर यह 'सही' है, तो फ़ाइलें bin डायरेक्ट्री के बजाय genfiles डायरेक्ट्री में जनरेट होंगी. अगर आपको मौजूदा नियमों के साथ काम करने के लिए इसकी ज़रूरत नहीं है (जैसे, C++ के लिए हेडर फ़ाइलें जनरेट करते समय), तो इस फ़्लैग को सेट न करें.
`fragments`	`sequence of strings`; default = [] उन कॉन्फ़िगरेशन फ़्रैगमेंट के नामों की सूची जिनकी टारगेट कॉन्फ़िगरेशन में नियम के लिए ज़रूरत होती है.
`host_fragments`	`sequence of strings`; default = [] उन कॉन्फ़िगरेशन फ़्रैगमेंट के नामों की सूची जिनकी ज़रूरत होस्ट कॉन्फ़िगरेशन में नियम के लिए होती है.
`_skylark_testable`	default = False (Experimental) अगर यह वैल्यू सही है, तो यह नियम, उन नियमों के लिए अपनी कार्रवाइयां दिखाएगा जो Actions प्रोवाइडर के ज़रिए इस पर निर्भर करते हैं. ctx.created_actions() को कॉल करके, नियम के लिए भी प्रोवाइडर उपलब्ध कराया जा सकता है. इसका इस्तेमाल सिर्फ़ Starlark नियमों के विश्लेषण के समय के व्यवहार की जांच करने के लिए किया जाना चाहिए. ऐसा हो सकता है कि आने वाले समय में, इस फ़्लैग को हटा दिया जाए.
`toolchains`	`sequence`; डिफ़ॉल्ट = [] अगर सेट किया जाता है, तो इस नियम के लिए ज़रूरी टूल चेन का सेट. इस सूची में, स्ट्रिंग, लेबल या StarlarkToolchainTypeApi ऑब्जेक्ट, किसी भी कॉम्बिनेशन में शामिल हो सकते हैं. मौजूदा प्लैटफ़ॉर्म की जांच करके टूल चेन ढूंढे जाएंगे और `ctx.toolchain` के ज़रिए नियम लागू करने के लिए उपलब्ध कराए जाएंगे.
`incompatible_use_toolchain_transition`	default = False इस्तेमाल नहीं किया जाता. इसे हटा दिया जाना चाहिए.
`doc`	default = '' नियम की जानकारी, जिसे दस्तावेज़ जनरेट करने वाले टूल से निकाला जा सकता है.
`provides`	default = [] सेवा देने वाली उन कंपनियों की सूची जिन्हें लागू करने वाले फ़ंक्शन को दिखाना चाहिए. अगर लागू करने वाले फ़ंक्शन में, यहां दी गई सूची में शामिल किसी भी तरह के प्रोवाइडर को रिटर्न वैल्यू से हटा दिया जाता है, तो यह गड़बड़ी होती है. हालांकि, लागू करने वाले फ़ंक्शन की रिटर्न वैल्यू में ऐसे अन्य प्रोवाइडर भी मिल सकते हैं जो यहां नहीं दिए गए हैं. सूची का हर एलिमेंट, `provider()` से मिला `*Info` ऑब्जेक्ट होता है. हालांकि, लेगसी प्रोवाइडर को उसके स्ट्रिंग नाम से दिखाया जाता है.
`exec_compatible_with`	`sequence of strings`; default = [] यह, एक्ज़ीक्यूशन प्लैटफ़ॉर्म पर मौजूद उन पाबंदियों की सूची है जो इस नियम टाइप के सभी टारगेट पर लागू होती हैं.
`analysis_test`	default = False अगर यह सही है, तो इस नियम को विश्लेषण की जांच के तौर पर माना जाता है. ध्यान दें: विश्लेषण के टेस्ट के नियमों को मुख्य तौर पर, Starlark की कोर लाइब्रेरी में उपलब्ध कराए गए इन्फ़्रास्ट्रक्चर का इस्तेमाल करके तय किया जाता है. दिशा-निर्देशों के लिए, टेस्टिंग देखें. अगर किसी नियम को विश्लेषण टेस्ट के नियम के तौर पर तय किया जाता है, तो उसे अपने एट्रिब्यूट पर analysis_test_transition का इस्तेमाल करके तय किए गए कॉन्फ़िगरेशन ट्रांज़िशन का इस्तेमाल करने की अनुमति मिल जाती है. हालांकि, इस पर कुछ पाबंदियां लागू होती हैं: इस नियम के टारगेट में, ट्रांज़िटिव डिपेंडेंसी की संख्या सीमित होती है. इस नियम को टेस्ट नियम माना जाता है. ऐसा तब होता है, जब `test=True` सेट किया गया हो. इससे `test` एट्रिब्यूट की वैल्यू बदल जाएगी ऐसा हो सकता है कि नियम लागू करने वाला फ़ंक्शन, कार्रवाइयों को रजिस्टर न करे. इसके बजाय, इसे AnalysisTestResultInfo उपलब्ध कराकर, पास/फ़ेल का नतीजा रजिस्टर करना होगा.
`build_setting`	`BuildSetting; or None`; डिफ़ॉल्ट = None अगर यह सेट है, तो यह बताता है कि यह नियम किस तरह का `build setting` है. `config` मॉड्यूल देखें. अगर यह सेट है, तो इस नियम में "build_setting_default" नाम का ज़रूरी एट्रिब्यूट अपने-आप जुड़ जाता है. यह एट्रिब्यूट, यहां दी गई वैल्यू के हिसाब से टाइप के साथ जुड़ता है.
`cfg`	default = None If set, points to the configuration transition the rule will apply to its own configuration before analysis.
`exec_groups`	`dict; or None`; डिफ़ॉल्ट = None एक डिक्शनरी, जिसमें एक्ज़ीक्यूशन ग्रुप का नाम (स्ट्रिंग) `exec_group` में बदला जाता है. अगर यह सेट होता है, तो नियमों को एक ही टारगेट में, कई एक्ज़ीक्यूशन प्लैटफ़ॉर्म पर कार्रवाइयां चलाने की अनुमति मिलती है. ज़्यादा जानकारी के लिए, एक्ज़ीक्यूशन ग्रुप का दस्तावेज़ देखें.
`compile_one_filetype`	`sequence of strings; or None`; default = None Used by --compile_one_dependency: if multiple rules consume the specified file, should we choose this rule over others.
`name`	`string; or None`; default = None Deprecated. यह पैरामीटर अब काम नहीं करता. इसे जल्द ही हटा दिया जाएगा. कृपया इसके भरोसे न रहें. `--+incompatible_remove_rule_name_parameter` के साथ, यह बंद है. इस फ़्लैग का इस्तेमाल करके पुष्टि करें कि आपका कोड, इस एपीआई के हटने के बाद भी सही तरीके से काम करेगा. अब काम नहीं करता: इसका इस्तेमाल न करें. इस नियम का नाम, जैसा कि Bazel समझता है और लॉगिंग, `native.existing_rule(...)[kind]`, और `bazel query` जैसे कॉन्टेक्स्ट में रिपोर्ट करता है. आम तौर पर, यह उस Starlark आइडेंटिफ़ायर के जैसा ही होता है जो इस नियम से जुड़ा होता है. उदाहरण के लिए, `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 या constraint_value इंस्टेंस की पहचान करती है. स्ट्रिंग के बजाय लेबल का इस्तेमाल कब करना है, यह जानने के लिए मैक्रो के बारे में दस्तावेज़ देखें.

no_match_error default = ''
Optional custom error to report if no condition matches.

पैरामीटर	ब्यौरा
`x`	ज़रूरी है एक डिक्शनरी, जो कॉन्फ़िगरेशन की शर्तों को वैल्यू पर मैप करती है. हर कुंजी एक लेबल या लेबल स्ट्रिंग होती है, जो config_setting या constraint_value इंस्टेंस की पहचान करती है. स्ट्रिंग के बजाय लेबल का इस्तेमाल कब करना है, यह जानने के लिए मैक्रो के बारे में दस्तावेज़ देखें.
`no_match_error`	default = '' Optional custom error to report if no condition matches.

single_version_override

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

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

पैरामीटर

पैरामीटर	ब्यौरा
`module_name`	ज़रूरी है यह Bazel मॉड्यूल डिपेंडेंसी का नाम है, जिस पर इस ओवरराइड को लागू करना है.
`version`	default = '' Overrides the declared version of this module in the dependency graph. दूसरे शब्दों में कहें, तो यह मॉड्यूल इस ओवरराइड वर्शन पर "पिन" हो जाएगा. अगर सिर्फ़ रजिस्ट्री या पैच को बदलना है, तो इस एट्रिब्यूट को शामिल करने की ज़रूरत नहीं है.
`registry`	default = '' Overrides the registry for this module; instead of finding this module from the default list of registries, the given registry should be used.
`patches`	`Iterable of strings`; default = [] यह इस मॉड्यूल के लिए लागू की जाने वाली पैच फ़ाइलों की सूची है. पैच फ़ाइलें, टॉप लेवल प्रोजेक्ट के सोर्स ट्री में मौजूद होनी चाहिए. ये सूची में दिए गए क्रम के हिसाब से लागू होते हैं.
`patch_cmds`	`Iterable of strings`; default = [] पैच लागू होने के बाद, Linux/Macos पर लागू होने वाले बैश कमांड का क्रम.
`patch_strip`	default = 0 यह Unix पैच के --strip तर्क के जैसा ही है.

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

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

यह फ़ंक्शन, क्रम से लगाई गई नई सूची दिखाता है. इसमें, दिए गए इटरेट किए जा सकने वाले क्रम के सभी एलिमेंट शामिल होते हैं. अगर x < y का इस्तेमाल करके, x और y के किसी भी पेयर की तुलना नहीं की जा सकती, तो गड़बड़ी हो सकती है. तत्वों को बढ़ते क्रम में लगाया जाता है. हालांकि, अगर reverse आर्ग्युमेंट की वैल्यू True है, तो उन्हें घटते क्रम में लगाया जाता है. सॉर्टिंग स्थिर होती है: तुलना करने पर बराबर पाए गए एलिमेंट, अपने मूल क्रम में ही रहते हैं.

sorted([3, 5, 4]) == [3, 4, 5]

पैरामीटर

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

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`	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`	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`	required वह ऑब्जेक्ट जिसका टाइप जांचना है.

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 If true, this usage of the module extension will be ignored if the current module is not the root module or `--ignore_dev_dependency` is enabled.
`isolate`	default = False एक्सपेरिमेंट के तौर पर उपलब्ध है. यह पैरामीटर एक्सपेरिमेंट के तौर पर उपलब्ध है. इसमें कभी भी बदलाव किया जा सकता है. कृपया इसके भरोसे न रहें. इसे एक्सपेरिमेंट के तौर पर चालू किया जा सकता है. इसके लिए, `---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 सोर्स फ़ाइल की टारगेट विज़िबिलिटी से अलग है. इससे यह तय होता है कि फ़ाइल, अन्य टारगेट की डिपेंडेंसी के तौर पर दिख सकती है या नहीं.) लोड करने की सुविधा, पैकेज के लेवल पर काम करती है: किसी मॉड्यूल को लोड करने के लिए, लोड करने वाली फ़ाइल को ऐसे पैकेज में होना चाहिए जिसे मॉड्यूल को दिखाने की अनुमति मिली हो. मॉड्यूल को हमेशा उसके पैकेज में लोड किया जा सकता है. भले ही, वह दिखे या न दिखे.

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

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

पैरामीटर

पैरामीटर ब्यौरा

पैरामीटर	ब्यौरा
`value`	ज़रूरी है पैकेज स्पेसिफ़िकेशन स्ट्रिंग की सूची या एक पैकेज स्पेसिफ़िकेशन स्ट्रिंग. पैकेज के ब्यौरे का फ़ॉर्मैट, `package_group` के फ़ॉर्मैट जैसा ही होता है. हालांकि, पैकेज के ब्यौरे में नेगेटिव वैल्यू इस्तेमाल करने की अनुमति नहीं होती. इसका मतलब है कि स्पेसिफ़िकेशन इस तरह के हो सकते हैं: `"//foo"`: the package `//foo` `"//foo/..."`: the package `//foo` and all of its subpackages. `"public"` या `"private"`: सभी पैकेज या कोई भी पैकेज नहीं "@" सिंटैक्स का इस्तेमाल नहीं किया जा सकता. सभी खास बातों को मौजूदा मॉड्यूल के डेटाबेस के हिसाब से समझा जाता है. अगर `value` स्ट्रिंग की सूची है, तो इस मॉड्यूल को दिखने वाले पैकेज का सेट, हर स्पेसिफ़िकेशन से दिखाए गए पैकेज का यूनीयन होता है. (खाली सूची का असर `private` जैसा ही होता है.) अगर `value` एक स्ट्रिंग है, तो इसे `[value]` के तौर पर माना जाता है. ध्यान दें कि `--incompatible_package_group_has_public_syntax` और `--incompatible_fix_package_group_reporoot_syntax` फ़्लैग का इस तर्क पर कोई असर नहीं पड़ता. `"public"` और `"private"` वैल्यू हमेशा उपलब्ध होती हैं. साथ ही, `"//..."` का मतलब हमेशा "मौजूदा रिपॉज़िटरी में मौजूद सभी पैकेज" होता है.

value

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

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

"//foo": the package //foo
"//foo/...": the package //foo and all of its subpackages.
"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 फ़ंक्शन होना चाहिए.

यह कुकी, इस वर्कस्पेस के लिए नाम सेट करती है. Workspace के नाम, Java-पैकेज-स्टाइल में प्रोजेक्ट के बारे में जानकारी देने वाले होने चाहिए.साथ ही, सेपरेटर के तौर पर अंडरस्कोर का इस्तेमाल किया जाना चाहिए. उदाहरण के लिए, github.com/bazelbuild/bazel के लिए com_github_bazelbuild_bazel का इस्तेमाल किया जाना चाहिए.

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

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

पैरामीटर

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

zip

list zip(*args)

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

ग्लोबल संग्रह की मदद से व्यवस्थित रहें अपनी प्राथमिकताओं के आधार पर, कॉन्टेंट को सेव करें और कैटगरी में बांटें.

सदस्य

सभी

पैरामीटर

analysis_test_transition

पैरामीटर

कोई

पैरामीटर

archive_override

पैरामीटर

आसपेक्ट

पैरामीटर

bazel_dep

पैरामीटर

बाइंड

पैरामीटर

बूल

पैरामीटर

configuration_field

पैरामीटर

depset

पैरामीटर

dict

पैरामीटर

dir

पैरामीटर

गिनती करना

पैरामीटर

exec_group

पैरामीटर

फ़ेल

पैरामीटर

फ़्लोट

पैरामीटर

getattr

पैरामीटर

git_override

पैरामीटर

hasattr

पैरामीटर

हैश

पैरामीटर

int

पैरामीटर

len

पैरामीटर

सूची

पैरामीटर

local_path_override

पैरामीटर

अधिकतम

पैरामीटर

कम से कम

पैरामीटर

मॉड्यूल

पैरामीटर

module_extension

पैरामीटर

multiple_version_override

पैरामीटर

प्रिंट करें

पैरामीटर

provider

पैरामीटर

सीमा

पैरामीटर

register_execution_platforms()

पैरामीटर

register_execution_platforms(dev_dependency)

पैरामीटर

register_toolchains()

पैरामीटर

register_toolchains(dev_dependency)

पैरामीटर

repository_rule

पैरामीटर

repr

पैरामीटर

रिवर्स किया गया

पैरामीटर

ग्लोबल