इस पेज का अनुवाद Cloud Translation API से किया गया है.

ग्लोबल

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

सदस्य

सभी
analysis_test_transition
कोई भी
archive_override
आसपेक्ट
bazen_dep
बाइंड
bool
config_field
डेपसेट
शब्द
dir
हिसाब लगाएं
exec_group
असफल
फ़्लोट
getattr
git_override
hasattr
हैश
int
लेन
list
local_path_override
ज़्यादा से ज़्यादा
कम से कम
मॉड्यूल
module_extensions
multiple_वर्शन_ओवरराइड
प्रिंट करें
सेवा देने वाली कंपनी
range
register_execution_platform
register_toolchains
repository_rule(लागू करना, attr, स्थानीय, एनवायरमेंट, कॉन्फ़िगर करना, बदला जा सकने वाला, दस्तावेज़)
repository_rule(लागू करना, attr, स्थानीय, एनवायरमेंट, कॉन्फ़िगर करना, बदला जा सकने वाला, दस्तावेज़)
जवाब
रिवर्स
नियम
चुनें
सिंगल_वर्शन_ओवरराइड
क्रम से लगाया गया
स्ट्रो
tag_class
टूपल
टाइप
use_extensions (इस्तेमाल_का_एक्सटेंशन)
use_repo
फ़ाइल फ़ोल्डर
ज़िप

सभी

bool all(elements)

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

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

पैरामीटर

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

विश्लेषण_जांच_का_ट्रांज़िशन

transition analysis_test_transition(settings)

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

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

पैरामीटर

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

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

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

कोई भी

bool any(elements)

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

any([-1, 0, 1]) == True
any([False, 0, ""]) == False

पैरामीटर

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

collections_override

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

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

पैरामीटर

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

आसपेक्ट

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`	ज़रूरी है एक स्टारलार्क फ़ंक्शन, जो सिर्फ़ दो पैरामीटर के साथ इस पहलू को लागू करता है: टारगेट (वह टारगेट जिस पर आसपेक्ट रेशियो (चौड़ाई-ऊंचाई का अनुपात) लागू होता है) और टैब (वह नियम संदर्भ जिससे टारगेट बनाया गया है). टारगेट के एट्रिब्यूट, `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`	डिफ़ॉल्ट = [] उन कंपनियों की सूची जिन्हें इंप्लिमेंटेशन फ़ंक्शन को रिटर्न करना है. अगर लागू करने का फ़ंक्शन, दी गई वैल्यू में से यहां दी गई सेवा देने वाली किसी भी कंपनी को शामिल नहीं करता है, तो यह एक गड़बड़ी होती है. हालांकि, लागू करने की सुविधा अन्य कंपनियों को भी दिखा सकती है, जो यहां नहीं दी गई हैं. सूची में मौजूद हर एलिमेंट, `provider()` की मदद से दिखाया गया `*Info` ऑब्जेक्ट है. हालांकि, लेगसी प्रोवाइडर को स्ट्रिंग के नाम से दिखाया जाता है.
`requires`	`sequence of Aspects`; डिफ़ॉल्ट = [] इस पहलू से पहले प्रचार किए जाने वाले पहलुओं की सूची.
`fragments`	`sequence of strings`; डिफ़ॉल्ट = [] कॉन्फ़िगरेशन फ़्रैगमेंट के ऐसे नामों की सूची जिन्हें आसपेक्ट कॉन्फ़िगरेशन में, आसपेक्ट रेशियो की ज़रूरत होती है.
`host_fragments`	`sequence of strings`; डिफ़ॉल्ट = [] कॉन्फ़िगरेशन फ़्रैगमेंट के उन नामों की सूची जिन्हें आसपेक्ट कॉन्फ़िगरेशन में आसपेक्ट रेशियो की ज़रूरत होती है.
`toolchains`	`sequence`; डिफ़ॉल्ट = [] अगर यह सेट किया जाता है, तो इस नियम के लिए टूलचेन के सेट की ज़रूरत होगी. इस सूची में स्ट्रिंग, लेबल या StarlarkToolchainTypeApi के ऑब्जेक्ट हो सकते हैं. मौजूदा प्लैटफ़ॉर्म की जांच करके, टूल का पता लगाया जाएगा. इस टूल को `ctx.toolchain` से लागू किया जाएगा.
`incompatible_use_toolchain_transition`	डिफ़ॉल्ट = गलत बहिष्कृत, यह अब इस्तेमाल में नहीं है और इसे हटा दिया जाना चाहिए.
`doc`	डिफ़ॉल्ट = '' उस पहलू का ब्यौरा जो दस्तावेज़ जनरेट करने वाले टूल से निकाला जा सकता है.
`apply_to_generating_rules`	डिफ़ॉल्ट = गलत अगर सही है, तो आउटपुट फ़ाइल पर लागू किए जाने पर, चौड़ाई-ऊंचाई के मान को आउटपुट फ़ाइल और #39;s जनरेट करने के नियम पर लागू कर दिया जाएगा. है डिफ़ॉल्ट रूप से गलत.
`exec_compatible_with`	`sequence of strings`; डिफ़ॉल्ट = [] एक्ज़ीक्यूशन प्लैटफ़ॉर्म पर कंस्ट्रेंट की सूची, जो इस आसपेक्ट के सभी इंस्टेंस पर लागू होती है.
`exec_groups`	`dict; or None`; डिफ़ॉल्ट = कोई नहीं एक्ज़ीक्यूशन ग्रुप के नाम (स्ट्रिंग) को `exec_group`s. अगर नीति को सेट किया जाता है, तो इससे एक से ज़्यादा प्लैटफ़ॉर्म पर एक ही इंस्टेंस में कार्रवाइयां की जा सकती हैं. ज़्यादा जानकारी के लिए, एक्ज़ीक्यूशन ग्रुप के दस्तावेज़ देखें.

बेज़ेल_डेप

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

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

पैरामीटर

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

बाइंड

None bind(name, actual=None)

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

//external पैकेज में किसी टारगेट को देता है.

पैरामीटर

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

बूल

bool bool(x=False)

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

पैरामीटर

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

कॉन्फ़िगरेशन_फ़ील्ड

LateBoundDefault configuration_field(fragment, name)

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

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

नियम का एट्रिब्यूट तय करना:

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

नियम लागू करने का ऐक्सेस:

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

पैरामीटर

पैरामीटर	ब्यौरा
`fragment`	ज़रूरी उस कॉन्फ़िगरेशन फ़्रैगमेंट का नाम जिसमें देरी से आने वाला मान होता है.
`name`	ज़रूरी कॉन्फ़िगरेशन फ़्रैगमेंट से पाने वाली वैल्यू का नाम.

Depset

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

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

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

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

इसके अलावा, एलिमेंट में अब भी बदलाव नहीं हो सकता. हालांकि, आने वाले समय में इस प्रतिबंध में ढील दी जाएगी.

बनाए गए डिपोसेट का क्रम, उसके transitive डेस्कटॉप के क्रम के साथ साथ काम करने वाला होना चाहिए. "default" ऑर्डर किसी दूसरे ऑर्डर पर काम करता है. बाकी सभी ऑर्डर सिर्फ़ खुद के लिए ऑर्डर हैं.

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

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

पैरामीटर

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

लिखवाना

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

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

पैरामीटर

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

dir

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`	डिफ़ॉल्ट = गलत अगर सही पर सेट किया जाता है, तो यह exec ग्रुप उस टूल की चेन और कंस्ट्रेंट को इनहेरिट करता है जिससे यह ग्रुप अटैच होता है. अगर इसे किसी दूसरी स्ट्रिंग पर सेट किया जाता है, तो गड़बड़ी दिखेगी.

