ग्लोबल

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

सदस्य

• all
• analysis_test_transition
• any
• archive_override
• aspect
• bazel_dep
• बाइंड करें
• bool
• configuration_field
• depset
• dict
• dir
• enumerate
• exec_group
• fail
• फ़्लोट
• getattr
• git_override
• hasattr
• हैश
• int
• len
• list
• local_path_override
• max
• मिनट
• मॉड्यूल
• module_extension
• multiple_version_override
• print
• सेवा देने वाली कंपनी
• range
• register_execution_platforms()
• register_execution_platforms(dev_dependency)
• register_toolchains()
• register_toolchains(dev_dependency)
• repository_rule
• repr
• रिवर्स
• नियम
• चुनें
• single_version_override
• क्रम में लगाए गए
• str
• tag_class
• ट्यूपल
• टाइप
• use_extension
• use_repo
• विज़िबिलिटी
• फ़ाइल फ़ोल्डर
• zip

सभी

bool all(elements)

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

पैरामीटर

analysis_test_transition

transition analysis_test_transition(settings)

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

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

पैरामीटर

कोई

bool any(elements)

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

पैरामीटर

archive_override

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

पैरामीटर

आसपेक्ट

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)

पैरामीटर

bazel_dep

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

पैरामीटर

बाइंड

None bind(name, actual=None)

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

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

पैरामीटर

बूल

bool bool(x=False)

पैरामीटर

configuration_field

LateBoundDefault configuration_field(fragment, name)

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

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

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

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

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

पैरामीटर

depset

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

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

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

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

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

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

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

पैरामीटर

dict

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

पैरामीटर

dir

list dir(x)

पैरामीटर

enumerate

list enumerate(list, start=0)

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

पैरामीटर

exec_group

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

पैरामीटर

फ़ेल

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

पैरामीटर

फ़्लोट

float float(x=unbound)

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

पैरामीटर

getattr

unknown getattr(x, name, default=unbound)

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

पैरामीटर

git_override

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

पैरामीटर

hasattr

bool hasattr(x, name)

hasattr(ctx.attr, "myattr")

पैरामीटर

हैश

int hash(value)

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

पैरामीटर

int

int int(x, base=unbound)

• अगर x पहले से ही int है, तो int उसे बिना किसी बदलाव के दिखाता है.
• अगर x बूल है, तो int True के लिए 1 और False के लिए 0 दिखाता है.
• अगर x एक स्ट्रिंग है, तो इसका फ़ॉर्मैट <sign><prefix><digits> होना चाहिए. <sign>, "+", "-" या खाली हो (जिसे पॉज़िटिव के तौर पर समझा जाता है). <digits>, 0 से लेकर base - 1 तक के अंकों का क्रम होता है. इसमें 10 से 35 तक के अंकों के तौर पर, a से z (या A से Z) अक्षरों का इस्तेमाल किया जाता है. अगर base 2/8/16 है, तो <prefix> ज़रूरी नहीं है और यह क्रमशः 0b/0o/0x (या इसके बराबर, 0B/0O/0X) हो सकता है; अगर base इन बेस या खास वैल्यू 0 के अलावा कोई दूसरी वैल्यू है, तो प्रीफ़िक्स खाली होना चाहिए. अगर base 0 है, तो स्ट्रिंग को पूर्णांक के लिटरल के तौर पर समझा जाता है. इसका मतलब है कि प्रीफ़िक्स के इस्तेमाल के आधार पर, 2/8/10/16 में से कोई एक बेस चुना जाता है. अगर base 0 है, तो किसी प्रीफ़िक्स का इस्तेमाल नहीं किया जाता. साथ ही, अगर एक से ज़्यादा अंक हैं, तो शुरुआती अंक 0 नहीं हो सकता. ऐसा ऑक्टल और दशमलव के बीच भ्रम से बचने के लिए किया जाता है. स्ट्रिंग से दिखाई गई संख्या का साइज़, int टाइप के लिए तय की गई सीमा के अंदर होना चाहिए.
• अगर x कोई फ़्लोट है, तो int फ़्लोट की पूर्णांक वैल्यू दिखाता है. साथ ही, वैल्यू को शून्य के आस-पास राउंड करता है. अगर x कोई फ़ाइनाइट वैल्यू (NaN या इनफ़िनिटी) नहीं है, तो गड़बड़ी का मैसेज दिखता है.

उदाहरण:

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

पैरामीटर

len

int len(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]

पैरामीटर

local_path_override

None local_path_override(module_name, path)

पैरामीटर

अधिकतम

unknown max(*args)

max(2, 5, 4) == 5
max([5, 6, 3]) == 6

पैरामीटर

कम से कम

unknown min(*args)

min(2, 5, 4) == 2
min([5, 6, 3]) == 3

पैरामीटर

मॉड्यूल

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

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

पैरामीटर

module_extension

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

पैरामीटर

multiple_version_override

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

पैरामीटर

प्रिंट करें

None print(sep=" ", *args)

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

पैरामीटर

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 पैरामीटर के बारे में चर्चा देखें.

पैरामीटर

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

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

सीमा

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

range(4) == [0, 1, 2, 3]
range(3, 9, 2) == [3, 5, 7]
range(3, 0, -1) == [3, 2, 1]

पैरामीटर

register_execution_platforms()

None register_execution_platforms(*platform_labels)

पैरामीटर

register_execution_platforms(dev_dependency)

None register_execution_platforms(dev_dependency=False, *platform_labels)

पैरामीटर

register_toolchains()

None register_toolchains(*toolchain_labels)

पैरामीटर

register_toolchains(dev_dependency)

None register_toolchains(dev_dependency=False, *toolchain_labels)

पैरामीटर

repository_rule

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

पैरामीटर

repr

string repr(x)

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

पैरामीटर

रद्द कर दिया गया

list reversed(sequence)

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

पैरामीटर

नियम

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)

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

जांच के नियमों का नाम _test पर खत्म होना चाहिए. हालांकि, अन्य सभी नियमों का नाम ऐसा नहीं होना चाहिए. (यह पाबंदी सिर्फ़ नियमों पर लागू होती है, उनके टारगेट पर नहीं.)

पैरामीटर

चुनें

unknown select(x, no_match_error='')

पैरामीटर

single_version_override

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

पैरामीटर

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

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

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

पैरामीटर

str

string str(x)

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

पैरामीटर

tag_class

tag_class tag_class(attrs={}, *, 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)

पैरामीटर

टाइप

string type(x)

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

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

पैरामीटर

use_extension

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

पैरामीटर

use_repo

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

पैरामीटर

कैसा दिखाई दे

None visibility(value)

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

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

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

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

पैरामीटर

कार्यस्थान

None workspace(name)

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

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

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

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

पैरामीटर

zip

list zip(*args)

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)]

पैरामीटर