ग्लोबल

सदस्य

• सभी
• analysis_test_transition
• any
• archive_override
• aspect
• bazel_dep
• बाइंड करें
• bool
• configuration_field
• depset
• dict
• dir
• enumerate
• exec_group
• फ़ेल
• फ़्लोट
• getattr
• git_override
• hasattr
• हैश
• int
• len
• list
• local_path_override
• max
• मिनट
• मॉड्यूल
• module_extension
• multiple_version_override
• print
• सेवा देने वाली कंपनी
• रेंज
• register_execution_platforms()
• register_execution_platforms(dev_dependency)
• register_toolchains()
• register_toolchains(dev_dependency)
• repository_rule(implementation, attrs, local, environ, configure, remotable, doc)
• repository_rule(implementation, attrs, local, environ, configure, remotable, doc)
• 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='')

पैरामीटर

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(implementation, attrs, local, environ, configure, remotable, doc)

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

पैरामीटर

repository_rule(implementation, attrs, local, environ, configure, remotable, doc)

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

पैरामीटर