पूरी नहीं हो सकी

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

इसकी वजह से, किसी गड़बड़ी की वजह से एक्ज़ीक्यूशन नहीं हो पाता.

पैरामीटर

पैरामीटर	ब्यौरा
`msg`	डिफ़ॉल्ट = कोई नहीं अब इस्तेमाल में नहीं है: इसके बजाय पोज़िशनल आर्ग्युमेंट का इस्तेमाल करें. यह तर्क, इंप्लिसिट लीडिंग पोज़िशनल आर्ग्युमेंट की तरह काम करता है.
`attr`	`string; or None`; डिफ़ॉल्ट = कोई नहीं बहिष्कृत. इससे, इस स्ट्रिंग वाले वैकल्पिक प्रीफ़िक्स को गड़बड़ी के मैसेज में जोड़ दिया जाता है.
`args`	ज़रूरी वैल्यू की ऐसी सूची जिसे 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`	डिफ़ॉल्ट = अनबाउंड कन्वर्ज़न की वैल्यू.

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`	डिफ़ॉल्ट = अनबाउंड अगर वैल्यू में दिए गए नाम का एट्रिब्यूट नहीं है, तो दिया जाने वाला डिफ़ॉल्ट वैल्यू.

git_override

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

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

पैरामीटर

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

हैश किया गया

bool hasattr(x, name)

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

hasattr(ctx.attr, "myattr")

पैरामीटर

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

हैश

int hash(value)

स्ट्रिंग के लिए हैश वैल्यू देना. इसकी गणना मुख्य रूप से उसी एल्गोरिदम का इस्तेमाल करके की जाती है जिसका Java's String.hashCode() में उपयोग किया जाता है, जैसे:

s[0] * (31^(n-1)) + s[1] * (31^(n-2)) + ... + s[n-1]

स्ट्रिंग के अलावा अन्य मानों का हैशिंग अभी समर्थित नहीं है.

पैरामीटर

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

int

int int(x, base=unbound)

एक इंटेजर वैल्यू के तौर पर x दिखाता है.

अगर x पहले से ही एक int है, तो 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) हो सकता है; अगर इन बेस या विशेष वैल्यू 0 के अलावा base कोई और वैल्यू है, तो प्रीफ़िक्स खाली होना चाहिए. जहां base 0 होता है, तो स्ट्रिंग को एक इंटेजर लिटरल माना जाता है. ऐसा इस आधार पर किया जाता है कि 2/8/10/16 में से कोई एक आधार इस बात पर निर्भर करता है कि कौनसा प्रीफ़िक्स इस्तेमाल किया गया है. अगर base 0 है, तो किसी प्रीफ़िक्स का इस्तेमाल नहीं किया जाता है और एक से ज़्यादा अंक होते हैं, तो सबसे पहले वाला अंक 0 नहीं होना चाहिए. यह ऑक्टल और दशमलव के बीच भ्रम की स्थिति से बचने के लिए है. स्ट्रिंग के ज़रिए दिखाई गई संख्या का तीव्रता, पूर्णांक प्रकार के लिए मंज़ूर की गई सीमा के अंदर होना चाहिए.
अगर x एक फ़्लोट है, तो int, फ़्लोट के पूर्णांक मान को शून्य की ओर राउंड ऑफ़ करता है. अगर x छोटी नहीं है (NaN या इनफ़िनिटी).

अगर x कोई और टाइप है या वैल्यू ऐसी स्ट्रिंग है जो ऊपर दिए गए फ़ॉर्मैट के मुताबिक नहीं है, तो यह फ़ंक्शन काम नहीं करता. 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 एक लिटरल वैल्यू है. अगर वैल्यू कोई स्ट्रिंग नहीं है, तो यह पैरामीटर नहीं दिया जाना चाहिए.

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

लेन

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`	डिफ़ॉल्ट = [] कन्वर्ज़न के लिए ऑब्जेक्ट.

local_path_override

None local_path_override(module_name, path)

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

पैरामीटर

पैरामीटर	ब्यौरा
`module_name`	ज़रूरी है इस ओवरराइड को लागू करने के लिए, बेज़ल मॉड्यूल की डिपेंडेंसी का नाम.
`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, execution_platforms_to_register=[], toolchains_to_register=[])

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

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

पैरामीटर

पैरामीटर	ब्यौरा
`name`	डिफ़ॉल्ट = '' मॉड्यूल का नाम. इसे सिर्फ़ तब छोड़ा जा सकता है, जब यह मॉड्यूल रूट मॉड्यूल हो (जैसा कि तब होता है, जब यह किसी दूसरे मॉड्यूल पर निर्भर न हो).
`version`	डिफ़ॉल्ट = '' मॉड्यूल का वर्शन. इसे सिर्फ़ तब छोड़ा जा सकता है, जब यह मॉड्यूल रूट मॉड्यूल हो (जैसा कि तब होता है, जब यह किसी दूसरे मॉड्यूल पर निर्भर न हो).
`compatibility_level`	डिफ़ॉल्ट = 0 मॉड्यूल का कम्पैटिबिलिटी लेवल; इसे हर बार तब बदला जाना चाहिए, जब मॉड्यूल में कोई बड़ा बदलाव न हो. यह Semver के मामले में मॉड्यूल का &majormor वर्शन&कोटेशन है. सिवाय इसके कि यह वर्शन स्ट्रिंग में एम्बेड नहीं किया गया है. हालांकि, यह एक अलग फ़ील्ड के तौर पर मौजूद है. अलग-अलग कम्पैटबिलटी लेवल वाले मॉड्यूल, वर्शन रिज़ॉल्यूशन में ऐसे दिखते हैं जैसे अलग-अलग नाम वाले मॉड्यूल. हालांकि, फ़ाइनल डिपेंडेंसी ग्राफ़ में एक ही नाम वाले अलग-अलग मॉड्यूल नहीं हो सकते, लेकिन अलग-अलग कंपैटिबिलिटी लेवल हो सकते हैं (जब तक कि `multiple_version_override` लागू न हो, ज़्यादा जानकारी के लिए यहां देखें).
`execution_platforms_to_register`	`Iterable of strings`; डिफ़ॉल्ट = [] इस मॉड्यूल को चुने जाने पर, पहले से तय एक्ज़ीक्यूशन प्लैटफ़ॉर्म की सूची. यह सटीक टारगेट पैटर्न की सूची होनी चाहिए (यानी, `@` या `//` से शुरू). ज़्यादा जानकारी के लिए, टूलचेन रिज़ॉल्यूशन देखें.
`toolchains_to_register`	`Iterable of strings`; डिफ़ॉल्ट = [] इस मॉड्यूल को चुने जाने पर, पहले से तय किए गए टूलचेन की एक सूची. यह सटीक टारगेट पैटर्न की सूची होनी चाहिए (यानी, `@` या `//` से शुरू). ज़्यादा जानकारी के लिए, टूलचेन रिज़ॉल्यूशन देखें.

मॉड्यूल_एक्सटेंशन

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

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

पैरामीटर

पैरामीटर	ब्यौरा
`implementation`	ज़रूरी वह फ़ंक्शन जो इस मॉड्यूल एक्सटेंशन को लागू करता है. सिर्फ़ एक पैरामीटर, `module_ctx` का इस्तेमाल करना होगा. फ़ंक्शन का इस्तेमाल किसी बिल्ड की शुरुआत में एक बार किया जाता है, ताकि उपलब्ध डेटा स्टोर का सेट तय किया जा सके.
`tag_classes`	डिफ़ॉल्ट = {} एक डिक्शनरी, जो एक्सटेंशन में इस्तेमाल होने वाले सभी टैग क्लास के बारे में बताती है. यह टैग क्लास के नाम से `tag_class` ऑब्जेक्ट तक मैप होता है.
`doc`	डिफ़ॉल्ट = '' मॉड्यूल एक्सटेंशन का ब्यौरा, जिसे दस्तावेज़ जनरेट करने वाले टूल से निकाला जा सकता है.

मल्टिपल_वर्शन_ओवरराइड

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

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

पैरामीटर

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

प्रिंट करें

None print(sep=" ", *args)

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

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

पैरामीटर

पैरामीटर	ब्यौरा
`sep`	डिफ़ॉल्ट = " &कोटेशन; ऑब्जेक्ट के बीच विभाजक स्ट्रिंग, डिफ़ॉल्ट स्पेस होता है (" &कोटेशन;).
`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 डिफ़ॉल्ट = ''
सेवा देने वाली उस कंपनी की जानकारी जिसे दस्तावेज़ जनरेट करने वाले टूल से निकाला जा सकता है.

पैरामीटर	ब्यौरा
`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`; डिफ़ॉल्ट = कोई नहीं इंस्टैंट प्रोसेस के दौरान, कंपनी और #39; के फ़ील्ड वैल्यू को पहले से प्रोसेस करने और उनकी पुष्टि करने के लिए एक वैकल्पिक कॉलबैक. अगर `init` बताया गया है, तो `provider()` दो एलिमेंट का टपल देता है: सामान्य प्रोवाइडर का निशान और रॉ कंस्ट्रक्टर. सटीक जानकारी दें; आसान चर्चा और इस्तेमाल के उदाहरणों के लिए, नियम देने वालों के मुताबिक बनाए गए नियम) नियम देखें. `P` को, `provider()` को कॉल करके, सेवा देने वाले का नाम बनाने दें. सैद्धांतिक तौर पर, डिफ़ॉल्ट कंस्ट्रक्टर फ़ंक्शन `c(args, kwargs)` को कॉल करके `P` का एक इंस्टेंस जनरेट किया जाता है, जो ये काम करता है: अगर `args` खाली नहीं है, तो कोई गड़बड़ी होती है. अगर `provider()` को कॉल करते समय `fields` पैरामीटर के बारे में बताया गया था और `kwargs` में कोई ऐसी कुंजी है जो `fields` में शामिल नहीं थी, तो कोई गड़बड़ी होगी. ऐसा न होने पर, `c` एक नया इंस्टेंस दिखाता है, जिसमें `kwargs` में हर `k: v` एंट्री के लिए, `v` वैल्यू वाला `k` नाम का एक फ़ील्ड होता है. `init` उदाहरण के लिए, MyInfo = provider() m = MyInfo(foo = 1) सादगी से इसे बनाएं, ताकि `m.foo == 1` के साथ `m`, एक `MyInfo` इंस्टेंस बन जाए. हालांकि, अगर `init` के बारे में बताया गया है, तो `P(args, *kwargs)` को कॉल किया जाएगा: कॉलबैक का इस्तेमाल, `init(args, kwargs)` के तौर पर किया जाता है. इसका मतलब है कि ठीक उसी पोज़िशनल और कीवर्ड आर्ग्युमेंट के साथ जो `P` को भेजा गया था. `init` की रिटर्न वैल्यू का डिक्शनरी `d` होना चाहिए, जिसकी कुंजियां फ़ील्ड नाम स्ट्रिंग हैं. अगर ऐसा नहीं होता है, तो कोई गड़बड़ी होती है. `P` के नए इंस्टेंस को इस तरह जनरेट किया जाता है जैसे डिफ़ॉल्ट कंस्ट्रक्टर को `d`'s एंट्री के साथ कीवर्ड के रूप में कॉल किया जाता है, जैसे कि `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; डिफ़ॉल्ट = कोई नहीं
अगर बताया गया है, तो अनुमति वाले फ़ील्ड के सेट पर पाबंदी लगाता है.
संभावित मान हैं:

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

सभी फ़ील्ड ज़रूरी नहीं हैं.

init

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

सटीक जानकारी दें; आसान चर्चा और इस्तेमाल के उदाहरणों के लिए, नियम देने वालों के मुताबिक बनाए गए नियम) नियम देखें.

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

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

init

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

m.foo == 1

m

MyInfo

हालांकि, अगर init के बारे में बताया गया है, तो P(*args, **kwargs) को कॉल किया जाएगा:

कॉलबैक का इस्तेमाल, init(*args, **kwargs) के तौर पर किया जाता है. इसका मतलब है कि ठीक उसी पोज़िशनल और कीवर्ड आर्ग्युमेंट के साथ जो P को भेजा गया था.
init की रिटर्न वैल्यू का डिक्शनरी d होना चाहिए, जिसकी कुंजियां फ़ील्ड नाम स्ट्रिंग हैं. अगर ऐसा नहीं होता है, तो कोई गड़बड़ी होती है.
P के नए इंस्टेंस को इस तरह जनरेट किया जाता है जैसे डिफ़ॉल्ट कंस्ट्रक्टर को d's एंट्री के साथ कीवर्ड के रूप में कॉल किया जाता है, जैसे कि 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`	ज़रूरी है स्टॉप के बारे में जानकारी देने पर, शुरुआती एलिमेंट की वैल्यू
`stop_or_none`	`int; or None`; डिफ़ॉल्ट = कोई भी नहीं पहले आइटम का वैकल्पिक इंडेक्स, नतीजे के तौर पर मिलने वाली सूची में शामिल नहीं होना चाहिए; `stop` तक पहुंचने से पहले सूची का जनरेट होना रुक जाता है.
`step`	डिफ़ॉल्ट = 1 बढ़ोतरी (डिफ़ॉल्ट रूप से एक होती है). यह नतीजा नेगेटिव हो सकता है.

रजिस्टर_तय करने वाले_प्लैटफ़ॉर्म

None register_execution_platforms(*platform_labels)

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

पैरामीटर

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

रजिस्टर_टूलचेन

None register_toolchains(*toolchain_labels)

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

पैरामीटर

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

रिपॉज़िटरी_नियम(लागू करना, attr, स्थानीय, एनवायरमेंट, कॉन्फ़िगर करना, बदला जा सकने वाला, दस्तावेज़)

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`	डिफ़ॉल्ट = गलत बताएं कि यह नियम लोकल सिस्टम से सब कुछ फ़ेच करता है और हर फ़ेच पर इसका फिर से आकलन किया जाना चाहिए.
`environ`	`sequence of strings`; Default = [] यह एनवायरमेंट वैरिएबल की सूची दिखाता है, जो रिपॉज़िटरी के इस नियम पर निर्भर करता है. अगर उस सूची में कोई एनवायरमेंट वैरिएबल बदलता है, तो रिपॉज़िटरी को फिर से फ़ेच किया जाएगा.
`configure`	डिफ़ॉल्ट = गलत बताएं कि रिपॉज़िटरी, कॉन्फ़िगरेशन के मकसद के लिए सिस्टम की जांच करती है
`remotable`	डिफ़ॉल्ट = गलत प्रयोग के तौर पर. इस पैरामीटर पर प्रयोग किया जा रहा है और यह किसी भी समय बदल सकता है. कृपया इस पर निर्भर न रहें. इसे `---experimental_repo_remote_exec` रिमोट एक्ज़ीक्यूशन के साथ काम करने वाली सेटिंग पर सेट करके, प्रयोग के आधार पर चालू किया जा सकता है
`doc`	डिफ़ॉल्ट = '' डेटा स्टोर करने के उस नियम का ब्यौरा जिसे दस्तावेज़ बनाने वाले टूल से निकाला जा सकता है.

रिपॉज़िटरी_नियम(लागू करना, attr, स्थानीय, एनवायरमेंट, कॉन्फ़िगर करना, बदला जा सकने वाला, दस्तावेज़)

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

पैरामीटर

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

जवाब

string repr(x)

किसी ऑब्जेक्ट को स्ट्रिंग प्रज़ेंटेशन में बदलता है. यह डीबग करने के लिए उपयोगी है.

repr("ab") == '"ab"'

पैरामीटर

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

उल्टा

list reversed(sequence)

एक नई, फ़्रीज़ न की गई सूची देता है, जिसमें मूल क्रम में चलने वाले क्रम के एलिमेंट उल्टे क्रम में होते हैं.

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

पैरामीटर

पैरामीटर	ब्यौरा
`sequence`	ज़रूरी बार-बार होने वाला क्रम (उदाहरण के लिए, सूची) जिसे उलटा जाना है.

नियम

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

नया नियम बनाता है, जिसे टारगेट बनाने के लिए किसी BUILD फ़ाइल या मैक्रो से कॉल किया जा सकता है.

नियमों को .bzl फ़ाइल में ग्लोबल वैरिएबल को असाइन किया जाना चाहिए; ग्लोबल वैरिएबल का नाम नियम's नाम है.

टेस्ट के नियमों का नाम _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` एट्रिब्यूट के उलट, उपयोगकर्ता इन फ़ाइलों के लिए लेबल तय नहीं करता. पहले से तय आउटपुट के बारे में ज़्यादा जानकारी के लिए, नियम पेज देखें. इस आर्ग्युमेंट की वैल्यू कोई डिक्शनरी या डिक्शनरी बनाने वाला कॉलबैक फ़ंक्शन होती है. कॉलबैक, कंप्यूट किए गए डिपेंडेंसी एट्रिब्यूट से मिलता-जुलता है: फ़ंक्शन' के पैरामीटर के नाम, नियम और #39; एट्रिब्यूट से मेल खाते हैं. इसलिए, `outputs = _my_func` को `def _my_func(srcs, deps): ...` परिभाषा के साथ पास करने पर, फ़ंक्शन के पास `srcs` और `deps` एट्रिब्यूट का ऐक्सेस होता है. भले ही शब्दकोश को सीधे तौर पर या किसी फ़ंक्शन की मदद से तय किया गया हो, उसे इस तरह समझा जाता है. डिक्शनरी में हर एंट्री एक पहले से तय किया गया आउटपुट बनाती है, जहां कुंजी एक पहचानकर्ता है और वैल्यू एक स्ट्रिंग टेंप्लेट है जो आउटपुट और #39;s लेबल को तय करता है. नियम और #39; इंप्लिमेंटेशन फ़ंक्शन में, आइडेंटिफ़ायर फ़ील्ड फ़ील्ड का नाम बन जाता है. `ctx.outputs` में आउटपुट's `File` को ऐक्सेस करने के लिए इसका इस्तेमाल किया जाता है. आउटपुट's लेबल का नियम पैकेज के समान है और पैकेज के बनने के बाद वाले हिस्से को `"%{ATTR}"` फ़ॉर्म के हर प्लेसहोल्डर की जगह एट्रिब्यूट की वैल्यू `ATTR` से बनाया गया है: स्ट्रिंग के प्रकार वाले एट्रिब्यूट को, शब्दों की जगह इस्तेमाल किया जाता है. लेबल के टाइप वाले एट्रिब्यूट, पैकेज के बाद लेबल का हिस्सा बन जाते हैं. इसमें से फ़ाइल एक्सटेंशन को घटाया जाता है. उदाहरण के लिए, `"//pkg:a/b.c"` लेबल `"a/b"` बन जाता है. फ़ाइल टाइप के साथ, आउटपुट टाइप एट्रिब्यूट, पैकेज के बाद लेबल का हिस्सा बन जाते हैं. ऊपर दिए गए उदाहरण के लिए, `"a/b.c"`. प्लेसहोल्डर में इस्तेमाल किए गए सभी टाइप के एट्रिब्यूट (उदाहरण के लिए, `attr.label_list`) में सिर्फ़ एक एलिमेंट होना ज़रूरी है. उनका कन्वर्ज़न, उनके बिना सूची वाले वर्शन (`attr.label`) जैसा ही है. हो सकता है कि दूसरी तरह के एट्रिब्यूट प्लेसहोल्डर में न दिखें. खास गैर-विशेषता वाले प्लेसहोल्डर `%{dirname}` और `%{basename}`, पैकेज के बिना नियम और #39; लेबल के उन हिस्सों को बड़ा कर देते हैं. उदाहरण के लिए, `"//pkg:a/b.c"` में, dirname `a` और बेसनाम `b.c` है. व्यावहारिक तौर पर, सबसे ज़्यादा विकल्प वाला प्लेसहोल्डर `"%{name}"` है. उदाहरण के लिए, "foo" नाम के टारगेट के लिए, आउटपुट निर्देश `{"bin": "%{name}.exe"}` यह तय करता है कि `foo.exe` नाम के आउटपुट को `ctx.outputs.bin` के तौर पर लागू किया जा सकता है.
`executable`	डिफ़ॉल्ट = गलत क्या इस नियम को एक्ज़ीक्यूटेबल माना जाता है, इसका मतलब है कि क्या यह `blaze run` निर्देश का विषय हो सकता है. ज़्यादा जानकारी के लिए, नियमों वाला पेज देखें.
`output_to_genfiles`	डिफ़ॉल्ट = गलत अगर सही है, तो फ़ाइलें बिन डायरेक्ट्री के बजाय genfiles डायरेक्ट्री में जनरेट होंगी. जब तक आपको मौजूदा नियमों के साथ काम करने की ज़रूरत न हो (उदाहरण के लिए, C++ के लिए हेडर फ़ाइलें जनरेट करते समय), तब तक इस फ़्लैग को सेट न करें.
`fragments`	`sequence of strings`; डिफ़ॉल्ट = [] कॉन्फ़िगरेशन फ़्रैगमेंट के ऐसे नामों की सूची जिनके लिए नियम, टारगेट कॉन्फ़िगरेशन में ज़रूरी है.
`host_fragments`	`sequence of strings`; डिफ़ॉल्ट = [] कॉन्फ़िगरेशन फ़्रैगमेंट के ऐसे नामों की सूची जिनके लिए नियम, होस्ट कॉन्फ़िगरेशन में ज़रूरी है.
`_skylark_testable`	डिफ़ॉल्ट = गलत (प्रयोग के तौर पर) अगर यह सही है, तो इस नियम की मदद से, नियमों के हिसाब से अपनी कार्रवाइयों की जांच की जाएगी. ये नियम, कार्रवाइयां से जुड़ी कंपनियों के ज़रिए दिए जाते हैं. सेवा देने वाली कंपनी नियम के लिए भी उपलब्ध है. इसके लिए, आपको ctx.created_actions() नंबर पर कॉल करना होगा. इसका इस्तेमाल सिर्फ़ Starlark के नियमों के विश्लेषण के समय की जांच के लिए किया जाना चाहिए. इस फ़्लैग को आने वाले समय में हटाया जा सकता है.
`toolchains`	`sequence`; डिफ़ॉल्ट = [] अगर यह सेट किया जाता है, तो इस नियम के लिए टूलचेन के सेट की ज़रूरत होगी. इस सूची में स्ट्रिंग, लेबल या StarlarkToolchainTypeApi के ऑब्जेक्ट हो सकते हैं. मौजूदा प्लैटफ़ॉर्म की जांच करके, टूल का पता लगाया जाएगा. इस टूल को `ctx.toolchain` से लागू किया जाएगा.
`incompatible_use_toolchain_transition`	डिफ़ॉल्ट = गलत बहिष्कृत, यह अब इस्तेमाल में नहीं है और इसे हटा दिया जाना चाहिए.
`doc`	डिफ़ॉल्ट = '' उस नियम का ब्यौरा जिसे दस्तावेज़ जनरेट करने वाले टूल से निकाला जा सकता है.
`provides`	डिफ़ॉल्ट = [] उन कंपनियों की सूची जिन्हें इंप्लिमेंटेशन फ़ंक्शन को रिटर्न करना है. अगर लागू करने का फ़ंक्शन, दी गई वैल्यू में से यहां दी गई सेवा देने वाली किसी भी कंपनी को शामिल नहीं करता है, तो यह एक गड़बड़ी होती है. हालांकि, लागू करने की सुविधा अन्य कंपनियों को भी दिखा सकती है, जो यहां नहीं दी गई हैं. सूची में मौजूद हर एलिमेंट, `provider()` की मदद से दिखाया गया `*Info` ऑब्जेक्ट है. हालांकि, लेगसी प्रोवाइडर को स्ट्रिंग के नाम से दिखाया जाता है.
`exec_compatible_with`	`sequence of strings`; डिफ़ॉल्ट = [] इस तरह के नियम के सभी टारगेट पर लागू होने वाले कार्यान्वयन प्लैटफ़ॉर्म पर कंस्ट्रेंट की सूची.
`analysis_test`	डिफ़ॉल्ट = गलत अगर सही है, तो इस नियम को विश्लेषण टेस्ट माना जाता है. ध्यान दें: विश्लेषण को टेस्ट करने के नियमों को मुख्य तौर पर Starstark लाइब्रेरी में मौजूद इंफ़्रास्ट्रक्चर का इस्तेमाल करके तय किया जाता है. ज़्यादा जानकारी के लिए, जांच करना लेख देखें. अगर किसी नियम को विश्लेषण की जांच के नियम के तौर पर तय किया गया है, तो उसकी विशेषताओं पर analysis_test_transition का इस्तेमाल करके, कॉन्फ़िगर किए गए कॉन्फ़िगरेशन ट्रांज़िशन का इस्तेमाल करने की अनुमति मिल जाती है. हालांकि, यह कुछ पाबंदियों पर ऑप्ट-इन करता है: इस नियम के टारगेट, उन ट्रांज़िटिव डिपेंडेंसी की संख्या में सीमित हैं जो इन पर हो सकते हैं. नियम को एक टेस्ट नियम माना जाता है (जैसे कि `test=True` सेट किया गया हो). यह `test` के मान की जगह लागू होता है हो सकता है कि नियम लागू करने का फ़ंक्शन, कार्रवाइयों को रजिस्टर न करे. इसके बजाय, इसे AalysisTestResultInfo देकर, पास/फ़ेल नतीजे के लिए रजिस्टर करना चाहिए.
`build_setting`	`BuildSetting; or None`; डिफ़ॉल्ट = कोई नहीं अगर सेट किया गया है, तो बताता है कि यह नियम किस तरह का `build setting` है. `config` मॉड्यूल देखें. अगर यह सेट है, तो इस नियम में जोड़ा गया वैल्यू से जुड़ा एक टाइप, "build_setting_default&kot; नाम का ज़रूरी एट्रिब्यूट अपने-आप जुड़ जाता है.
`cfg`	डिफ़ॉल्ट = कोई नहीं अगर सेट किया जाता है, तो विश्लेषण के पहले नियम, कॉन्फ़िगरेशन ट्रांज़िशन के लिए अपने कॉन्फ़िगरेशन पर लागू होगा.
`exec_groups`	`dict; or None`; डिफ़ॉल्ट = कोई नहीं एक्ज़ीक्यूशन ग्रुप के नाम (स्ट्रिंग) को `exec_group`s. अगर इस नीति को सेट किया जाता है, तो नियम एक ही टारगेट में, एक से ज़्यादा एक्ज़ीक्यूशन प्लैटफ़ॉर्म पर कार्रवाइयां कर सकते हैं. ज़्यादा जानकारी के लिए, एक्ज़ीक्यूशन ग्रुप के दस्तावेज़ देखें.
`compile_one_filetype`	`sequence of strings; or None`; डिफ़ॉल्ट = कोई नहीं --compile_one_dependency: अगर एक से ज़्यादा नियम तय फ़ाइल का इस्तेमाल करते हैं, तो क्या हमें अन्य नियमों के बजाय इस नियम को चुनना चाहिए.
`name`	`string; or None`; डिफ़ॉल्ट = कोई नहीं इस नियम का नाम, जिसे बेज़ल ने समझा है. साथ ही, इसे लॉग करने, `native.existing_rule(...)[kind]`, और `bazel query` जैसे संदर्भों में रिपोर्ट किया गया है. आम तौर पर, यह Starlark आइडेंटिफ़ायर ही होता है, जो इस नियम से बंधा होता है. उदाहरण के लिए, `foo_library` नाम के नियम को आम तौर पर `foo_library = rule(...)` के तौर पर एलान किया जाता है और उसे BUILD फ़ाइल में `foo_library(...)` के तौर पर इंस्टैंशिएट किया जाता है. अगर यह पैरामीटर मौजूद नहीं है, तो नियम और #39; का नाम, पहले एलान किए गए ग्लोबल वैरिएबल के नाम पर सेट है. ऐसा करने से, वह एलान किए गए .bzl मॉड्यूल में मौजूद इस नियम से जुड़ा होगा. इसलिए, अगर नाम `foo_library` है, तो `foo_library = rule(...)` को यह पैरामीटर तय नहीं करना होगा. किसी नियम के लिए साफ़ तौर पर नाम बताने से, इस बात पर कोई असर नहीं पड़ता कि आप नियम को कहां लागू कर सकते हैं.

चुनें

unknown select(x, no_match_error='')

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

पैरामीटर

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

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

no_match_error डिफ़ॉल्ट = ''
कोई भी स्थिति मेल न खाने पर, रिपोर्ट करने के लिए कस्टम गड़बड़ी.

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

सिंगल_वर्शन_ओवरराइड

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

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

पैरामीटर

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

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

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

क्रम से लगाई गई एक नई सूची दिखाता है, जिसमें दिए गए क्रम में चलने वाले सभी एलिमेंट शामिल होते हैं. एलिमेंट x के किसी भी जोड़े को x &lt का इस्तेमाल करके जोड़ने पर गड़बड़ी हो सकती है. एलिमेंट को बढ़ते क्रम में रखा जाता है, बशर्ते रिवर्स आर्ग्युमेंट 'सही' है. ऐसे में ऑर्डर का घटते क्रम में होना. डेटा को क्रम से लगाना स्थायी होता है: एलिमेंट का मतलब एक जैसा होने पर उनका मूल क्रम एक जैसा बना रहता है.

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

पैरामीटर

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

स्ट्रो

string str(x)

किसी भी ऑब्जेक्ट को स्ट्रिंग में बदलता है. यह डीबग करने के लिए उपयोगी है.

str("ab") == "ab"
str(8) == "8"

पैरामीटर

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

Tag_class (टैग_श्रेणी)

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

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

पैरामीटर

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

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

doc डिफ़ॉल्ट = ''
टैग क्लास की जानकारी जिसे दस्तावेज़ जनरेट करने वाले टूल से निकाला जा सकता है.

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

टपल

tuple tuple(x=())

दिए गए इटरेबल वैल्यू वाले एलिमेंट के साथ एक ट्यूलिप मिलता है.

tuple([1, 2]) == (1, 2)
tuple((2, 3, 2)) == (2, 3, 2)
tuple({5: "a", 2: "b", 4: "c"}) == (5, 2, 4)

पैरामीटर

पैरामीटर	ब्यौरा
`x`	डिफ़ॉल्ट = () कन्वर्ट किया जाने वाला ऑब्जेक्ट.

टाइप

string type(x)

अपने तर्क के टाइप का नाम दिखाता है. यह डीबग करने और टाइप जांचने के लिए उपयोगी है. उदाहरण:

type(2) == "int"
type([1]) == "list"
type(struct(a = 2)) == "struct"

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

if type(x) == type([]):  # if x is a list

पैरामीटर

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

यूज़_एक्सटेंशन

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

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

पैरामीटर

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

Use_repo

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

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

पैरामीटर

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

कार्यस्थान

None workspace(name, managed_directories={})

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

इस फ़ाइल फ़ोल्डर का नाम सेट करता है. फ़ाइल फ़ोल्डर के नाम, प्रोजेक्ट के Java-पैकेज की शैली में होने चाहिए.इनमें सेपरेटर के तौर पर अंडरस्कोर का इस्तेमाल करें. जैसे, github.com/bazerbuild/bazen को com_github_bazerbuild_bazen का इस्तेमाल करना चाहिए.

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

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

पैरामीटर

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

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

managed_directories डिफ़ॉल्ट = {}
उन स्ट्रिंग के लिए मैपिंग के बारे में बताने के लिए (स्ट्रिंग की सूची की स्ट्रिंग) डिक्ट करें (डायरेक्ट्री रूट के लिए) जो इंक्रीमेंटल तरीके से अपडेट होती हैं. मैनेज की जा रही डायरेक्ट्री को सोर्स ट्री से बाहर रखा जाना चाहिए. इसके लिए, उन्हें या उनकी पैरंट डायरेक्ट्री को .bazenignore फ़ाइल में दिखाएं.

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

zip

list zip(*args)

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