query stringlengths 9 3.4k | document stringlengths 9 87.4k | metadata dict | negatives listlengths 4 101 | negative_scores listlengths 4 101 | document_score stringlengths 3 10 | document_rank stringclasses 102 values |
|---|---|---|---|---|---|---|
Ensure admin can't credit negative tickets to a user | def test_credit_ticket_negative_int(self):
user = UserFactory()
self.assertEqual(user.tickets, 1)
nb_tickets_to_add = -5
data = {
'nb_tickets': nb_tickets_to_add,
}
self.client.force_authenticate(user=self.admin)
response = self.client.post(
reverse(
'user-credit-tickets',
kwargs={'pk': user.id},
),
data,
format='json',
)
self.assertEqual(
response.status_code,
status.HTTP_400_BAD_REQUEST,
) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_credit_ticket_as_admin(self):\n user = UserFactory()\n self.assertEqual(user.tickets, 1)\n nb_tickets_to_add = 5\n data = {\n 'nb_tickets': nb_tickets_to_add,\n }\n\n self.client.force_authenticate(user=self.admin)\n response = self.client.post(\... | [
"0.69149536",
"0.65459514",
"0.63113207",
"0.63042814",
"0.617169",
"0.6162346",
"0.60777926",
"0.60088956",
"0.5990186",
"0.5983708",
"0.59674823",
"0.59468544",
"0.59359336",
"0.59180915",
"0.5916562",
"0.58903867",
"0.58831507",
"0.58831507",
"0.58763945",
"0.58660877",
"0... | 0.73568875 | 0 |
Convert a django model to a Python dictionary. | def model_to_dict(instance):
opts = instance._meta
data = {}
for f in opts.concrete_fields + opts.many_to_many:
if isinstance(f, ManyToManyField):
if instance.pk is None:
data[f.name] = []
else:
data[f.name] = list(f.value_from_object(instance).values_list('pk', flat=True))
else:
data[f.name] = f.value_from_object(instance)
return data | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def serialize(model):\n # first we get the names of all the columns on your model\n columns = [c.key for c in class_mapper(model.__class__).columns]\n # then we return their values in a dict\n return dict((c, getattr(model, c)) for c in columns)",
"def serialize(model):\n # first we get the names ... | [
"0.74951124",
"0.74951124",
"0.74951124",
"0.7297441",
"0.71069056",
"0.70827776",
"0.701292",
"0.69411165",
"0.67609876",
"0.6588779",
"0.65625906",
"0.6549681",
"0.65171313",
"0.6515657",
"0.6490812",
"0.6461443",
"0.6450688",
"0.64377403",
"0.6435162",
"0.64019275",
"0.633... | 0.6789229 | 8 |
Returns a JSON response, transforming 'context' to make the payload. | def render_to_json_response(self, context, **response_kwargs):
response_kwargs.update(dict(json_dumps_params=dict(ensure_ascii=False)))
return JsonResponse(self.safe_json(context), **response_kwargs) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def render_to_response(self, context):\n return self.get_json_response(self.convert_context_to_json(context))",
"def render_to_response(self, context):\n\t\treturn self.get_json_response(self.convert_context_to_json(context))",
"def render_to_json_response(self, context, **response_kwargs):\n ret... | [
"0.7898263",
"0.7824009",
"0.76766837",
"0.76766837",
"0.7560496",
"0.75058556",
"0.74115",
"0.74115",
"0.74115",
"0.74115",
"0.74115",
"0.73821956",
"0.73662317",
"0.7348336",
"0.7309291",
"0.7130906",
"0.6941217",
"0.6892298",
"0.6722085",
"0.663044",
"0.663044",
"0.66304... | 0.7347456 | 14 |
Returns an object that will be serialized as JSON by json.dumps(). | def safe_json(self, context):
serialize_context = dict()
for key, obj in context.items():
if isinstance(obj.__class__, ModelBase):
if hasattr(obj, 'serialize') and callable(getattr(obj, 'serialize')):
serialize_context[key] = obj.serialize()
else:
serialize_context[key] = model_to_dict(obj)
elif isinstance(obj, QuerySet):
serialize_context[key] = [o.serialize() for o in obj if hasattr(o, 'serialize')]
if len(serialize_context[key]) != len(obj):
serialize_context[key] = [model_to_dict(o) for o in obj]
elif key == 'extra':
serialize_context[key] = obj
# elif key == 'view':
# continue
# else:
# serialize_context[key] = obj
return dict(success=True, data=serialize_context) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def toJSON(cls, obj):\n return json.dumps(obj)",
"def serialize(self, obj):\n return json.dumps(obj)",
"def toJSON(self):\n return json.dumps(self, default=lambda o: o.__dict__)",
"def to_json(self, *args, **kwargs):\n return json.dumps(self.serialize(primitive=True), *args, **kwa... | [
"0.78144574",
"0.7662045",
"0.76151204",
"0.74891126",
"0.7480223",
"0.7432419",
"0.7416268",
"0.7400361",
"0.7388459",
"0.7362635",
"0.73541415",
"0.73291653",
"0.7320688",
"0.7310187",
"0.73080957",
"0.727898",
"0.727898",
"0.72756785",
"0.7259399",
"0.72041607",
"0.7153282... | 0.0 | -1 |
Return the error as a JSON response. | def throw_error(self, error, status_code=400, **extra):
data = dict(success=False, data=dict(message=error, **extra))
raise ShortCircuitHttpChain(response=JsonResponse(data, status=status_code)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def json_error(message):\n return json_response(isError=True, message=message)",
"def handle_error(error):\n response = jsonify(error.to_dict())\n response.status_code = error.status_code\n return response",
"def jsonify_exception(error: HTTPException) -> Response:\n exc_resp = error.get_response()\n ... | [
"0.7800289",
"0.77307755",
"0.7713259",
"0.7626865",
"0.7596588",
"0.75559425",
"0.7506786",
"0.74428797",
"0.7394055",
"0.73734087",
"0.7364901",
"0.73521066",
"0.7298466",
"0.72667325",
"0.7261724",
"0.7238622",
"0.7220519",
"0.72151345",
"0.71981364",
"0.7188909",
"0.71853... | 0.0 | -1 |
Returns a value in a nested associative structure, where `ks` is a sequence of keys. Returns `None`, if the key is not present, or the `default` value, if supplied. | def get_in(d, ks, default=None):
*ks_, last = ks
d_ = d
for k in ks_:
if type(d_) != dict or k not in d_:
return default
d_ = d_[k]
if type(d_) == dict:
return d_.get(last, default)
return default | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def do_get(d, *ks, **kwargs):\n try:\n res = reduce (lambda acc, k: acc[k], ks, d)\n except (KeyError, TypeError):\n if \"default\" in kwargs:\n return kwargs[\"default\"]\n else:\n t, v, tb = sys.exc_info()\n if t == KeyError:\n msg = \"ne... | [
"0.66533864",
"0.6498185",
"0.63302475",
"0.6233764",
"0.62260294",
"0.6200173",
"0.6188591",
"0.6064579",
"0.604745",
"0.6032425",
"0.6025601",
"0.60055006",
"0.6003231",
"0.59860516",
"0.59845686",
"0.5940937",
"0.59354126",
"0.5911613",
"0.5899532",
"0.5888177",
"0.5871198... | 0.7002469 | 0 |
Associates a value in a nested associative structure, where `ks` is a sequence of keys and `v` is the new value, and returns a nested structure. If any levels do not exist, `dict`s will be created. | def assoc_in(d, ks, v):
*ks_, last = ks
d_ = d
for k in ks_:
if k not in d_:
d_[k] = {}
d_ = d_[k]
d_[last] = v
return d | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def nested_set(d: t.Dict, keys: t.Sequence[str], value: t.Any) -> t.Dict:\n if not keys:\n return d\n\n if len(keys) == 1:\n d[keys[0]] = value\n return d\n\n subd = d\n for key in keys[:-1]:\n if key not in subd:\n subd = subd.setdefault(key, {})\n else:\n... | [
"0.6572794",
"0.63907355",
"0.6336366",
"0.62305176",
"0.6214868",
"0.61555994",
"0.59882414",
"0.59860635",
"0.5962133",
"0.590882",
"0.58780855",
"0.5875496",
"0.5871324",
"0.58609086",
"0.58548045",
"0.582082",
"0.5820722",
"0.5794419",
"0.5784228",
"0.5780479",
"0.5768079... | 0.70314556 | 0 |
Returns a function that applies other functions in sequence. `compose(f, g, h)(x, y)` is the same as `f(g(h(x, y)))`. If no arguments are provided, the identity function is returned. | def compose(*funcs):
if not funcs:
return identity
def wrapper(*args, **kwargs):
fst, *rest = funcs
ret = fst(*args, **kwargs)
for f in rest:
ret = f(ret)
return ret
return wrapper | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def compose(f,g):\n def composed(x):\n return f(g(x))\n\n return composed",
"def compose(*functions):\n head, *tail = functions\n return head if not tail else lambda *args, **kwargs: head(compose(*tail)(*args, **kwargs))",
"def compose(f, g):\n return lambda *args, **kwargs: f(g(*args, **... | [
"0.81175",
"0.7936012",
"0.7929636",
"0.7896892",
"0.7852169",
"0.7835173",
"0.7823427",
"0.78121835",
"0.770165",
"0.7692192",
"0.76420945",
"0.7633142",
"0.758357",
"0.75239193",
"0.7490701",
"0.7352416",
"0.73518074",
"0.72612894",
"0.7251908",
"0.7217228",
"0.7167121",
... | 0.7443417 | 15 |
Print a `middleware_name` with a right arrow if `_VERBOSE_MODE` is on. | def _print_inwards(middleware_name):
if _VERBOSE_MODE:
print('{}--->'.format(middleware_name)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _print_outwards(middleware_name):\n if _VERBOSE_MODE:\n print('<---{}'.format(middleware_name))",
"def named(name):\n\n def new_annotate(mware):\n def new_middleware(handler):\n\n new_handler = mware(handler)\n\n def verbose_handler(ctx):\n _print_inwa... | [
"0.8443991",
"0.59464276",
"0.5638737",
"0.560429",
"0.5601479",
"0.5314763",
"0.5303445",
"0.5292417",
"0.528729",
"0.5279358",
"0.52545273",
"0.5227158",
"0.5212542",
"0.5212174",
"0.52042764",
"0.51971495",
"0.5194814",
"0.5194814",
"0.5190525",
"0.5150018",
"0.5143002",
... | 0.85856086 | 0 |
Print a `middleware_name` with a left arrow if `_VERBOSE_MODE` is on. | def _print_outwards(middleware_name):
if _VERBOSE_MODE:
print('<---{}'.format(middleware_name)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _print_inwards(middleware_name):\n if _VERBOSE_MODE:\n print('{}--->'.format(middleware_name))",
"def named(name):\n\n def new_annotate(mware):\n def new_middleware(handler):\n\n new_handler = mware(handler)\n\n def verbose_handler(ctx):\n _print_inwar... | [
"0.85265154",
"0.59112906",
"0.5598949",
"0.5553952",
"0.5419853",
"0.52704614",
"0.52555555",
"0.5231697",
"0.5227046",
"0.5205608",
"0.5202568",
"0.5120578",
"0.51193374",
"0.5041665",
"0.5041665",
"0.50310254",
"0.50283116",
"0.50258374",
"0.5003555",
"0.49982905",
"0.4993... | 0.8331396 | 1 |
This function is not very useful, so it's advised not to use it, because it can be removed at any time before 1.0.0 | def mw_from_cm(name, cm_constructor, ks=None, ctx_args={}, **kwargs):
def new_middleware(handler):
def new_handler(ctx):
_print_inwards(name)
ctx_kwargs = {}
for k, ks_ in ctx_args:
ctx_kwargs[k] = get_in(ctx, ks_)
with cm_constructor(**ctx_kwargs, **kwargs) as v:
if ks:
assoc_in(ctx, ks, v)
new_ctx = handler(ctx)
_print_outwards(name)
return new_ctx
return new_handler
return new_middleware | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_4_4_1_1(self):\n pass",
"def regular(self):",
"def __call__(self) -> None:",
"def exo2():",
"def degibber(self):",
"def exercise_b2_53():\r\n pass",
"def exercise_b2_106():\r\n pass",
"def _prepare(self):",
"def _prepare(self):",
"def nulltest():",
"def support(self):",
... | [
"0.54195523",
"0.53025854",
"0.5283479",
"0.52821845",
"0.5257055",
"0.5218573",
"0.51446503",
"0.5124683",
"0.5124683",
"0.51094174",
"0.5101899",
"0.5096671",
"0.5088057",
"0.50846183",
"0.50812197",
"0.507752",
"0.507305",
"0.507305",
"0.507305",
"0.507305",
"0.507305",
... | 0.0 | -1 |
This function is used to decorate generators with exactly two `yield` statements and turn them into middleware. For examples see documentation to this module and tests. Extra arguments beyond name are passed to the generator that is being decorated during instantiation. If they are not defined during interpretation of this module, then this function can be used as a regular callable and not as an annotation. | def middleware(name, *args, **kwargs):
def new_annotate(g_fn):
def new_middleware(handler):
def new_handler(ctx):
_print_inwards(name)
g = g_fn(ctx, *args, **kwargs)
changed_ctx = next(g)
new_ctx = handler(changed_ctx)
last_ctx = g.send(new_ctx)
_print_outwards(name)
return last_ctx
return new_handler
return new_middleware
return new_annotate | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def consumer(func):\n\n from functools import wraps\n\n @wraps(func)\n def wrapper(*args,**kw):\n gen = func(*args, **kw)\n gen.next()\n return gen\n return wrapper",
"def named(name):\n\n def new_annotate(mware):\n def new_middleware(handler):\n\n new_handle... | [
"0.61025184",
"0.6074266",
"0.60481",
"0.59272635",
"0.587607",
"0.57251585",
"0.5700559",
"0.565485",
"0.5628643",
"0.5623533",
"0.55874825",
"0.5568008",
"0.5555406",
"0.5531668",
"0.55288386",
"0.55071145",
"0.55039895",
"0.54155296",
"0.53743196",
"0.5331949",
"0.5328424"... | 0.68625414 | 0 |
This function is used to decorate middleware functions in order for their before and after sections to show up during a verbose run. For examples see documentation to this module and tests. | def named(name):
def new_annotate(mware):
def new_middleware(handler):
new_handler = mware(handler)
def verbose_handler(ctx):
_print_inwards(name)
new_ctx = new_handler(ctx)
_print_outwards(name)
return new_ctx
return verbose_handler
return new_middleware
return new_annotate | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def middleware(name, *args, **kwargs):\n\n def new_annotate(g_fn):\n def new_middleware(handler):\n def new_handler(ctx):\n _print_inwards(name)\n\n g = g_fn(ctx, *args, **kwargs)\n\n changed_ctx = next(g)\n new_ctx = handler(changed_... | [
"0.65105826",
"0.62661564",
"0.61409885",
"0.60957867",
"0.59238327",
"0.59235173",
"0.5898055",
"0.58747447",
"0.5837454",
"0.5817847",
"0.5798494",
"0.57882106",
"0.5778773",
"0.5720582",
"0.57170993",
"0.5715777",
"0.5690158",
"0.5687903",
"0.568684",
"0.5677401",
"0.56587... | 0.59098107 | 6 |
This function layers `middleware` left to right around the `handler` and calls it all with `ctx` as an argument. Setting `verbose` to `True` prints when handlers start their before and after sections. | def wrap_and_call(ctx, handler, *middleware, verbose=False):
global _VERBOSE_MODE
_VERBOSE_MODE = verbose
middleware_ = list(middleware)
return compose(*reversed(middleware_))(handler)(ctx) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _print_inwards(middleware_name):\n if _VERBOSE_MODE:\n print('{}--->'.format(middleware_name))",
"def _print_outwards(middleware_name):\n if _VERBOSE_MODE:\n print('<---{}'.format(middleware_name))",
"def middleware(name, *args, **kwargs):\n\n def new_annotate(g_fn):\n def new... | [
"0.61028963",
"0.5979751",
"0.553887",
"0.5415598",
"0.5203609",
"0.5072327",
"0.5070068",
"0.50015277",
"0.4928767",
"0.4807581",
"0.47827762",
"0.4747526",
"0.46803856",
"0.46597835",
"0.46321198",
"0.46194658",
"0.4610729",
"0.4543063",
"0.4516026",
"0.45135337",
"0.450970... | 0.7304824 | 0 |
transforms airspace files from and to open air format kml (google earth) | def __init__(self, full_path_of_source=''):
if len(full_path_of_source) == 0:
full_path_of_source = fileopenbox(default=os.path.curdir, filetypes=["*.txt", "*.kml"])
if full_path_of_source is None:
print('Airspace conversion was aborted by the user')
quit()
# set template (this should not be changed)
self.full_path_kml_template = r'Thermal_Map_Template5.kml' # set template file here: Folder must be named "good" and "bad"
self.airspaces = [] # airspace container
self.kml_template = {'header': [], 'good': [], 'bad': [], # will be filled after loading template
'good_subdivided': {'head':[], 'placemark': [], 'tail': []},
'bad_subdivided': {'head':[], 'placemark': [], 'tail': []}}
self.txt_lines = [] # airspace file in open airspace format
self.kml_lines = [] # airspace file in kml format
""" handle conversion from and to KML / airspace format"""
if full_path_of_source.lower().endswith('.kml'):
self.kml_2_open_airspace_and_json_format(full_path_of_source)
if full_path_of_source.lower().endswith('.txt'):
self.open_airspace_format_2_kml(full_path_of_source)
self.plot_all() # works for now only for TXT input | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def open_airspace_format_2_kml(self, source_file_txt):\n # load template for kml file\n self.load_kml_template(self.full_path_kml_template)\n # load airspace source\n self.load_airspace_open_air_format(source_file_txt)\n\n self.kml_lines = self.kml_template['header']\n sel... | [
"0.726774",
"0.66690755",
"0.66451776",
"0.6530712",
"0.6462909",
"0.62168556",
"0.5969086",
"0.5435771",
"0.53939426",
"0.5367328",
"0.53303623",
"0.53256774",
"0.5312925",
"0.5307262",
"0.52901286",
"0.5280847",
"0.52789676",
"0.5241874",
"0.5188435",
"0.51814985",
"0.51693... | 0.6455014 | 5 |
converts kml files to open airspace files | def kml_2_open_airspace_and_json_format(self, full_path):
# read file
f = open(full_path,'r')
kml = f.readlines()
f.close()
# find airspaces
"""Placemark >
< name > Bremen - Blumenthal
Thermikplatte < / name >
< styleUrl > # inline10</styleUrl>
< Polygon >
< tessellate > 1 < / tessellate >
< outerBoundaryIs >
< LinearRing >
< coordinates >
8.529121049900063, 53.19549566929423, 0
8.52324583919868, 53.21131939607898, 0
8.545439298799483, 53.23055800702935, 0
8.588991466114615, 53.23047069814625, 0
8.575289966189502, 53.20745451706468, 0
8.560633120477348, 53.19724609335408, 0
8.529121049900063, 53.19549566929423, 0
< / coordinates >
< / LinearRing >
< / outerBoundaryIs >
< / Polygon >
< / Placemark >"""
container = []
idxLine = 0
did_not_pass_main_folder = True
list_of_airspace_types_included = []
while idxLine < len(kml):
#print(kml[idxLine])
#if '<Folder>' in kml[idxLine] and did_not_pass_main_folder:
# # we have to jump over the first folder
# print(f'Reading everything inside folder: {kml[idxLine]}')
# did_not_pass_main_folder = False
if '<Folder>' in kml[idxLine]: # begin of airspace
as_type = kml[idxLine+1].replace('\t','').replace('<name>','').replace('</name>\n','') # <name>B</name>
print('Reading AS-types: ' + as_type)
list_of_airspace_types_included.append(as_type)
#if not (as_type == 'A' or as_type == 'B'):
# print('#### Check Folder / Airspace Types, must be "A" or "B" and try again (current %s)' % as_type)
# msgbox('Check Folder / Airspace Types, are not "A" or "B" (current %s). Airspace E will be used for export.' % as_type)
# as_type = 'E'
if '<Placemark' in kml[idxLine]: # begin of airspace
container = []
if '</Placemark' in kml[idxLine]: # end of airspace
# make sure only Polygons are stored
for as_line in container:
if '<Polygon>' in as_line:
idx_lookAt_start = None
for idx, line_of_container in enumerate(container):
if "<LookAt>" in line_of_container:
idx_lookAt_start = idx
if "</LookAt>" in line_of_container:
idx_lookAt_end = idx
# Remove lookAt lines if necessary
if idx_lookAt_start:
container = container[0:idx_lookAt_start] + container[idx_lookAt_end+1::] # cut out look at part
# append airspace to airspace list as airspace class
self.airspaces.append(Airspace(lines=container, file_type='kml', as_type=as_type))
container.append(kml[idxLine])
idxLine += 1
print('Loaded %d airspaces from KML-file (%s)' %(len(self.airspaces),full_path))
# summary
outlines = ['* KML conversion file, rename this line']
json_dict = {"circles": [], "polygons": []}
for airspace in self.airspaces:
# prepare open-airspace formate
outlines.append('\n\n') # separate airspaces
outlines.extend(airspace.txt_lines)
# prepare json
json_dict['polygons'].append(airspace.json_dict)
# write open airspace format
target_path = full_path[:-4] + '_converted.txt'
# uisave dialog
target_path = filesavebox(default=target_path, filetypes="*.txt")
if target_path is None:
print('Airspace conversion was aborted by the user')
quit()
f = open(target_path,'w')
f.writelines(outlines)
f.close()
print('Result was written to: %s' % target_path)
# write json:
target_path_json = target_path[:-4] + '.json'
json_string = json.dumps(json_dict)
json_file = open(target_path_json, "w")
json_file.write(json_string)
json_file.close()
# write list of airspace files for index.html for leaflet map
print('The following airspace types have been converted:')
print(list_of_airspace_types_included) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def open_airspace_format_2_kml(self, source_file_txt):\n # load template for kml file\n self.load_kml_template(self.full_path_kml_template)\n # load airspace source\n self.load_airspace_open_air_format(source_file_txt)\n\n self.kml_lines = self.kml_template['header']\n sel... | [
"0.7400537",
"0.66784334",
"0.64540035",
"0.62201595",
"0.6089382",
"0.60512364",
"0.5901473",
"0.5742026",
"0.5689828",
"0.566298",
"0.5614185",
"0.5548671",
"0.55181766",
"0.54977727",
"0.54335207",
"0.54022497",
"0.53411245",
"0.5290524",
"0.51947296",
"0.5126708",
"0.5105... | 0.68759656 | 1 |
transforms airspace in open air format to kml for google earth | def open_airspace_format_2_kml(self, source_file_txt):
# load template for kml file
self.load_kml_template(self.full_path_kml_template)
# load airspace source
self.load_airspace_open_air_format(source_file_txt)
self.kml_lines = self.kml_template['header']
self.kml_lines.extend(self.kml_template['good_subdivided']['head'])
# collect all A and B kml lines
kml_A = []
kml_B = []
# transform airspaces and attach to A and B collect-lists
for airspace in self.airspaces:
airspace.make_kml_format(self.kml_template)
if airspace.as_type == 'A':
kml_A.extend(airspace.kml_lines)
if airspace.as_type == 'B':
kml_B.extend(airspace.kml_lines)
self.kml_lines.extend(kml_A)
self.kml_lines.extend(self.kml_template['good_subdivided']['tail'])
# start B part
self.kml_lines.extend(self.kml_template['bad_subdivided']['head'])
self.kml_lines.extend(kml_B)
self.kml_lines.extend(self.kml_template['bad_subdivided']['tail'])
full_path_kml = source_file_txt[:-4] + '_converted.kml'
# uisave dialog
full_path_kml = filesavebox(default=full_path_kml, filetypes="*.kml")
if full_path_kml is None:
print('Airspace conversion was aborted by the user')
quit()
# write to file
f = open(full_path_kml, 'w')
f.writelines(self.kml_lines)
f.close()
print('Resulting KML files was saved to: %s' % full_path_kml) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def make_open_airspace_format(self):\n # Extract coordinates from KML\n for idxline in range(len(self.kml_lines)):\n if '<name>' in self.kml_lines[idxline]:\n self.name = self.kml_lines[idxline].replace('\\t', '').replace('<name>', '').replace('</name>', '').replace('\\n',''... | [
"0.70086014",
"0.6861497",
"0.61510426",
"0.5941489",
"0.59399176",
"0.59311515",
"0.58990943",
"0.5860803",
"0.5813129",
"0.5499347",
"0.54266125",
"0.5407943",
"0.5396494",
"0.5380504",
"0.53745914",
"0.5275087",
"0.52564675",
"0.5236269",
"0.51970184",
"0.516719",
"0.51457... | 0.6388248 | 2 |
generates json format for web page visualization | def make_json_airspace_format(self):
# The previous fct make_open_airspace_format already stored, coordinates_kml, name and type
# This data is collected in an dictionary, which then is stored as json.
# initialize dict
coordinates_as_list_of_floats = []
# run through coordinates
coordinates_as_list_of_floats = []
for coo_pt in self.coordinates_kml.split(' ')[:-1]:
lat_long = coo_pt.split(',')
coordinates_as_list_of_floats.append([float(lat_long[1]), float(lat_long[0])])
# make json dict
# rename name if not thermal space
if self.name.startswith('TS_') and not (self.as_type == 'A' or self.as_type == 'B'):
name_for_json = self.name[3:]
else:
name_for_json = self.name
# rename airspace type for json:
if self.as_type == 'A':
self.as_type = 'Good_thermals'
if self.as_type == 'B':
self.as_type = 'Bad_thermals'
self.json_dict = {"AL": "FL98", "AH": "FL99", "AC": self.as_type, "AN": name_for_json, "data": coordinates_as_list_of_floats} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def json(self) -> PageJson:\n\n json: PageJson = {}\n json[\"id\"] = self.id\n json[\"cells\"] = [cell.json() for cell in self.cells]\n json[\"data\"] = self.data\n return json",
"def json_view(self, recursive=False):\n\n context = self.context.aq_inner\n data = s... | [
"0.6761482",
"0.67505777",
"0.63986033",
"0.6352996",
"0.6321673",
"0.63178545",
"0.62238723",
"0.62133825",
"0.6212409",
"0.6167629",
"0.6154408",
"0.6149698",
"0.612473",
"0.61238694",
"0.6115323",
"0.60985136",
"0.6090451",
"0.60752165",
"0.6065477",
"0.606487",
"0.6025067... | 0.0 | -1 |
convert to open airspace format | def make_open_airspace_format(self):
# Extract coordinates from KML
for idxline in range(len(self.kml_lines)):
if '<name>' in self.kml_lines[idxline]:
self.name = self.kml_lines[idxline].replace('\t', '').replace('<name>', '').replace('</name>', '').replace('\n','')
if not self.name.startswith('TS'):
self.name = 'TS_' + self.name
print('Type: %s | Name: %s' % (self.as_type, self.name))
if '<coordinates>' in self.kml_lines[idxline]:
self.coordinates_kml = self.kml_lines[idxline + 1].replace('\t', '').replace('\n', '')
break
# start conversion to airspace format
""" AC A
AN TS_Erzgeb
AL FL98
AH FL99
DP 50:26:22 N 012:17:59 E
DP 50:25:25 N 012:18:26 E
DP 50:24:40 N 012:19:01 E
DP 50:24:06 N 012:19:46 E"""
# AC A
self.txt_lines.append('AC %s\n' % self.as_type)
# AN TS_Erzgeb
self.txt_lines.append('AN %s\n' % self.name)
# heights
self.txt_lines.append('AL FL98\n')
self.txt_lines.append('AH FL99\n')
# coordinates
for coo_pt in self.coordinates_kml.split(' ')[:-1]:
# Target format: DP 50:26:22 N 012:17:59 E
lat_long = coo_pt.split(',')
# latitude
latDecAsStr = lat_long[1].split('.')
#if '.' not in latDecAsStr: # take care of case "51" instead of "51.123456"
# latDecAsStr += '.000000'
lat_degree = abs(int(latDecAsStr[0]))
#print(f'latDecAsStr {latDecAsStr}')
if len(latDecAsStr)==1:
latDecAsStr.append('0')
lat_secondDec = (float('0.' + latDecAsStr[1])*60) % 1
lat_minute = round((float('0.' + latDecAsStr[1])*60) - lat_secondDec)
lat_second = round(lat_secondDec*60)
cooString = ('DP %02d:%02d:%02d' %(lat_degree,lat_minute,lat_second))
if latDecAsStr[0].startswith('-'):
cooString += ' S'
else:
cooString += ' N'
# longitude
#print(f'converting lat_long {lat_long}')
# take care of case: no decimal sign included, case "11" instead of "11.123456"
if '.' not in lat_long[0]:
lat_long[0] += '.0'
lonDecAsStr = lat_long[0].split('.')
lon_degree = abs(int(lonDecAsStr[0]))
lon_secondDec = (float('0.' + lonDecAsStr[1]) * 60) % 1
lon_minute = round((float('0.' + lonDecAsStr[1]) * 60) - lon_secondDec)
lon_second = round(lon_secondDec * 60)
cooString += (' %03d:%02d:%02d' % (lon_degree, lon_minute, lon_second))
if lonDecAsStr[0].startswith('-'):
cooString += ' W'
else:
cooString += ' E'
cooString += '\n'
self.txt_lines.append(cooString) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def make_json_airspace_format(self):\n # The previous fct make_open_airspace_format already stored, coordinates_kml, name and type\n # This data is collected in an dictionary, which then is stored as json.\n # initialize dict\n coordinates_as_list_of_floats = []\n # run through ... | [
"0.6572235",
"0.5615951",
"0.5423645",
"0.53658104",
"0.51459473",
"0.51208514",
"0.50073093",
"0.5003773",
"0.49911514",
"0.49624845",
"0.48734692",
"0.48479107",
"0.4842932",
"0.48100558",
"0.47674647",
"0.4759654",
"0.47496668",
"0.4749038",
"0.4746655",
"0.4734282",
"0.47... | 0.76431525 | 0 |
uses template in order to make kml format | def make_kml_format(self,kml_template):
if self.as_type == 'A':
self.kml_lines = kml_template['good_subdivided']['placemark']
elif self.as_type == 'B':
self.kml_lines = kml_template['bad_subdivided']['placemark']
else:
print('Unknown airspace type')
# get idx of name and coordinates
idxLine = 0
while idxLine < len(self.kml_lines):
#print(self.kml_lines[idxLine]
if self.kml_lines[idxLine].startswith('\t\t\t\t<name>'): # begin of airspace
idx_name = idxLine
if '\t\t\t\t\t\t\t<coordinates>\n' in self.kml_lines[idxLine]: # begin of airspace
idx_coordinates = idxLine+1
idxLine += 1
# transform coordinates
# add all coordinates: Format is:
# source: 'DP 50:26:22 N 012:17:59 E\n'
# target: 9.025830271397426,53.46493577242719,0 8.986157446488383,53.46952117358134,0
coo_list = [] # collect list of coorinates as strings
for line in self.txt_lines:
if line.startswith('AN'):
self.name = line[3:].replace('\n','')
self.kml_lines[idx_name] = '\t\t\t\t<name>%s</name>\n' % self.name
if line.startswith('DP'):
# lon
lon_deg = float(line[14:17])
lon_min = float(line[18:20])
lon_sec = float(line[21:23])
lon_dec = (lon_sec / 60 + lon_min) / 60 + lon_deg
if line[24] == 'W':
lon_dec *= -1 # negative if west
# lat
lat_deg = float(line[3:5])
lat_min = float(line[6:8])
lat_sec = float(line[9:11])
lat_dec = (lat_sec / 60 + lat_min) / 60 + lat_deg
if line[12] == 'S':
lat_dec *= -1 # negative if west
# attach coordinates
coo_list.append('%1.16f,%1.16f,0 ' % (lon_dec,lat_dec))
# store for later plotting
self.lat_dec.append(lat_dec)
self.lon_dec.append(lon_dec)
# make sure that shape is closed --> first an last point must be the same
if coo_list[0] != coo_list[-1]:
coo_list.append(coo_list[0])
self.lat_dec.append(self.lat_dec[0])
self.lon_dec.append(self.lon_dec[0])
# write coordinate strings into kml
self.kml_lines[idx_coordinates] = '\t\t\t\t\t\t\t\t' # is prefix. Coordinates to be added as string below
for pt in coo_list:
self.kml_lines[idx_coordinates] += pt
print('Converted airspace %s' % self.name) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def generate_document_kml(self, title, content):\n return \"\"\"\\\n<?xml version=\"1.0\" encoding=\"utf-8\"?>\n<kml xmlns=\"http://earth.google.com/kml/2.1\">\n <Document>\n <name>%s</name>\n <description></description>\n <Style>\n <ListStyle id=\"hideChildren\">\n <listItemType>checkHideCh... | [
"0.65473634",
"0.6186442",
"0.59212077",
"0.58994913",
"0.5786561",
"0.5749856",
"0.57343155",
"0.5694609",
"0.56501126",
"0.5589115",
"0.5586314",
"0.5547935",
"0.5522636",
"0.5514267",
"0.5514267",
"0.54982287",
"0.54740417",
"0.54516935",
"0.5447252",
"0.54235315",
"0.5416... | 0.6787827 | 0 |
Plots airspace into figure, reuse open figure if available | def plot(self):
# determine color
if self.as_type=='A':
color4plot = 'g'
elif self.as_type == 'B':
color4plot = 'b'
else:
color4plot = 'k'
# plot
plt.fill(self.lon_dec,self.lat_dec,facecolor=color4plot) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def show_graphs ():\n plt.ylim = (0, 300)\n plt.xlim = (0, 300)\n #Set up lidar plot to figure 1\n lidar_plot = plt.figure (1)\n #Assign title\n plt.title ('Lidar data')\n #Assign data\n plt.imshow (lidar_clean)\n #Set up radar plot to figure 2\n radar_plot = plt.figure (2)\n #Assi... | [
"0.6310482",
"0.626213",
"0.6240595",
"0.62188065",
"0.61812156",
"0.61757153",
"0.61031306",
"0.6088691",
"0.6061382",
"0.59504133",
"0.59478855",
"0.5947725",
"0.594132",
"0.5940302",
"0.59187317",
"0.59125113",
"0.59071434",
"0.5900893",
"0.5887625",
"0.5882247",
"0.587600... | 0.0 | -1 |
Model trained with full vocabulary classification. | def __init__(self, vocab_size: int, embedding_dim: int, hidden_size: int, dropout: float = 0.2,
read_context: bool = False, pad_idx: int = Vocabulary.pad_idx):
super(FullVocabularyModel, self).__init__()
self.embedding = nn.Embedding(vocab_size, embedding_dim, padding_idx=pad_idx)
self.embed_dropout = nn.Dropout(dropout)
self.rnn = nn.LSTM(embedding_dim, hidden_size)
self.linear = nn.Linear(hidden_size, vocab_size)
self.loss_fn = nn.CrossEntropyLoss(ignore_index=pad_idx)
self.vocab_size = vocab_size
self.read_context = read_context
self.pad_idx = pad_idx
initrange = 0.5 / embedding_dim
self.embedding.weight.data.uniform_(-initrange, initrange)
self.embedding.weight.data[pad_idx].zero_() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self):\n self.sess = tf.Session()\n vocab_path = os.path.join(params.data_dir, \"vocab%d\" % params.vocab_size)\n self.vocab, self.rev_vocab = data_utils.initialize_vocabulary(vocab_path)\n self.model = model_utils.create_model(self.sess, True)\n self.model.batch_size = 1 # Respond 1 se... | [
"0.7002918",
"0.69951147",
"0.68627745",
"0.67508525",
"0.66912574",
"0.66359586",
"0.6607676",
"0.6582862",
"0.65730536",
"0.65690607",
"0.65606356",
"0.65052295",
"0.64981496",
"0.6493124",
"0.64924264",
"0.648903",
"0.6479486",
"0.64262235",
"0.6392545",
"0.6390712",
"0.63... | 0.0 | -1 |
Model trained with negative sampling. | def __init__(self, vocab_size: int, embedding_dim: int, dropout: float = 0.2, pad_idx: int = Vocabulary.pad_idx):
super(NegativeSamplingModel, self).__init__()
self.in_embedding = nn.Embedding(vocab_size, embedding_dim, padding_idx=pad_idx)
self.out_embedding = nn.Embedding(vocab_size, embedding_dim, padding_idx=pad_idx)
self.embed_dropout = nn.Dropout(dropout)
self.rnn = nn.LSTM(embedding_dim, embedding_dim)
self.embedding_dim = embedding_dim
self.pad_idx = pad_idx
initrange = 0.5 / embedding_dim
self.in_embedding.weight.data.uniform_(-initrange, initrange)
self.in_embedding.weight.data[pad_idx].zero_()
self.out_embedding.weight.data.uniform_(-initrange, initrange)
self.out_embedding.weight.data[pad_idx].zero_() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def neg_sampling_transform(data):\n train_neg_edge_index = negative_sampling(\n edge_index=data.train_pos_edge_index, num_nodes=data.num_nodes,\n num_neg_samples=data.train_pos_edge_index.size(1))\n data.train_edge_index = torch.cat(\n [data.train_pos_edge_index, train_neg_edge_index], d... | [
"0.6653699",
"0.6541765",
"0.637076",
"0.62263596",
"0.62053776",
"0.61295056",
"0.6102357",
"0.60013276",
"0.5856466",
"0.5846717",
"0.5828895",
"0.58022124",
"0.57946515",
"0.5791492",
"0.5789991",
"0.5780061",
"0.5766371",
"0.576477",
"0.57344276",
"0.5696231",
"0.569474",... | 0.61521417 | 5 |
Negative sampling loss function. | def loss_fn(self, hidden: torch.Tensor, pos_embedded: torch.Tensor, neg_embedded: torch.Tensor,
mask: torch.BoolTensor) -> torch.Tensor:
pos_embedded = pos_embedded[:, None, :] # batch_size * pad_len, 1, embedding_dim
pos_score = self.get_score(pos_embedded, hidden) # batch_size * pad_len
pos_contrib = -F.logsigmoid(pos_score)
neg_score = self.get_score(neg_embedded, hidden) # batch_size * pad_len, neg_count
neg_contrib = -torch.log(1 - torch.sigmoid(neg_score)).mean(dim=-1) # batch_size * pad_len
return torch.masked_select(pos_contrib + neg_contrib, mask).mean() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def negative_gradient(self, y, y_pred, **kargs):",
"def loss(A, Y):\n return A - Y",
"def test_negative_sampling_self_adversarial_loss(self):\n loss_fct = NSSALoss(margin=1.0, adversarial_temperature=1.0)\n self.assertIs(loss_fct._reduction_method, torch.mean)\n\n pos_scores = torch.ten... | [
"0.71352494",
"0.70853186",
"0.7057606",
"0.66854465",
"0.6680998",
"0.666433",
"0.6643865",
"0.65241724",
"0.65200275",
"0.65122724",
"0.6505412",
"0.6476094",
"0.6475439",
"0.64674455",
"0.6447396",
"0.6428077",
"0.6416268",
"0.64070994",
"0.63982755",
"0.6386199",
"0.63691... | 0.0 | -1 |
cast(itkLightObject obj) > itkTernaryAddImageFilterID2ID2ID2ID2_Superclass | def cast(*args):
return _itkTernaryAddImageFilterPython.itkTernaryAddImageFilterID2ID2ID2ID2_Superclass_cast(*args) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def cast(obj: 'itkLightObject') -> \"itkNotImageFilterIF2IF2_Superclass *\":\n return _itkNotImageFilterPython.itkNotImageFilterIF2IF2_Superclass_cast(obj)",
"def itkNotImageFilterIF2IF2_Superclass_cast(obj: 'itkLightObject') -> \"itkNotImageFilterIF2IF2_Superclass *\":\n return _itkNotImageFilterPytho... | [
"0.83064026",
"0.8255792",
"0.8157398",
"0.81537783",
"0.8102101",
"0.8073973",
"0.80381954",
"0.800663",
"0.7993588",
"0.79927564",
"0.7985042",
"0.79630977",
"0.79616165",
"0.77700764",
"0.7733867",
"0.7707605",
"0.7705628",
"0.767445",
"0.7638304",
"0.761557",
"0.7609519",... | 0.7650135 | 18 |
New() > itkTernaryAddImageFilterID2ID2ID2ID2_Superclass Create a new object of the class itkTernaryAddImageFilterID2ID2ID2ID2_Superclass and set the input and the parameters if some named or nonnamed arguments are passed to that method. New() tries to assign all the non named parameters to the input of the new objects the first non named parameter in the first input, etc. The named parameters are used by calling the method with the same name prefixed by 'Set'. | def New(*args, **kargs):
obj = itkTernaryAddImageFilterID2ID2ID2ID2_Superclass.__New_orig__()
import itkTemplate
itkTemplate.New(obj, *args, **kargs)
return obj | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def New(*args, **kargs):\n obj = itkTernaryAddImageFilterIF2IF2IF2IF2_Superclass.__New_orig__()\n import itkTemplate\n itkTemplate.New(obj, *args, **kargs)\n return obj",
"def New(*args, **kargs):\n obj = itkTernaryAddImageFilterIUL2IUL2IUL2IUL2_Superclass.__New_orig__()\n ... | [
"0.762808",
"0.75490963",
"0.74511015",
"0.7423488",
"0.7417358",
"0.73689806",
"0.7338099",
"0.72890794",
"0.7233506",
"0.72322845",
"0.71680635",
"0.7162203",
"0.7157877",
"0.7050944",
"0.7018189",
"0.7015261",
"0.701475",
"0.7012063",
"0.69447744",
"0.69441223",
"0.6889131... | 0.7865722 | 0 |
itkTernaryAddImageFilterID2ID2ID2ID2_Superclass_cast(itkLightObject obj) > itkTernaryAddImageFilterID2ID2ID2ID2_Superclass | def itkTernaryAddImageFilterID2ID2ID2ID2_Superclass_cast(*args):
return _itkTernaryAddImageFilterPython.itkTernaryAddImageFilterID2ID2ID2ID2_Superclass_cast(*args) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def itkNotImageFilterIF2IF2_Superclass_cast(obj: 'itkLightObject') -> \"itkNotImageFilterIF2IF2_Superclass *\":\n return _itkNotImageFilterPython.itkNotImageFilterIF2IF2_Superclass_cast(obj)",
"def itkNotImageFilterIUS2IUS2_Superclass_cast(obj: 'itkLightObject') -> \"itkNotImageFilterIUS2IUS2_Superclass *\":\... | [
"0.84598845",
"0.830569",
"0.83006763",
"0.829275",
"0.82689846",
"0.82017225",
"0.8179489",
"0.8175326",
"0.81749785",
"0.8088286",
"0.80781823",
"0.8049702",
"0.8036825",
"0.802763",
"0.80256134",
"0.8021667",
"0.7969493",
"0.7960738",
"0.79595184",
"0.7879262",
"0.78750664... | 0.83009154 | 2 |
cast(itkLightObject obj) > itkTernaryAddImageFilterID3ID3ID3ID3_Superclass | def cast(*args):
return _itkTernaryAddImageFilterPython.itkTernaryAddImageFilterID3ID3ID3ID3_Superclass_cast(*args) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def cast(obj: 'itkLightObject') -> \"itkNotImageFilterIF3IF3_Superclass *\":\n return _itkNotImageFilterPython.itkNotImageFilterIF3IF3_Superclass_cast(obj)",
"def itkNotImageFilterIF3IF3_Superclass_cast(obj: 'itkLightObject') -> \"itkNotImageFilterIF3IF3_Superclass *\":\n return _itkNotImageFilterPytho... | [
"0.8447806",
"0.835408",
"0.8331328",
"0.83247644",
"0.8303352",
"0.81888425",
"0.81718343",
"0.8150934",
"0.8132018",
"0.8111063",
"0.80385387",
"0.8013818",
"0.79792774",
"0.796343",
"0.79049927",
"0.7870615",
"0.7870506",
"0.7843389",
"0.780859",
"0.77116466",
"0.76478946"... | 0.75060236 | 27 |
New() > itkTernaryAddImageFilterID3ID3ID3ID3_Superclass Create a new object of the class itkTernaryAddImageFilterID3ID3ID3ID3_Superclass and set the input and the parameters if some named or nonnamed arguments are passed to that method. New() tries to assign all the non named parameters to the input of the new objects the first non named parameter in the first input, etc. The named parameters are used by calling the method with the same name prefixed by 'Set'. | def New(*args, **kargs):
obj = itkTernaryAddImageFilterID3ID3ID3ID3_Superclass.__New_orig__()
import itkTemplate
itkTemplate.New(obj, *args, **kargs)
return obj | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def New(*args, **kargs):\n obj = itkTernaryAddImageFilterIF3IF3IF3IF3_Superclass.__New_orig__()\n import itkTemplate\n itkTemplate.New(obj, *args, **kargs)\n return obj",
"def New(*args, **kargs):\n obj = itkTernaryAddImageFilterIUL3IUL3IUL3IUL3_Superclass.__New_orig__()\n ... | [
"0.77666956",
"0.76079875",
"0.75039846",
"0.75035",
"0.7479952",
"0.74662477",
"0.7298497",
"0.72855514",
"0.72777826",
"0.72717106",
"0.72706074",
"0.7184689",
"0.7160855",
"0.71421075",
"0.71154994",
"0.7073263",
"0.7060131",
"0.70412266",
"0.7006315",
"0.6987071",
"0.6958... | 0.7919466 | 0 |
itkTernaryAddImageFilterID3ID3ID3ID3_Superclass_cast(itkLightObject obj) > itkTernaryAddImageFilterID3ID3ID3ID3_Superclass | def itkTernaryAddImageFilterID3ID3ID3ID3_Superclass_cast(*args):
return _itkTernaryAddImageFilterPython.itkTernaryAddImageFilterID3ID3ID3ID3_Superclass_cast(*args) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def itkNotImageFilterIF3IF3_Superclass_cast(obj: 'itkLightObject') -> \"itkNotImageFilterIF3IF3_Superclass *\":\n return _itkNotImageFilterPython.itkNotImageFilterIF3IF3_Superclass_cast(obj)",
"def itkNotImageFilterISS3ISS3_Superclass_cast(obj: 'itkLightObject') -> \"itkNotImageFilterISS3ISS3_Superclass *\":\... | [
"0.8736071",
"0.868161",
"0.85678107",
"0.855728",
"0.8525033",
"0.84827745",
"0.8458611",
"0.84521455",
"0.8401546",
"0.8398676",
"0.82971007",
"0.82100916",
"0.819524",
"0.8174809",
"0.8162183",
"0.8155681",
"0.8120304",
"0.8097459",
"0.80840564",
"0.8081543",
"0.8037756",
... | 0.8572596 | 2 |
cast(itkLightObject obj) > itkTernaryAddImageFilterIF2IF2IF2IF2_Superclass | def cast(*args):
return _itkTernaryAddImageFilterPython.itkTernaryAddImageFilterIF2IF2IF2IF2_Superclass_cast(*args) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def itkNotImageFilterIF2IF2_Superclass_cast(obj: 'itkLightObject') -> \"itkNotImageFilterIF2IF2_Superclass *\":\n return _itkNotImageFilterPython.itkNotImageFilterIF2IF2_Superclass_cast(obj)",
"def cast(obj: 'itkLightObject') -> \"itkNotImageFilterIF2IF2_Superclass *\":\n return _itkNotImageFilterPytho... | [
"0.83766204",
"0.8343197",
"0.81994504",
"0.8033622",
"0.8021271",
"0.7993956",
"0.79668874",
"0.7955408",
"0.79487544",
"0.7893651",
"0.78932303",
"0.7893183",
"0.7889645",
"0.78552145",
"0.7831324",
"0.7804832",
"0.7798998",
"0.77956307",
"0.7756702",
"0.7714334",
"0.767403... | 0.787697 | 13 |
New() > itkTernaryAddImageFilterIF2IF2IF2IF2_Superclass Create a new object of the class itkTernaryAddImageFilterIF2IF2IF2IF2_Superclass and set the input and the parameters if some named or nonnamed arguments are passed to that method. New() tries to assign all the non named parameters to the input of the new objects the first non named parameter in the first input, etc. The named parameters are used by calling the method with the same name prefixed by 'Set'. | def New(*args, **kargs):
obj = itkTernaryAddImageFilterIF2IF2IF2IF2_Superclass.__New_orig__()
import itkTemplate
itkTemplate.New(obj, *args, **kargs)
return obj | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def New(*args, **kargs):\n obj = itkTernaryAddImageFilterID2ID2ID2ID2_Superclass.__New_orig__()\n import itkTemplate\n itkTemplate.New(obj, *args, **kargs)\n return obj",
"def New(*args, **kargs):\n obj = itkTernaryAddImageFilterIUL2IUL2IUL2IUL2_Superclass.__New_orig__()\n ... | [
"0.78903687",
"0.7618442",
"0.7587125",
"0.7554806",
"0.7497415",
"0.7490903",
"0.7460643",
"0.7349206",
"0.73199266",
"0.7273647",
"0.7265122",
"0.7225199",
"0.72199607",
"0.7203722",
"0.7196587",
"0.71783614",
"0.71586716",
"0.7110979",
"0.7084644",
"0.70412594",
"0.7006525... | 0.8061528 | 0 |
itkTernaryAddImageFilterIF2IF2IF2IF2_Superclass_cast(itkLightObject obj) > itkTernaryAddImageFilterIF2IF2IF2IF2_Superclass | def itkTernaryAddImageFilterIF2IF2IF2IF2_Superclass_cast(*args):
return _itkTernaryAddImageFilterPython.itkTernaryAddImageFilterIF2IF2IF2IF2_Superclass_cast(*args) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def itkNotImageFilterIF2IF2_Superclass_cast(obj: 'itkLightObject') -> \"itkNotImageFilterIF2IF2_Superclass *\":\n return _itkNotImageFilterPython.itkNotImageFilterIF2IF2_Superclass_cast(obj)",
"def cast(obj: 'itkLightObject') -> \"itkNotImageFilterIF2IF2_Superclass *\":\n return _itkNotImageFilterPytho... | [
"0.88076603",
"0.8572629",
"0.85263824",
"0.84869593",
"0.84707963",
"0.8447603",
"0.8407247",
"0.83666754",
"0.8311725",
"0.82673705",
"0.82649153",
"0.8258107",
"0.8230317",
"0.82138693",
"0.82006955",
"0.8125339",
"0.8115553",
"0.80756104",
"0.8072043",
"0.8067883",
"0.805... | 0.8668573 | 1 |
cast(itkLightObject obj) > itkTernaryAddImageFilterIF3IF3IF3IF3_Superclass | def cast(*args):
return _itkTernaryAddImageFilterPython.itkTernaryAddImageFilterIF3IF3IF3IF3_Superclass_cast(*args) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def itkNotImageFilterIF3IF3_Superclass_cast(obj: 'itkLightObject') -> \"itkNotImageFilterIF3IF3_Superclass *\":\n return _itkNotImageFilterPython.itkNotImageFilterIF3IF3_Superclass_cast(obj)",
"def cast(obj: 'itkLightObject') -> \"itkNotImageFilterIF3IF3_Superclass *\":\n return _itkNotImageFilterPytho... | [
"0.84215736",
"0.84034926",
"0.8305896",
"0.81551635",
"0.81245995",
"0.8102471",
"0.80973864",
"0.80775636",
"0.80774724",
"0.8057766",
"0.8046051",
"0.8026812",
"0.80027497",
"0.78837883",
"0.7882408",
"0.78676045",
"0.7847785",
"0.78235435",
"0.77957475",
"0.774796",
"0.77... | 0.77168095 | 21 |
New() > itkTernaryAddImageFilterIF3IF3IF3IF3_Superclass Create a new object of the class itkTernaryAddImageFilterIF3IF3IF3IF3_Superclass and set the input and the parameters if some named or nonnamed arguments are passed to that method. New() tries to assign all the non named parameters to the input of the new objects the first non named parameter in the first input, etc. The named parameters are used by calling the method with the same name prefixed by 'Set'. | def New(*args, **kargs):
obj = itkTernaryAddImageFilterIF3IF3IF3IF3_Superclass.__New_orig__()
import itkTemplate
itkTemplate.New(obj, *args, **kargs)
return obj | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def New(*args, **kargs):\n obj = itkTernaryAddImageFilterID3ID3ID3ID3_Superclass.__New_orig__()\n import itkTemplate\n itkTemplate.New(obj, *args, **kargs)\n return obj",
"def New(*args, **kargs):\n obj = itkCosImageFilterIF3IF3_Superclass.__New_orig__()\n import itkTemp... | [
"0.78577113",
"0.7592699",
"0.7584402",
"0.74809074",
"0.7461834",
"0.74548477",
"0.7382315",
"0.7356721",
"0.7290633",
"0.72715217",
"0.7263018",
"0.7174303",
"0.7171283",
"0.7165325",
"0.7131815",
"0.7109765",
"0.7042447",
"0.7011581",
"0.69516927",
"0.69480693",
"0.6946724... | 0.7961178 | 0 |
itkTernaryAddImageFilterIF3IF3IF3IF3_Superclass_cast(itkLightObject obj) > itkTernaryAddImageFilterIF3IF3IF3IF3_Superclass | def itkTernaryAddImageFilterIF3IF3IF3IF3_Superclass_cast(*args):
return _itkTernaryAddImageFilterPython.itkTernaryAddImageFilterIF3IF3IF3IF3_Superclass_cast(*args) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def itkNotImageFilterIF3IF3_Superclass_cast(obj: 'itkLightObject') -> \"itkNotImageFilterIF3IF3_Superclass *\":\n return _itkNotImageFilterPython.itkNotImageFilterIF3IF3_Superclass_cast(obj)",
"def itkTernaryAddImageFilterID3ID3ID3ID3_Superclass_cast(*args):\n return _itkTernaryAddImageFilterPython.itkTernar... | [
"0.889163",
"0.872401",
"0.8716521",
"0.8686031",
"0.86727256",
"0.8645202",
"0.86261636",
"0.85349524",
"0.8480945",
"0.84491646",
"0.8429972",
"0.8390216",
"0.8305966",
"0.82382905",
"0.82324976",
"0.81321186",
"0.81260115",
"0.8123955",
"0.80859166",
"0.80845314",
"0.80565... | 0.87746197 | 1 |
cast(itkLightObject obj) > itkTernaryAddImageFilterIUC2IUC2IUC2IUC2_Superclass | def cast(*args):
return _itkTernaryAddImageFilterPython.itkTernaryAddImageFilterIUC2IUC2IUC2IUC2_Superclass_cast(*args) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def cast(obj: 'itkLightObject') -> \"itkNotImageFilterIUC2IUC2_Superclass *\":\n return _itkNotImageFilterPython.itkNotImageFilterIUC2IUC2_Superclass_cast(obj)",
"def itkNotImageFilterIUC2IUC2_Superclass_cast(obj: 'itkLightObject') -> \"itkNotImageFilterIUC2IUC2_Superclass *\":\n return _itkNotImageFil... | [
"0.834111",
"0.8290173",
"0.81825304",
"0.81166714",
"0.8085342",
"0.8076864",
"0.8007342",
"0.7972806",
"0.7964573",
"0.7946949",
"0.7939894",
"0.7933654",
"0.78695387",
"0.7853671",
"0.7838806",
"0.78119445",
"0.7795307",
"0.7725836",
"0.77124554",
"0.77036095",
"0.77026665... | 0.7777628 | 17 |
New() > itkTernaryAddImageFilterIUC2IUC2IUC2IUC2_Superclass Create a new object of the class itkTernaryAddImageFilterIUC2IUC2IUC2IUC2_Superclass and set the input and the parameters if some named or nonnamed arguments are passed to that method. New() tries to assign all the non named parameters to the input of the new objects the first non named parameter in the first input, etc. The named parameters are used by calling the method with the same name prefixed by 'Set'. | def New(*args, **kargs):
obj = itkTernaryAddImageFilterIUC2IUC2IUC2IUC2_Superclass.__New_orig__()
import itkTemplate
itkTemplate.New(obj, *args, **kargs)
return obj | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def New(*args, **kargs):\n obj = itkTernaryAddImageFilterIUL2IUL2IUL2IUL2_Superclass.__New_orig__()\n import itkTemplate\n itkTemplate.New(obj, *args, **kargs)\n return obj",
"def New(*args, **kargs):\n obj = itkTernaryAddImageFilterIUC3IUC3IUC3IUC3_Superclass.__New_orig__()\n ... | [
"0.77771425",
"0.777552",
"0.7686807",
"0.7643416",
"0.7587692",
"0.75774217",
"0.73941374",
"0.73560876",
"0.73111916",
"0.7292542",
"0.72911847",
"0.72615075",
"0.7257298",
"0.72467935",
"0.71607935",
"0.71508795",
"0.7145032",
"0.71084183",
"0.7099382",
"0.70673823",
"0.70... | 0.79703885 | 0 |
itkTernaryAddImageFilterIUC2IUC2IUC2IUC2_Superclass_cast(itkLightObject obj) > itkTernaryAddImageFilterIUC2IUC2IUC2IUC2_Superclass | def itkTernaryAddImageFilterIUC2IUC2IUC2IUC2_Superclass_cast(*args):
return _itkTernaryAddImageFilterPython.itkTernaryAddImageFilterIUC2IUC2IUC2IUC2_Superclass_cast(*args) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def itkNotImageFilterIUC2IUC2_Superclass_cast(obj: 'itkLightObject') -> \"itkNotImageFilterIUC2IUC2_Superclass *\":\n return _itkNotImageFilterPython.itkNotImageFilterIUC2IUC2_Superclass_cast(obj)",
"def itkNotImageFilterIF2IF2_Superclass_cast(obj: 'itkLightObject') -> \"itkNotImageFilterIF2IF2_Superclass *\"... | [
"0.8583774",
"0.8431196",
"0.8420218",
"0.83839583",
"0.8363702",
"0.83492815",
"0.82900065",
"0.82717526",
"0.82178116",
"0.8217027",
"0.8207864",
"0.820718",
"0.8156194",
"0.80921507",
"0.8092105",
"0.8075868",
"0.8073345",
"0.8053059",
"0.8038925",
"0.8010338",
"0.79771775... | 0.85070795 | 1 |
cast(itkLightObject obj) > itkTernaryAddImageFilterIUC3IUC3IUC3IUC3_Superclass | def cast(*args):
return _itkTernaryAddImageFilterPython.itkTernaryAddImageFilterIUC3IUC3IUC3IUC3_Superclass_cast(*args) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def cast(obj: 'itkLightObject') -> \"itkNotImageFilterIUC3IUC3_Superclass *\":\n return _itkNotImageFilterPython.itkNotImageFilterIUC3IUC3_Superclass_cast(obj)",
"def cast(obj: 'itkLightObject') -> \"itkNotImageFilterIUC2IUC2_Superclass *\":\n return _itkNotImageFilterPython.itkNotImageFilterIUC2IU... | [
"0.8382613",
"0.8278823",
"0.8251991",
"0.82148737",
"0.8203227",
"0.8143775",
"0.81393623",
"0.8138548",
"0.81275445",
"0.80943424",
"0.8089351",
"0.7965766",
"0.79550606",
"0.79431623",
"0.79347086",
"0.791383",
"0.7902391",
"0.7832134",
"0.7724162",
"0.7658042",
"0.7645572... | 0.756046 | 27 |
New() > itkTernaryAddImageFilterIUC3IUC3IUC3IUC3_Superclass Create a new object of the class itkTernaryAddImageFilterIUC3IUC3IUC3IUC3_Superclass and set the input and the parameters if some named or nonnamed arguments are passed to that method. New() tries to assign all the non named parameters to the input of the new objects the first non named parameter in the first input, etc. The named parameters are used by calling the method with the same name prefixed by 'Set'. | def New(*args, **kargs):
obj = itkTernaryAddImageFilterIUC3IUC3IUC3IUC3_Superclass.__New_orig__()
import itkTemplate
itkTemplate.New(obj, *args, **kargs)
return obj | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def New(*args, **kargs):\n obj = itkTernaryAddImageFilterID3ID3ID3ID3_Superclass.__New_orig__()\n import itkTemplate\n itkTemplate.New(obj, *args, **kargs)\n return obj",
"def New(*args, **kargs):\n obj = itkTernaryAddImageFilterIUL3IUL3IUL3IUL3_Superclass.__New_orig__()\n ... | [
"0.78084457",
"0.7777113",
"0.7743919",
"0.7609945",
"0.75737077",
"0.7548231",
"0.73495024",
"0.7265904",
"0.7243554",
"0.7237153",
"0.7220631",
"0.7212902",
"0.72032726",
"0.7179373",
"0.7160813",
"0.7156109",
"0.7147796",
"0.71228814",
"0.71199644",
"0.70842755",
"0.707750... | 0.7868488 | 0 |
itkTernaryAddImageFilterIUC3IUC3IUC3IUC3_Superclass_cast(itkLightObject obj) > itkTernaryAddImageFilterIUC3IUC3IUC3IUC3_Superclass | def itkTernaryAddImageFilterIUC3IUC3IUC3IUC3_Superclass_cast(*args):
return _itkTernaryAddImageFilterPython.itkTernaryAddImageFilterIUC3IUC3IUC3IUC3_Superclass_cast(*args) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def itkNotImageFilterIUC3IUC3_Superclass_cast(obj: 'itkLightObject') -> \"itkNotImageFilterIUC3IUC3_Superclass *\":\n return _itkNotImageFilterPython.itkNotImageFilterIUC3IUC3_Superclass_cast(obj)",
"def itkTernaryAddImageFilterIUL3IUL3IUL3IUL3_Superclass_cast(*args):\n return _itkTernaryAddImageFilterPython... | [
"0.8532647",
"0.85305256",
"0.8516313",
"0.849879",
"0.84499377",
"0.84234107",
"0.8399052",
"0.83886224",
"0.8355858",
"0.8344065",
"0.83316773",
"0.8331413",
"0.83286583",
"0.82926065",
"0.8276312",
"0.8266724",
"0.826375",
"0.8225655",
"0.8214009",
"0.8193666",
"0.8193466"... | 0.86180055 | 0 |
cast(itkLightObject obj) > itkTernaryAddImageFilterIUL2IUL2IUL2IUL2_Superclass | def cast(*args):
return _itkTernaryAddImageFilterPython.itkTernaryAddImageFilterIUL2IUL2IUL2IUL2_Superclass_cast(*args) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def cast(obj: 'itkLightObject') -> \"itkNotImageFilterIF2IF2_Superclass *\":\n return _itkNotImageFilterPython.itkNotImageFilterIF2IF2_Superclass_cast(obj)",
"def cast(obj: 'itkLightObject') -> \"itkNotImageFilterIUC2IUC2_Superclass *\":\n return _itkNotImageFilterPython.itkNotImageFilterIUC2IUC2_S... | [
"0.8231043",
"0.8183794",
"0.8179944",
"0.813997",
"0.8107713",
"0.81054693",
"0.8088916",
"0.8019836",
"0.80192333",
"0.8010472",
"0.80005395",
"0.7982409",
"0.7888748",
"0.7857484",
"0.7852095",
"0.78295845",
"0.7784547",
"0.7752002",
"0.7742223",
"0.76902217",
"0.76497644"... | 0.76787597 | 20 |
New() > itkTernaryAddImageFilterIUL2IUL2IUL2IUL2_Superclass Create a new object of the class itkTernaryAddImageFilterIUL2IUL2IUL2IUL2_Superclass and set the input and the parameters if some named or nonnamed arguments are passed to that method. New() tries to assign all the non named parameters to the input of the new objects the first non named parameter in the first input, etc. The named parameters are used by calling the method with the same name prefixed by 'Set'. | def New(*args, **kargs):
obj = itkTernaryAddImageFilterIUL2IUL2IUL2IUL2_Superclass.__New_orig__()
import itkTemplate
itkTemplate.New(obj, *args, **kargs)
return obj | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def New(*args, **kargs):\n obj = itkTernaryAddImageFilterIUL3IUL3IUL3IUL3_Superclass.__New_orig__()\n import itkTemplate\n itkTemplate.New(obj, *args, **kargs)\n return obj",
"def New(*args, **kargs):\n obj = itkTernaryAddImageFilterIUC2IUC2IUC2IUC2_Superclass.__New_orig__()\n ... | [
"0.76136214",
"0.75883645",
"0.75875884",
"0.7529568",
"0.74792403",
"0.7449526",
"0.74375355",
"0.7260869",
"0.7239844",
"0.7108787",
"0.70131814",
"0.69569594",
"0.6922677",
"0.6912971",
"0.68873686",
"0.687519",
"0.6859417",
"0.6853394",
"0.68529296",
"0.68343085",
"0.6792... | 0.77367264 | 0 |
itkTernaryAddImageFilterIUL2IUL2IUL2IUL2_Superclass_cast(itkLightObject obj) > itkTernaryAddImageFilterIUL2IUL2IUL2IUL2_Superclass | def itkTernaryAddImageFilterIUL2IUL2IUL2IUL2_Superclass_cast(*args):
return _itkTernaryAddImageFilterPython.itkTernaryAddImageFilterIUL2IUL2IUL2IUL2_Superclass_cast(*args) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def itkNotImageFilterIF2IF2_Superclass_cast(obj: 'itkLightObject') -> \"itkNotImageFilterIF2IF2_Superclass *\":\n return _itkNotImageFilterPython.itkNotImageFilterIF2IF2_Superclass_cast(obj)",
"def itkNotImageFilterIUS2IUS2_Superclass_cast(obj: 'itkLightObject') -> \"itkNotImageFilterIUS2IUS2_Superclass *\":\... | [
"0.83347076",
"0.8259786",
"0.8254877",
"0.82273674",
"0.8213395",
"0.81952333",
"0.81827587",
"0.81737477",
"0.81565833",
"0.81444824",
"0.81440467",
"0.8123669",
"0.81183785",
"0.8090652",
"0.80894965",
"0.8077059",
"0.80663335",
"0.80111235",
"0.79480046",
"0.7916144",
"0.... | 0.8331188 | 1 |
cast(itkLightObject obj) > itkTernaryAddImageFilterIUL3IUL3IUL3IUL3_Superclass | def cast(*args):
return _itkTernaryAddImageFilterPython.itkTernaryAddImageFilterIUL3IUL3IUL3IUL3_Superclass_cast(*args) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def cast(obj: 'itkLightObject') -> \"itkNotImageFilterIF3IF3_Superclass *\":\n return _itkNotImageFilterPython.itkNotImageFilterIF3IF3_Superclass_cast(obj)",
"def cast(obj: 'itkLightObject') -> \"itkNotImageFilterIUC3IUC3_Superclass *\":\n return _itkNotImageFilterPython.itkNotImageFilterIUC3IUC3_S... | [
"0.8344029",
"0.83224463",
"0.8284969",
"0.8224202",
"0.82228005",
"0.82063365",
"0.81694835",
"0.8165365",
"0.80582345",
"0.80344105",
"0.8034188",
"0.80162996",
"0.80015427",
"0.7995259",
"0.7987952",
"0.7976403",
"0.7948404",
"0.7799154",
"0.77925974",
"0.7752949",
"0.7708... | 0.7512756 | 26 |
New() > itkTernaryAddImageFilterIUL3IUL3IUL3IUL3_Superclass Create a new object of the class itkTernaryAddImageFilterIUL3IUL3IUL3IUL3_Superclass and set the input and the parameters if some named or nonnamed arguments are passed to that method. New() tries to assign all the non named parameters to the input of the new objects the first non named parameter in the first input, etc. The named parameters are used by calling the method with the same name prefixed by 'Set'. | def New(*args, **kargs):
obj = itkTernaryAddImageFilterIUL3IUL3IUL3IUL3_Superclass.__New_orig__()
import itkTemplate
itkTemplate.New(obj, *args, **kargs)
return obj | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def New(*args, **kargs):\n obj = itkTernaryAddImageFilterID3ID3ID3ID3_Superclass.__New_orig__()\n import itkTemplate\n itkTemplate.New(obj, *args, **kargs)\n return obj",
"def New(*args, **kargs):\n obj = itkTernaryAddImageFilterIUC3IUC3IUC3IUC3_Superclass.__New_orig__()\n ... | [
"0.77514553",
"0.765869",
"0.76537627",
"0.7553569",
"0.749837",
"0.7385497",
"0.7229729",
"0.72107583",
"0.71896565",
"0.71452445",
"0.71168566",
"0.7091152",
"0.70909774",
"0.7024852",
"0.70056397",
"0.6996257",
"0.69950944",
"0.69864553",
"0.69812405",
"0.69450486",
"0.692... | 0.7761621 | 0 |
itkTernaryAddImageFilterIUL3IUL3IUL3IUL3_Superclass_cast(itkLightObject obj) > itkTernaryAddImageFilterIUL3IUL3IUL3IUL3_Superclass | def itkTernaryAddImageFilterIUL3IUL3IUL3IUL3_Superclass_cast(*args):
return _itkTernaryAddImageFilterPython.itkTernaryAddImageFilterIUL3IUL3IUL3IUL3_Superclass_cast(*args) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def itkNotImageFilterIF3IF3_Superclass_cast(obj: 'itkLightObject') -> \"itkNotImageFilterIF3IF3_Superclass *\":\n return _itkNotImageFilterPython.itkNotImageFilterIF3IF3_Superclass_cast(obj)",
"def itkNotImageFilterISS3ISS3_Superclass_cast(obj: 'itkLightObject') -> \"itkNotImageFilterISS3ISS3_Superclass *\":\... | [
"0.85246396",
"0.84796506",
"0.84340036",
"0.84302866",
"0.84288764",
"0.8423453",
"0.8416096",
"0.83491045",
"0.8327571",
"0.83225805",
"0.82702595",
"0.8268719",
"0.82654333",
"0.8251263",
"0.82445973",
"0.8234296",
"0.8218139",
"0.8206639",
"0.81782633",
"0.8108415",
"0.80... | 0.85044765 | 1 |
cast(itkLightObject obj) > itkTernaryAddImageFilterIUS2IUS2IUS2IUS2_Superclass | def cast(*args):
return _itkTernaryAddImageFilterPython.itkTernaryAddImageFilterIUS2IUS2IUS2IUS2_Superclass_cast(*args) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def itkNotImageFilterIUS2IUS2_Superclass_cast(obj: 'itkLightObject') -> \"itkNotImageFilterIUS2IUS2_Superclass *\":\n return _itkNotImageFilterPython.itkNotImageFilterIUS2IUS2_Superclass_cast(obj)",
"def cast(obj: 'itkLightObject') -> \"itkNotImageFilterIUS2IUS2_Superclass *\":\n return _itkNotImageFil... | [
"0.8304301",
"0.82490915",
"0.81188726",
"0.80280966",
"0.7972961",
"0.78848064",
"0.7863343",
"0.7826107",
"0.7789981",
"0.7746478",
"0.7744639",
"0.7724042",
"0.771654",
"0.7712445",
"0.7704052",
"0.76961714",
"0.7681886",
"0.767606",
"0.7668913",
"0.76313215",
"0.7622179",... | 0.77324975 | 11 |
New() > itkTernaryAddImageFilterIUS2IUS2IUS2IUS2_Superclass Create a new object of the class itkTernaryAddImageFilterIUS2IUS2IUS2IUS2_Superclass and set the input and the parameters if some named or nonnamed arguments are passed to that method. New() tries to assign all the non named parameters to the input of the new objects the first non named parameter in the first input, etc. The named parameters are used by calling the method with the same name prefixed by 'Set'. | def New(*args, **kargs):
obj = itkTernaryAddImageFilterIUS2IUS2IUS2IUS2_Superclass.__New_orig__()
import itkTemplate
itkTemplate.New(obj, *args, **kargs)
return obj | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def New(*args, **kargs):\n obj = itkTernaryAddImageFilterID2ID2ID2ID2_Superclass.__New_orig__()\n import itkTemplate\n itkTemplate.New(obj, *args, **kargs)\n return obj",
"def New(*args, **kargs):\n obj = itkTernaryAddImageFilterIUS3IUS3IUS3IUS3_Superclass.__New_orig__()\n ... | [
"0.7596377",
"0.75910646",
"0.7560997",
"0.75100327",
"0.74321425",
"0.73726755",
"0.73566854",
"0.734661",
"0.7272658",
"0.72386825",
"0.7217317",
"0.7106021",
"0.7098527",
"0.70696133",
"0.7002581",
"0.6983039",
"0.6974576",
"0.69361895",
"0.6912299",
"0.68864566",
"0.68625... | 0.7922314 | 0 |
itkTernaryAddImageFilterIUS2IUS2IUS2IUS2_Superclass_cast(itkLightObject obj) > itkTernaryAddImageFilterIUS2IUS2IUS2IUS2_Superclass | def itkTernaryAddImageFilterIUS2IUS2IUS2IUS2_Superclass_cast(*args):
return _itkTernaryAddImageFilterPython.itkTernaryAddImageFilterIUS2IUS2IUS2IUS2_Superclass_cast(*args) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def itkNotImageFilterIUS2IUS2_Superclass_cast(obj: 'itkLightObject') -> \"itkNotImageFilterIUS2IUS2_Superclass *\":\n return _itkNotImageFilterPython.itkNotImageFilterIUS2IUS2_Superclass_cast(obj)",
"def cast(obj: 'itkLightObject') -> \"itkNotImageFilterIUS2IUS2_Superclass *\":\n return _itkNotImageFil... | [
"0.8769365",
"0.8522652",
"0.839778",
"0.83974636",
"0.8386833",
"0.8381579",
"0.8350641",
"0.8332937",
"0.8298384",
"0.8288761",
"0.824455",
"0.82303673",
"0.8217982",
"0.82114774",
"0.81883687",
"0.8180019",
"0.8107185",
"0.8103616",
"0.8074904",
"0.80426836",
"0.8036381",
... | 0.83809143 | 6 |
cast(itkLightObject obj) > itkTernaryAddImageFilterIUS3IUS3IUS3IUS3_Superclass | def cast(*args):
return _itkTernaryAddImageFilterPython.itkTernaryAddImageFilterIUS3IUS3IUS3IUS3_Superclass_cast(*args) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def cast(obj: 'itkLightObject') -> \"itkNotImageFilterIUS3IUS3_Superclass *\":\n return _itkNotImageFilterPython.itkNotImageFilterIUS3IUS3_Superclass_cast(obj)",
"def itkNotImageFilterIUS3IUS3_Superclass_cast(obj: 'itkLightObject') -> \"itkNotImageFilterIUS3IUS3_Superclass *\":\n return _itkNotImageFil... | [
"0.83137727",
"0.8301095",
"0.82114863",
"0.8178836",
"0.8119993",
"0.79578906",
"0.79196596",
"0.78718543",
"0.78582305",
"0.7827678",
"0.78161174",
"0.7789821",
"0.7776616",
"0.7749188",
"0.7730019",
"0.7708901",
"0.7708324",
"0.7677274",
"0.7676748",
"0.765284",
"0.7648585... | 0.7613641 | 22 |
New() > itkTernaryAddImageFilterIUS3IUS3IUS3IUS3_Superclass Create a new object of the class itkTernaryAddImageFilterIUS3IUS3IUS3IUS3_Superclass and set the input and the parameters if some named or nonnamed arguments are passed to that method. New() tries to assign all the non named parameters to the input of the new objects the first non named parameter in the first input, etc. The named parameters are used by calling the method with the same name prefixed by 'Set'. | def New(*args, **kargs):
obj = itkTernaryAddImageFilterIUS3IUS3IUS3IUS3_Superclass.__New_orig__()
import itkTemplate
itkTemplate.New(obj, *args, **kargs)
return obj | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def New(*args, **kargs):\n obj = itkTernaryAddImageFilterID3ID3ID3ID3_Superclass.__New_orig__()\n import itkTemplate\n itkTemplate.New(obj, *args, **kargs)\n return obj",
"def New(*args, **kargs):\n obj = itkTernaryAddImageFilterIUS2IUS2IUS2IUS2_Superclass.__New_orig__()\n ... | [
"0.76287913",
"0.7548939",
"0.7542766",
"0.74978733",
"0.74911535",
"0.73237395",
"0.7311357",
"0.7223127",
"0.7221928",
"0.7203291",
"0.711763",
"0.70980036",
"0.7094449",
"0.70661205",
"0.7045585",
"0.69802654",
"0.69774556",
"0.6953183",
"0.6930293",
"0.6927179",
"0.692529... | 0.7858551 | 0 |
itkTernaryAddImageFilterIUS3IUS3IUS3IUS3_Superclass_cast(itkLightObject obj) > itkTernaryAddImageFilterIUS3IUS3IUS3IUS3_Superclass | def itkTernaryAddImageFilterIUS3IUS3IUS3IUS3_Superclass_cast(*args):
return _itkTernaryAddImageFilterPython.itkTernaryAddImageFilterIUS3IUS3IUS3IUS3_Superclass_cast(*args) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def itkNotImageFilterIUS3IUS3_Superclass_cast(obj: 'itkLightObject') -> \"itkNotImageFilterIUS3IUS3_Superclass *\":\n return _itkNotImageFilterPython.itkNotImageFilterIUS3IUS3_Superclass_cast(obj)",
"def itkNotImageFilterIUS2IUS2_Superclass_cast(obj: 'itkLightObject') -> \"itkNotImageFilterIUS2IUS2_Superclass... | [
"0.8716246",
"0.86355853",
"0.86032987",
"0.85149944",
"0.8514654",
"0.8504637",
"0.85039264",
"0.8490741",
"0.8417344",
"0.8411787",
"0.8396364",
"0.8383459",
"0.838299",
"0.8310304",
"0.8255951",
"0.82330203",
"0.82198226",
"0.82180065",
"0.81992364",
"0.8187167",
"0.818102... | 0.8538841 | 3 |
cast(itkLightObject obj) > itkTernaryAddImageFilterID2ID2ID2ID2 | def cast(*args):
return _itkTernaryAddImageFilterPython.itkTernaryAddImageFilterID2ID2ID2ID2_cast(*args) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def itkNotImageFilterIF2IF2_cast(obj: 'itkLightObject') -> \"itkNotImageFilterIF2IF2 *\":\n return _itkNotImageFilterPython.itkNotImageFilterIF2IF2_cast(obj)",
"def cast(obj: 'itkLightObject') -> \"itkNotImageFilterIF2IF2 *\":\n return _itkNotImageFilterPython.itkNotImageFilterIF2IF2_cast(obj)",
"def... | [
"0.7715046",
"0.7705152",
"0.76006335",
"0.75384825",
"0.74669284",
"0.7435751",
"0.74244475",
"0.73907906",
"0.73766285",
"0.73675126",
"0.7347136",
"0.73369384",
"0.733344",
"0.7333071",
"0.73104805",
"0.730174",
"0.729558",
"0.7290023",
"0.7279606",
"0.7250818",
"0.7246067... | 0.7090828 | 39 |
New() > itkTernaryAddImageFilterID2ID2ID2ID2 Create a new object of the class itkTernaryAddImageFilterID2ID2ID2ID2 and set the input and the parameters if some named or nonnamed arguments are passed to that method. New() tries to assign all the non named parameters to the input of the new objects the first non named parameter in the first input, etc. The named parameters are used by calling the method with the same name prefixed by 'Set'. | def New(*args, **kargs):
obj = itkTernaryAddImageFilterID2ID2ID2ID2.__New_orig__()
import itkTemplate
itkTemplate.New(obj, *args, **kargs)
return obj | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def New(*args, **kargs):\n obj = itkTernaryAddImageFilterID2ID2ID2ID2_Superclass.__New_orig__()\n import itkTemplate\n itkTemplate.New(obj, *args, **kargs)\n return obj",
"def New(*args, **kargs):\n obj = itkTernaryAddImageFilterIF2IF2IF2IF2.__New_orig__()\n import itkTe... | [
"0.79866374",
"0.7950948",
"0.7902202",
"0.76756924",
"0.7476825",
"0.74265414",
"0.742054",
"0.7409127",
"0.7372828",
"0.73234135",
"0.7315541",
"0.7296767",
"0.7270058",
"0.7263262",
"0.7241665",
"0.7233361",
"0.72253376",
"0.72154576",
"0.715046",
"0.7147575",
"0.71471334"... | 0.8147333 | 0 |
itkTernaryAddImageFilterID2ID2ID2ID2_cast(itkLightObject obj) > itkTernaryAddImageFilterID2ID2ID2ID2 | def itkTernaryAddImageFilterID2ID2ID2ID2_cast(*args):
return _itkTernaryAddImageFilterPython.itkTernaryAddImageFilterID2ID2ID2ID2_cast(*args) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def itkNotImageFilterIF2IF2_cast(obj: 'itkLightObject') -> \"itkNotImageFilterIF2IF2 *\":\n return _itkNotImageFilterPython.itkNotImageFilterIF2IF2_cast(obj)",
"def itkTernaryAddImageFilterIF2IF2IF2IF2_cast(*args):\n return _itkTernaryAddImageFilterPython.itkTernaryAddImageFilterIF2IF2IF2IF2_cast(*args)",
... | [
"0.76308167",
"0.758188",
"0.7517058",
"0.7454919",
"0.74101835",
"0.73981917",
"0.7383619",
"0.73698163",
"0.7358109",
"0.7336409",
"0.7328914",
"0.7323717",
"0.7288171",
"0.72586155",
"0.725105",
"0.72349465",
"0.7195933",
"0.7163779",
"0.7159076",
"0.7150028",
"0.7110235",... | 0.7765551 | 0 |
cast(itkLightObject obj) > itkTernaryAddImageFilterID3ID3ID3ID3 | def cast(*args):
return _itkTernaryAddImageFilterPython.itkTernaryAddImageFilterID3ID3ID3ID3_cast(*args) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def cast(obj: 'itkLightObject') -> \"itkNotImageFilterIF3IF3 *\":\n return _itkNotImageFilterPython.itkNotImageFilterIF3IF3_cast(obj)",
"def cast(obj: 'itkLightObject') -> \"itkHuangThresholdImageFilterIF3IUS3 *\":\n return _itkHuangThresholdImageFilterPython.itkHuangThresholdImageFilterIF3IUS3_cas... | [
"0.7741984",
"0.7713559",
"0.77034396",
"0.76531625",
"0.76131505",
"0.7598604",
"0.75758034",
"0.7566732",
"0.75606537",
"0.75531316",
"0.75246245",
"0.749187",
"0.7488528",
"0.74811006",
"0.74808985",
"0.74759084",
"0.74668235",
"0.74441904",
"0.7443954",
"0.7413306",
"0.74... | 0.7174502 | 48 |
New() > itkTernaryAddImageFilterID3ID3ID3ID3 Create a new object of the class itkTernaryAddImageFilterID3ID3ID3ID3 and set the input and the parameters if some named or nonnamed arguments are passed to that method. New() tries to assign all the non named parameters to the input of the new objects the first non named parameter in the first input, etc. The named parameters are used by calling the method with the same name prefixed by 'Set'. | def New(*args, **kargs):
obj = itkTernaryAddImageFilterID3ID3ID3ID3.__New_orig__()
import itkTemplate
itkTemplate.New(obj, *args, **kargs)
return obj | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def New(*args, **kargs):\n obj = itkTernaryAddImageFilterIF3IF3IF3IF3.__New_orig__()\n import itkTemplate\n itkTemplate.New(obj, *args, **kargs)\n return obj",
"def New(*args, **kargs):\n obj = itkTernaryAddImageFilterIF3IF3IF3IF3_Superclass.__New_orig__()\n import itkTe... | [
"0.8122643",
"0.80405945",
"0.79705286",
"0.7826779",
"0.7583411",
"0.75830215",
"0.7572595",
"0.756218",
"0.74430597",
"0.74388206",
"0.7398677",
"0.73933834",
"0.7389276",
"0.7356299",
"0.73425376",
"0.732044",
"0.73061585",
"0.7295671",
"0.7292391",
"0.7291407",
"0.7245295... | 0.81664336 | 0 |
itkTernaryAddImageFilterID3ID3ID3ID3_cast(itkLightObject obj) > itkTernaryAddImageFilterID3ID3ID3ID3 | def itkTernaryAddImageFilterID3ID3ID3ID3_cast(*args):
return _itkTernaryAddImageFilterPython.itkTernaryAddImageFilterID3ID3ID3ID3_cast(*args) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def itkTernaryAddImageFilterIF3IF3IF3IF3_cast(*args):\n return _itkTernaryAddImageFilterPython.itkTernaryAddImageFilterIF3IF3IF3IF3_cast(*args)",
"def itkNotImageFilterIF3IF3_cast(obj: 'itkLightObject') -> \"itkNotImageFilterIF3IF3 *\":\n return _itkNotImageFilterPython.itkNotImageFilterIF3IF3_cast(obj)",
... | [
"0.78832257",
"0.785561",
"0.77852875",
"0.7771489",
"0.7718299",
"0.7687708",
"0.76786035",
"0.7662282",
"0.7625325",
"0.7598742",
"0.7597835",
"0.7562758",
"0.7558518",
"0.75351113",
"0.75327724",
"0.7522676",
"0.75222576",
"0.7520495",
"0.75182086",
"0.7504889",
"0.7499525... | 0.80553585 | 0 |
cast(itkLightObject obj) > itkTernaryAddImageFilterIF2IF2IF2IF2 | def cast(*args):
return _itkTernaryAddImageFilterPython.itkTernaryAddImageFilterIF2IF2IF2IF2_cast(*args) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def itkNotImageFilterIF2IF2_cast(obj: 'itkLightObject') -> \"itkNotImageFilterIF2IF2 *\":\n return _itkNotImageFilterPython.itkNotImageFilterIF2IF2_cast(obj)",
"def cast(obj: 'itkLightObject') -> \"itkNotImageFilterIF2IF2 *\":\n return _itkNotImageFilterPython.itkNotImageFilterIF2IF2_cast(obj)",
"def... | [
"0.8116733",
"0.8000364",
"0.7750954",
"0.77352816",
"0.76985484",
"0.7662705",
"0.76402336",
"0.7612111",
"0.75822896",
"0.7576933",
"0.74957603",
"0.74747777",
"0.7450279",
"0.74031514",
"0.7363972",
"0.7326749",
"0.73242706",
"0.73232335",
"0.73223644",
"0.73027104",
"0.73... | 0.7416886 | 13 |
New() > itkTernaryAddImageFilterIF2IF2IF2IF2 Create a new object of the class itkTernaryAddImageFilterIF2IF2IF2IF2 and set the input and the parameters if some named or nonnamed arguments are passed to that method. New() tries to assign all the non named parameters to the input of the new objects the first non named parameter in the first input, etc. The named parameters are used by calling the method with the same name prefixed by 'Set'. | def New(*args, **kargs):
obj = itkTernaryAddImageFilterIF2IF2IF2IF2.__New_orig__()
import itkTemplate
itkTemplate.New(obj, *args, **kargs)
return obj | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def New(*args, **kargs):\n obj = itkTernaryAddImageFilterIF2IF2IF2IF2_Superclass.__New_orig__()\n import itkTemplate\n itkTemplate.New(obj, *args, **kargs)\n return obj",
"def New(*args, **kargs):\n obj = itkTernaryAddImageFilterID2ID2ID2ID2.__New_orig__()\n import itkTe... | [
"0.8164579",
"0.796104",
"0.7792533",
"0.76417816",
"0.74947166",
"0.7469685",
"0.7461249",
"0.745837",
"0.7394439",
"0.73799187",
"0.7362876",
"0.735769",
"0.7347056",
"0.73209006",
"0.73039687",
"0.7292726",
"0.72827333",
"0.72694397",
"0.7240936",
"0.7170967",
"0.7154845",... | 0.8288121 | 0 |
itkTernaryAddImageFilterIF2IF2IF2IF2_cast(itkLightObject obj) > itkTernaryAddImageFilterIF2IF2IF2IF2 | def itkTernaryAddImageFilterIF2IF2IF2IF2_cast(*args):
return _itkTernaryAddImageFilterPython.itkTernaryAddImageFilterIF2IF2IF2IF2_cast(*args) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def itkNotImageFilterIF2IF2_cast(obj: 'itkLightObject') -> \"itkNotImageFilterIF2IF2 *\":\n return _itkNotImageFilterPython.itkNotImageFilterIF2IF2_cast(obj)",
"def cast(obj: 'itkLightObject') -> \"itkNotImageFilterIF2IF2 *\":\n return _itkNotImageFilterPython.itkNotImageFilterIF2IF2_cast(obj)",
"def... | [
"0.8325339",
"0.81298554",
"0.7900186",
"0.789129",
"0.7829227",
"0.7820389",
"0.78154504",
"0.7814893",
"0.7799674",
"0.7781515",
"0.77740836",
"0.7751609",
"0.77474713",
"0.7740967",
"0.77069825",
"0.7687321",
"0.7653217",
"0.7551432",
"0.75447375",
"0.7498614",
"0.74841386... | 0.82992935 | 1 |
cast(itkLightObject obj) > itkTernaryAddImageFilterIF3IF3IF3IF3 | def cast(*args):
return _itkTernaryAddImageFilterPython.itkTernaryAddImageFilterIF3IF3IF3IF3_cast(*args) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def itkNotImageFilterIF3IF3_cast(obj: 'itkLightObject') -> \"itkNotImageFilterIF3IF3 *\":\n return _itkNotImageFilterPython.itkNotImageFilterIF3IF3_cast(obj)",
"def cast(obj: 'itkLightObject') -> \"itkNotImageFilterIF3IF3 *\":\n return _itkNotImageFilterPython.itkNotImageFilterIF3IF3_cast(obj)",
"def... | [
"0.81073576",
"0.80122215",
"0.7959463",
"0.78997636",
"0.7873615",
"0.7828453",
"0.7827501",
"0.7825715",
"0.7757871",
"0.7743137",
"0.77404636",
"0.77255476",
"0.7713849",
"0.7702168",
"0.764673",
"0.7637698",
"0.76347834",
"0.7630268",
"0.7629711",
"0.7618248",
"0.7616702"... | 0.74116236 | 36 |
New() > itkTernaryAddImageFilterIF3IF3IF3IF3 Create a new object of the class itkTernaryAddImageFilterIF3IF3IF3IF3 and set the input and the parameters if some named or nonnamed arguments are passed to that method. New() tries to assign all the non named parameters to the input of the new objects the first non named parameter in the first input, etc. The named parameters are used by calling the method with the same name prefixed by 'Set'. | def New(*args, **kargs):
obj = itkTernaryAddImageFilterIF3IF3IF3IF3.__New_orig__()
import itkTemplate
itkTemplate.New(obj, *args, **kargs)
return obj | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def New(*args, **kargs):\n obj = itkTernaryAddImageFilterIF3IF3IF3IF3_Superclass.__New_orig__()\n import itkTemplate\n itkTemplate.New(obj, *args, **kargs)\n return obj",
"def New(*args, **kargs):\n obj = itkTernaryAddImageFilterID3ID3ID3ID3.__New_orig__()\n import itkTe... | [
"0.81593454",
"0.8019483",
"0.77812564",
"0.7755564",
"0.76374006",
"0.7600967",
"0.7552205",
"0.75319076",
"0.75210726",
"0.75069284",
"0.7500817",
"0.74600273",
"0.7445691",
"0.7439426",
"0.74359894",
"0.7410714",
"0.7394769",
"0.7375656",
"0.73547715",
"0.73338944",
"0.730... | 0.83370554 | 0 |
itkTernaryAddImageFilterIF3IF3IF3IF3_cast(itkLightObject obj) > itkTernaryAddImageFilterIF3IF3IF3IF3 | def itkTernaryAddImageFilterIF3IF3IF3IF3_cast(*args):
return _itkTernaryAddImageFilterPython.itkTernaryAddImageFilterIF3IF3IF3IF3_cast(*args) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def itkNotImageFilterIF3IF3_cast(obj: 'itkLightObject') -> \"itkNotImageFilterIF3IF3 *\":\n return _itkNotImageFilterPython.itkNotImageFilterIF3IF3_cast(obj)",
"def cast(obj: 'itkLightObject') -> \"itkNotImageFilterIF3IF3 *\":\n return _itkNotImageFilterPython.itkNotImageFilterIF3IF3_cast(obj)",
"def... | [
"0.8314334",
"0.8146819",
"0.81391484",
"0.8064029",
"0.8047938",
"0.80301446",
"0.8027858",
"0.80160296",
"0.8015273",
"0.7977002",
"0.79115695",
"0.7899026",
"0.7853632",
"0.78422785",
"0.78316253",
"0.78305656",
"0.78131515",
"0.7811875",
"0.7801812",
"0.77994573",
"0.7799... | 0.83667874 | 0 |
cast(itkLightObject obj) > itkTernaryAddImageFilterIUC2IUC2IUC2IUC2 | def cast(*args):
return _itkTernaryAddImageFilterPython.itkTernaryAddImageFilterIUC2IUC2IUC2IUC2_cast(*args) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def itkNotImageFilterIUC2IUC2_cast(obj: 'itkLightObject') -> \"itkNotImageFilterIUC2IUC2 *\":\n return _itkNotImageFilterPython.itkNotImageFilterIUC2IUC2_cast(obj)",
"def cast(obj: 'itkLightObject') -> \"itkHuangThresholdImageFilterIUC2IUC2 *\":\n return _itkHuangThresholdImageFilterPython.itkHuangThre... | [
"0.78606176",
"0.77856857",
"0.7734099",
"0.7726301",
"0.7724931",
"0.7701192",
"0.764721",
"0.7644028",
"0.7607412",
"0.7591791",
"0.75696933",
"0.75436753",
"0.7526074",
"0.75034356",
"0.75017846",
"0.7489283",
"0.7467527",
"0.74643415",
"0.74634385",
"0.74435395",
"0.74328... | 0.71642035 | 64 |
New() > itkTernaryAddImageFilterIUC2IUC2IUC2IUC2 Create a new object of the class itkTernaryAddImageFilterIUC2IUC2IUC2IUC2 and set the input and the parameters if some named or nonnamed arguments are passed to that method. New() tries to assign all the non named parameters to the input of the new objects the first non named parameter in the first input, etc. The named parameters are used by calling the method with the same name prefixed by 'Set'. | def New(*args, **kargs):
obj = itkTernaryAddImageFilterIUC2IUC2IUC2IUC2.__New_orig__()
import itkTemplate
itkTemplate.New(obj, *args, **kargs)
return obj | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def New(*args, **kargs):\n obj = itkTernaryAddImageFilterIUC2IUC2IUC2IUC2_Superclass.__New_orig__()\n import itkTemplate\n itkTemplate.New(obj, *args, **kargs)\n return obj",
"def New(*args, **kargs):\n obj = itkTernaryAddImageFilterIUL2IUL2IUL2IUL2.__New_orig__()\n impo... | [
"0.80834025",
"0.79318345",
"0.7846418",
"0.7789117",
"0.7781465",
"0.76959866",
"0.7689662",
"0.7657546",
"0.76215744",
"0.7617233",
"0.76065916",
"0.75819594",
"0.7497899",
"0.7480199",
"0.7466372",
"0.7465572",
"0.7454194",
"0.74479383",
"0.74334204",
"0.7425108",
"0.74227... | 0.82164854 | 0 |
itkTernaryAddImageFilterIUC2IUC2IUC2IUC2_cast(itkLightObject obj) > itkTernaryAddImageFilterIUC2IUC2IUC2IUC2 | def itkTernaryAddImageFilterIUC2IUC2IUC2IUC2_cast(*args):
return _itkTernaryAddImageFilterPython.itkTernaryAddImageFilterIUC2IUC2IUC2IUC2_cast(*args) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def itkNotImageFilterIUC2IUC2_cast(obj: 'itkLightObject') -> \"itkNotImageFilterIUC2IUC2 *\":\n return _itkNotImageFilterPython.itkNotImageFilterIUC2IUC2_cast(obj)",
"def itkHuangThresholdImageFilterIUC2IUC2_cast(obj: 'itkLightObject') -> \"itkHuangThresholdImageFilterIUC2IUC2 *\":\n return _itkHuangThresh... | [
"0.7892496",
"0.78112376",
"0.77925205",
"0.77598757",
"0.77170867",
"0.76765",
"0.764932",
"0.7625104",
"0.7615173",
"0.7612952",
"0.7601345",
"0.7593909",
"0.75822866",
"0.7575358",
"0.7571743",
"0.7553365",
"0.75141734",
"0.74964494",
"0.7489112",
"0.7484641",
"0.7465378",... | 0.7989687 | 0 |
cast(itkLightObject obj) > itkTernaryAddImageFilterIUC3IUC3IUC3IUC3 | def cast(*args):
return _itkTernaryAddImageFilterPython.itkTernaryAddImageFilterIUC3IUC3IUC3IUC3_cast(*args) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def cast(obj: 'itkLightObject') -> \"itkHuangThresholdImageFilterIUC3IUC3 *\":\n return _itkHuangThresholdImageFilterPython.itkHuangThresholdImageFilterIUC3IUC3_cast(obj)",
"def cast(obj: 'itkLightObject') -> \"itkHuangThresholdImageFilterIF3IUC3 *\":\n return _itkHuangThresholdImageFilterPython.it... | [
"0.77693975",
"0.7703127",
"0.76897246",
"0.76749665",
"0.76679075",
"0.7648735",
"0.7646133",
"0.75900036",
"0.7586561",
"0.7576648",
"0.7568216",
"0.75426763",
"0.7539724",
"0.7532106",
"0.7513516",
"0.74965817",
"0.7474853",
"0.7471096",
"0.74622446",
"0.7437819",
"0.74244... | 0.71232 | 79 |
New() > itkTernaryAddImageFilterIUC3IUC3IUC3IUC3 Create a new object of the class itkTernaryAddImageFilterIUC3IUC3IUC3IUC3 and set the input and the parameters if some named or nonnamed arguments are passed to that method. New() tries to assign all the non named parameters to the input of the new objects the first non named parameter in the first input, etc. The named parameters are used by calling the method with the same name prefixed by 'Set'. | def New(*args, **kargs):
obj = itkTernaryAddImageFilterIUC3IUC3IUC3IUC3.__New_orig__()
import itkTemplate
itkTemplate.New(obj, *args, **kargs)
return obj | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def New(*args, **kargs):\n obj = itkTernaryAddImageFilterIF3IF3IF3IF3.__New_orig__()\n import itkTemplate\n itkTemplate.New(obj, *args, **kargs)\n return obj",
"def New(*args, **kargs):\n obj = itkTernaryAddImageFilterIF3IF3IF3IF3_Superclass.__New_orig__()\n import itkTe... | [
"0.81388545",
"0.810595",
"0.8090037",
"0.7969986",
"0.7956292",
"0.78857464",
"0.785059",
"0.77959174",
"0.77761877",
"0.7631814",
"0.75843716",
"0.7583665",
"0.7542179",
"0.75403064",
"0.7498079",
"0.74783415",
"0.74772173",
"0.74764365",
"0.7475445",
"0.7461655",
"0.746162... | 0.82122886 | 0 |
itkTernaryAddImageFilterIUC3IUC3IUC3IUC3_cast(itkLightObject obj) > itkTernaryAddImageFilterIUC3IUC3IUC3IUC3 | def itkTernaryAddImageFilterIUC3IUC3IUC3IUC3_cast(*args):
return _itkTernaryAddImageFilterPython.itkTernaryAddImageFilterIUC3IUC3IUC3IUC3_cast(*args) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def itkTernaryAddImageFilterIUL3IUL3IUL3IUL3_cast(*args):\n return _itkTernaryAddImageFilterPython.itkTernaryAddImageFilterIUL3IUL3IUL3IUL3_cast(*args)",
"def itkNotImageFilterIUC3IUC3_cast(obj: 'itkLightObject') -> \"itkNotImageFilterIUC3IUC3 *\":\n return _itkNotImageFilterPython.itkNotImageFilterIUC3IUC3_... | [
"0.7892304",
"0.78337157",
"0.78077155",
"0.7804674",
"0.77679163",
"0.7764134",
"0.7759513",
"0.7749586",
"0.7723623",
"0.7722778",
"0.77218026",
"0.7688984",
"0.7677636",
"0.76723707",
"0.76719034",
"0.76536036",
"0.7652875",
"0.7634969",
"0.76083463",
"0.7607304",
"0.76035... | 0.81195134 | 0 |
cast(itkLightObject obj) > itkTernaryAddImageFilterIUL2IUL2IUL2IUL2 | def cast(*args):
return _itkTernaryAddImageFilterPython.itkTernaryAddImageFilterIUL2IUL2IUL2IUL2_cast(*args) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def cast(obj: 'itkLightObject') -> \"itkHuangThresholdImageFilterIF2IUS2 *\":\n return _itkHuangThresholdImageFilterPython.itkHuangThresholdImageFilterIF2IUS2_cast(obj)",
"def cast(obj: 'itkLightObject') -> \"itkNotImageFilterIF2IF2 *\":\n return _itkNotImageFilterPython.itkNotImageFilterIF2IF2_cas... | [
"0.7591891",
"0.74914503",
"0.7475746",
"0.7469472",
"0.7456874",
"0.73987305",
"0.7355603",
"0.73495823",
"0.7347236",
"0.7315157",
"0.7291294",
"0.7271386",
"0.72556365",
"0.7250248",
"0.7243723",
"0.72239333",
"0.72214377",
"0.7204429",
"0.71994066",
"0.7191831",
"0.718562... | 0.6999903 | 55 |
New() > itkTernaryAddImageFilterIUL2IUL2IUL2IUL2 Create a new object of the class itkTernaryAddImageFilterIUL2IUL2IUL2IUL2 and set the input and the parameters if some named or nonnamed arguments are passed to that method. New() tries to assign all the non named parameters to the input of the new objects the first non named parameter in the first input, etc. The named parameters are used by calling the method with the same name prefixed by 'Set'. | def New(*args, **kargs):
obj = itkTernaryAddImageFilterIUL2IUL2IUL2IUL2.__New_orig__()
import itkTemplate
itkTemplate.New(obj, *args, **kargs)
return obj | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def New(*args, **kargs):\n obj = itkTernaryAddImageFilterIUL2IUL2IUL2IUL2_Superclass.__New_orig__()\n import itkTemplate\n itkTemplate.New(obj, *args, **kargs)\n return obj",
"def New(*args, **kargs):\n obj = itkTernaryAddImageFilterIF2IF2IF2IF2_Superclass.__New_orig__()\n ... | [
"0.7961385",
"0.7959622",
"0.79339135",
"0.7845965",
"0.7836587",
"0.78198117",
"0.7744429",
"0.765472",
"0.7626084",
"0.75983095",
"0.75397074",
"0.7475012",
"0.73143613",
"0.7257502",
"0.72472817",
"0.72370017",
"0.7167874",
"0.71628785",
"0.7112177",
"0.71041477",
"0.70785... | 0.81316435 | 0 |
itkTernaryAddImageFilterIUL2IUL2IUL2IUL2_cast(itkLightObject obj) > itkTernaryAddImageFilterIUL2IUL2IUL2IUL2 | def itkTernaryAddImageFilterIUL2IUL2IUL2IUL2_cast(*args):
return _itkTernaryAddImageFilterPython.itkTernaryAddImageFilterIUL2IUL2IUL2IUL2_cast(*args) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def itkTernaryAddImageFilterIUC2IUC2IUC2IUC2_cast(*args):\n return _itkTernaryAddImageFilterPython.itkTernaryAddImageFilterIUC2IUC2IUC2IUC2_cast(*args)",
"def itkTernaryAddImageFilterIF2IF2IF2IF2_cast(*args):\n return _itkTernaryAddImageFilterPython.itkTernaryAddImageFilterIF2IF2IF2IF2_cast(*args)",
"def cas... | [
"0.7352389",
"0.7324347",
"0.7310399",
"0.7304036",
"0.72892624",
"0.7284477",
"0.72233516",
"0.7186214",
"0.7185038",
"0.7158732",
"0.71572274",
"0.7150702",
"0.7124124",
"0.7089004",
"0.7087673",
"0.7077956",
"0.70659965",
"0.7064473",
"0.7033919",
"0.70215225",
"0.70097744... | 0.7681724 | 0 |
cast(itkLightObject obj) > itkTernaryAddImageFilterIUL3IUL3IUL3IUL3 | def cast(*args):
return _itkTernaryAddImageFilterPython.itkTernaryAddImageFilterIUL3IUL3IUL3IUL3_cast(*args) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def cast(obj: 'itkLightObject') -> \"itkHuangThresholdImageFilterIF3IUS3 *\":\n return _itkHuangThresholdImageFilterPython.itkHuangThresholdImageFilterIF3IUS3_cast(obj)",
"def cast(obj: 'itkLightObject') -> \"itkHuangThresholdImageFilterIUS3IUS3 *\":\n return _itkHuangThresholdImageFilterPython.itk... | [
"0.7647566",
"0.7561853",
"0.7548788",
"0.753728",
"0.75245917",
"0.7512707",
"0.74969774",
"0.7495816",
"0.7483497",
"0.74777776",
"0.7451763",
"0.74383324",
"0.7436231",
"0.7423924",
"0.7415188",
"0.7409509",
"0.7404221",
"0.73695934",
"0.7364972",
"0.7341425",
"0.73326707"... | 0.70471674 | 62 |
New() > itkTernaryAddImageFilterIUL3IUL3IUL3IUL3 Create a new object of the class itkTernaryAddImageFilterIUL3IUL3IUL3IUL3 and set the input and the parameters if some named or nonnamed arguments are passed to that method. New() tries to assign all the non named parameters to the input of the new objects the first non named parameter in the first input, etc. The named parameters are used by calling the method with the same name prefixed by 'Set'. | def New(*args, **kargs):
obj = itkTernaryAddImageFilterIUL3IUL3IUL3IUL3.__New_orig__()
import itkTemplate
itkTemplate.New(obj, *args, **kargs)
return obj | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def New(*args, **kargs):\n obj = itkTernaryAddImageFilterIF3IF3IF3IF3.__New_orig__()\n import itkTemplate\n itkTemplate.New(obj, *args, **kargs)\n return obj",
"def New(*args, **kargs):\n obj = itkTernaryAddImageFilterIF3IF3IF3IF3_Superclass.__New_orig__()\n import itkTe... | [
"0.81462044",
"0.8110021",
"0.7995434",
"0.7912326",
"0.79099345",
"0.787577",
"0.77468467",
"0.7723048",
"0.77158433",
"0.7480538",
"0.74527663",
"0.73376215",
"0.7280301",
"0.7275997",
"0.7273901",
"0.7256137",
"0.723621",
"0.72328305",
"0.7226152",
"0.7203478",
"0.7197948"... | 0.814467 | 1 |
itkTernaryAddImageFilterIUL3IUL3IUL3IUL3_cast(itkLightObject obj) > itkTernaryAddImageFilterIUL3IUL3IUL3IUL3 | def itkTernaryAddImageFilterIUL3IUL3IUL3IUL3_cast(*args):
return _itkTernaryAddImageFilterPython.itkTernaryAddImageFilterIUL3IUL3IUL3IUL3_cast(*args) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def itkTernaryAddImageFilterIUC3IUC3IUC3IUC3_cast(*args):\n return _itkTernaryAddImageFilterPython.itkTernaryAddImageFilterIUC3IUC3IUC3IUC3_cast(*args)",
"def itkTernaryAddImageFilterIF3IF3IF3IF3_cast(*args):\n return _itkTernaryAddImageFilterPython.itkTernaryAddImageFilterIF3IF3IF3IF3_cast(*args)",
"def itk... | [
"0.7748961",
"0.76095223",
"0.7589307",
"0.75607187",
"0.7520681",
"0.7497383",
"0.74870694",
"0.74818844",
"0.7464951",
"0.74644643",
"0.74344575",
"0.74030006",
"0.7387342",
"0.73710954",
"0.7369231",
"0.7366797",
"0.7360392",
"0.73567164",
"0.73386925",
"0.7336549",
"0.733... | 0.78951705 | 0 |
cast(itkLightObject obj) > itkTernaryAddImageFilterIUS2IUS2IUS2IUS2 | def cast(*args):
return _itkTernaryAddImageFilterPython.itkTernaryAddImageFilterIUS2IUS2IUS2IUS2_cast(*args) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def itkHuangThresholdImageFilterIUS2IUS2_cast(obj: 'itkLightObject') -> \"itkHuangThresholdImageFilterIUS2IUS2 *\":\n return _itkHuangThresholdImageFilterPython.itkHuangThresholdImageFilterIUS2IUS2_cast(obj)",
"def cast(obj: 'itkLightObject') -> \"itkHuangThresholdImageFilterIUS2IUS2 *\":\n return _itk... | [
"0.795775",
"0.79334676",
"0.79191446",
"0.78629583",
"0.77982414",
"0.7746097",
"0.76591057",
"0.7601464",
"0.7575579",
"0.75715923",
"0.7570197",
"0.75645965",
"0.7556181",
"0.7556168",
"0.75122136",
"0.7493305",
"0.74912035",
"0.74833924",
"0.74627525",
"0.74295926",
"0.74... | 0.71492976 | 41 |
New() > itkTernaryAddImageFilterIUS2IUS2IUS2IUS2 Create a new object of the class itkTernaryAddImageFilterIUS2IUS2IUS2IUS2 and set the input and the parameters if some named or nonnamed arguments are passed to that method. New() tries to assign all the non named parameters to the input of the new objects the first non named parameter in the first input, etc. The named parameters are used by calling the method with the same name prefixed by 'Set'. | def New(*args, **kargs):
obj = itkTernaryAddImageFilterIUS2IUS2IUS2IUS2.__New_orig__()
import itkTemplate
itkTemplate.New(obj, *args, **kargs)
return obj | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def New(*args, **kargs):\n obj = itkTernaryAddImageFilterIUS2IUS2IUS2IUS2_Superclass.__New_orig__()\n import itkTemplate\n itkTemplate.New(obj, *args, **kargs)\n return obj",
"def New(*args, **kargs):\n obj = itkSquaredDifferenceImageFilterIUS2IUS2IUS2.__New_orig__()\n i... | [
"0.80503565",
"0.7489746",
"0.7481182",
"0.74704665",
"0.7466978",
"0.7464551",
"0.74596614",
"0.74402666",
"0.74363726",
"0.7434975",
"0.73753166",
"0.734277",
"0.73379105",
"0.7327973",
"0.7306081",
"0.7305786",
"0.7299731",
"0.7296037",
"0.7261096",
"0.7260247",
"0.7259942... | 0.83108383 | 0 |
itkTernaryAddImageFilterIUS2IUS2IUS2IUS2_cast(itkLightObject obj) > itkTernaryAddImageFilterIUS2IUS2IUS2IUS2 | def itkTernaryAddImageFilterIUS2IUS2IUS2IUS2_cast(*args):
return _itkTernaryAddImageFilterPython.itkTernaryAddImageFilterIUS2IUS2IUS2IUS2_cast(*args) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def itkHuangThresholdImageFilterIUS2IUS2_cast(obj: 'itkLightObject') -> \"itkHuangThresholdImageFilterIUS2IUS2 *\":\n return _itkHuangThresholdImageFilterPython.itkHuangThresholdImageFilterIUS2IUS2_cast(obj)",
"def itkHuangThresholdImageFilterIF2IUS2_cast(obj: 'itkLightObject') -> \"itkHuangThresholdImageFilt... | [
"0.8039066",
"0.803752",
"0.799232",
"0.78865457",
"0.7822779",
"0.7739733",
"0.76613253",
"0.7638676",
"0.76206696",
"0.7589836",
"0.75830173",
"0.7563245",
"0.75561917",
"0.7547682",
"0.7529822",
"0.7529683",
"0.75135267",
"0.75091255",
"0.74985117",
"0.74913585",
"0.748500... | 0.79412234 | 3 |
cast(itkLightObject obj) > itkTernaryAddImageFilterIUS3IUS3IUS3IUS3 | def cast(*args):
return _itkTernaryAddImageFilterPython.itkTernaryAddImageFilterIUS3IUS3IUS3IUS3_cast(*args) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def cast(obj: 'itkLightObject') -> \"itkHuangThresholdImageFilterIUS3IUS3 *\":\n return _itkHuangThresholdImageFilterPython.itkHuangThresholdImageFilterIUS3IUS3_cast(obj)",
"def cast(obj: 'itkLightObject') -> \"itkHuangThresholdImageFilterIUS2IUS2 *\":\n return _itkHuangThresholdImageFilterPython.i... | [
"0.7828117",
"0.77500296",
"0.7680378",
"0.76507425",
"0.76472664",
"0.76291966",
"0.7628558",
"0.76244795",
"0.76156825",
"0.76125294",
"0.7602379",
"0.75422204",
"0.75175846",
"0.7516735",
"0.75001353",
"0.7496559",
"0.7451433",
"0.7428584",
"0.74199283",
"0.7396845",
"0.73... | 0.72114044 | 36 |
New() > itkTernaryAddImageFilterIUS3IUS3IUS3IUS3 Create a new object of the class itkTernaryAddImageFilterIUS3IUS3IUS3IUS3 and set the input and the parameters if some named or nonnamed arguments are passed to that method. New() tries to assign all the non named parameters to the input of the new objects the first non named parameter in the first input, etc. The named parameters are used by calling the method with the same name prefixed by 'Set'. | def New(*args, **kargs):
obj = itkTernaryAddImageFilterIUS3IUS3IUS3IUS3.__New_orig__()
import itkTemplate
itkTemplate.New(obj, *args, **kargs)
return obj | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def New(*args, **kargs):\n obj = itkTernaryAddImageFilterIUS3IUS3IUS3IUS3_Superclass.__New_orig__()\n import itkTemplate\n itkTemplate.New(obj, *args, **kargs)\n return obj",
"def New(*args, **kargs):\n obj = itkTernaryAddImageFilterIF3IF3IF3IF3.__New_orig__()\n import i... | [
"0.81209564",
"0.76765245",
"0.76381725",
"0.7637697",
"0.76059175",
"0.75846446",
"0.75640565",
"0.75020564",
"0.7486624",
"0.747826",
"0.7462136",
"0.7449853",
"0.74443847",
"0.7438893",
"0.7429914",
"0.74282986",
"0.74251896",
"0.74120355",
"0.73986375",
"0.7391535",
"0.73... | 0.83841634 | 0 |
itkTernaryAddImageFilterIUS3IUS3IUS3IUS3_cast(itkLightObject obj) > itkTernaryAddImageFilterIUS3IUS3IUS3IUS3 | def itkTernaryAddImageFilterIUS3IUS3IUS3IUS3_cast(*args):
return _itkTernaryAddImageFilterPython.itkTernaryAddImageFilterIUS3IUS3IUS3IUS3_cast(*args) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def itkHuangThresholdImageFilterIUS3IUS3_cast(obj: 'itkLightObject') -> \"itkHuangThresholdImageFilterIUS3IUS3 *\":\n return _itkHuangThresholdImageFilterPython.itkHuangThresholdImageFilterIUS3IUS3_cast(obj)",
"def itkHuangThresholdImageFilterIF3IUS3_cast(obj: 'itkLightObject') -> \"itkHuangThresholdImageFilt... | [
"0.80789053",
"0.80319655",
"0.8008976",
"0.79430354",
"0.79271203",
"0.78627837",
"0.78258866",
"0.782384",
"0.781271",
"0.779851",
"0.77923465",
"0.7790801",
"0.7773563",
"0.77652675",
"0.7721575",
"0.770351",
"0.7701595",
"0.7673285",
"0.7649216",
"0.76348764",
"0.7603356"... | 0.81228995 | 0 |
Compute the aperture radius necessary to have a certain SPAXEL SCALE [in mas] at a certain WAVELENGTH [in microns] | def spaxel_scale(scale=4, wave=1.0):
scale_rad = scale / MILIARCSECS_IN_A_RAD
rho = scale_rad * ELT_DIAM / (wave * 1e-6)
print(rho) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getSphereRadius(self):\n return 1.5",
"def totalMass(self, trunc=None):\n if trunc is None:\n trunc = self.trunc\n rVir = self.U.rVir(m, z)\n rS, rhoS, c = self.rS_rhoS_c(m, z)\n # truncation radius over scale radius\n xMax = trunc * rVir/rS\n result = 4./3. * np.... | [
"0.6156244",
"0.6068487",
"0.6068487",
"0.6032485",
"0.6008205",
"0.5966811",
"0.5919071",
"0.5859431",
"0.5852741",
"0.58379126",
"0.5818871",
"0.5818871",
"0.58174205",
"0.580654",
"0.5779134",
"0.57611865",
"0.57207704",
"0.5711433",
"0.57023317",
"0.56883377",
"0.5678015"... | 0.5964626 | 6 |
Compute the aperture radius necessary to have a certain SPAXEL SCALE [in mas] at a certain WAVELENGTH [in microns] That would be the aperture radius in an array ranging from [1, 1] in physical length For example, if rho = 0.5, then the necessary aperture is a circle of half the size of the array We can use the inverse of that to get the "oversize" in physical units in our arrays to match a given scale | def rho_spaxel_scale(spaxel_scale=4.0, wavelength=1.0):
scale_rad = spaxel_scale / MILIARCSECS_IN_A_RAD
rho = scale_rad * ELT_DIAM / (wavelength * 1e-6)
return rho | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def spaxel_scale(scale=4, wave=1.0):\n\n scale_rad = scale / MILIARCSECS_IN_A_RAD\n rho = scale_rad * ELT_DIAM / (wave * 1e-6)\n print(rho)",
"def check_spaxel_scale(rho_aper, wavelength):\n\n SPAXEL_RAD = rho_aper * wavelength / ELT_DIAM * 1e-6\n SPAXEL_MAS = SPAXEL_RAD * MILIARCSECS_IN_A_RAD\n ... | [
"0.6397559",
"0.59061825",
"0.58994806",
"0.5894734",
"0.58598316",
"0.58598316",
"0.5819259",
"0.5739598",
"0.57345325",
"0.56258273",
"0.5618448",
"0.5549182",
"0.55437136",
"0.5513248",
"0.55029523",
"0.5493522",
"0.54327166",
"0.54285365",
"0.5425453",
"0.54176575",
"0.54... | 0.6352933 | 1 |
Checks the spaxel scale at a certain wavelength, for a given aperture radius defined for a [1, 1] physical array | def check_spaxel_scale(rho_aper, wavelength):
SPAXEL_RAD = rho_aper * wavelength / ELT_DIAM * 1e-6
SPAXEL_MAS = SPAXEL_RAD * MILIARCSECS_IN_A_RAD
print('%.2f mas spaxels at %.2f microns' %(SPAXEL_MAS, wavelength)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def spaxel_scale(scale=4, wave=1.0):\n\n scale_rad = scale / MILIARCSECS_IN_A_RAD\n rho = scale_rad * ELT_DIAM / (wave * 1e-6)\n print(rho)",
"def rho_spaxel_scale(spaxel_scale=4.0, wavelength=1.0):\n\n scale_rad = spaxel_scale / MILIARCSECS_IN_A_RAD\n rho = scale_rad * ELT_DIAM / (wavelength * 1e... | [
"0.63555455",
"0.6032541",
"0.5720245",
"0.56559825",
"0.55820227",
"0.5571117",
"0.55641395",
"0.5554358",
"0.55440706",
"0.5535525",
"0.54904956",
"0.5435876",
"0.5406285",
"0.5405981",
"0.5359477",
"0.53531414",
"0.5340021",
"0.53357816",
"0.53222436",
"0.53126466",
"0.530... | 0.71937263 | 0 |
Returns a Dictionary for the triangular numbers associated with the Zernike pyramid | def triangular_numbers(N_levels):
zernike_rows = list(np.arange(1, N_levels + 1))
triangular = {}
for i, zernike_per_row in enumerate(zernike_rows):
total = np.sum(zernike_rows[:i+1])
triangular[zernike_per_row] = total
return triangular | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _get_tri_dict(self):\n tri_dict = dict(\n vertices=np.concatenate([self.contour.vertices] + [hole.vertices for hole in self.holes]),\n segments=list(self._segment_pairs())\n )\n if self.holes:\n tri_dict['holes'] = np.array([hole.interior_point for hole in ... | [
"0.67723066",
"0.6626647",
"0.5800086",
"0.5686751",
"0.5580213",
"0.55674565",
"0.5506504",
"0.54808724",
"0.5421397",
"0.54160047",
"0.5405297",
"0.5372639",
"0.5343492",
"0.5306792",
"0.530101",
"0.5289107",
"0.5287096",
"0.5276585",
"0.52750313",
"0.52660143",
"0.52657723... | 0.6907697 | 0 |
Computes the (Xc, Yc) coordinates of actuator centres inside a circle of rho_aper, assuming there are N_actuators along the [1, 1] line | def actuator_centres(N_actuators, rho_aper=RHO_APER, rho_obsc=RHO_OBSC):
x0 = np.linspace(-1., 1., N_actuators, endpoint=True)
delta = x0[1] - x0[0]
N_in_D = 2*RHO_APER/delta
print('%.2f actuators in D' %N_in_D)
max_freq = N_in_D / 2 # Max spatial frequency we can sense
xx, yy = np.meshgrid(x0, x0)
x_f = xx.flatten()
y_f = yy.flatten()
act = []
for x_c, y_c in zip(x_f, y_f):
r = np.sqrt(x_c ** 2 + y_c ** 2)
if r < 0.97 * rho_aper and r > 1.05 * rho_obsc:
act.append([x_c, y_c])
total_act = len(act)
print('Total Actuators: ', total_act)
return [act, delta], max_freq | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def center_of_charge(self):\n ret = [0.0, 0.0, 0.0]\n total_c = 0.0\n\n for at in range(self.natom()):\n c = self.charge(at)\n ret = add(ret, scale(self.xyz(at), c))\n total_c += c\n\n ret = scale(ret, 1.0 / total_c)\n return ret",
"def gen_cent... | [
"0.6132837",
"0.5954457",
"0.5869159",
"0.5858206",
"0.5853505",
"0.5796136",
"0.57292473",
"0.5709713",
"0.5697524",
"0.5693983",
"0.56876165",
"0.56802106",
"0.56581277",
"0.56567794",
"0.5652664",
"0.5648251",
"0.56471676",
"0.5623604",
"0.561589",
"0.56110007",
"0.5595283... | 0.69552195 | 0 |
Compute the PEAK of the PSF without aberrations so that we can normalize everything by it | def peak_PSF(self):
im, strehl = self.compute_PSF(np.zeros(self.N_act))
return strehl | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def pulp_smash():",
"def peak_PSF(self):\n return self.compute_PSF(np.zeros(self.N_zern))",
"def cal_pn(grams_set, grams, candidate, reference):\n count = 0\n for gram in grams_set:\n # print(gram)\n count += count_clip(gram, grams, reference)\n # calculate log() for p, so '+10**-... | [
"0.58542764",
"0.58267516",
"0.5633884",
"0.5620691",
"0.5568786",
"0.5546477",
"0.5538438",
"0.5512286",
"0.5491357",
"0.5486278",
"0.53827614",
"0.535951",
"0.5333681",
"0.53270435",
"0.5324692",
"0.5322697",
"0.53162724",
"0.5314971",
"0.5281472",
"0.5278054",
"0.5277989",... | 0.60214907 | 0 |
Compute the PSF and the Strehl ratio | def compute_PSF(self, coef, crop=True):
phase = np.dot(self.RBF_mat, coef) + self.defocus
pupil_function = self.pupil_mask * np.exp(2 * np.pi * 1j * phase)
image = (np.abs(fftshift(fft2(pupil_function))))**2
try:
image /= self.PEAK
except AttributeError:
# If self.PEAK is not defined, self.compute_PSF will compute the peak
pass
strehl = np.max(image)
if crop:
image = image[self.minPix:self.maxPix, self.minPix:self.maxPix]
else:
pass
return image, strehl | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_percentage_sf_votes(self):\n\n votes_f = self.get_num_f_votes()\n votes_sf = self.get_num_sf_votes()\n\n # avoid dividing by zero\n if votes_f + votes_sf == 0:\n return 0\n else:\n ratio = float(votes_sf)/(votes_f + votes_sf)\n return roun... | [
"0.6681911",
"0.6620132",
"0.65377945",
"0.6458727",
"0.6316942",
"0.6316942",
"0.62935734",
"0.6280627",
"0.62713075",
"0.6183255",
"0.6126164",
"0.6119334",
"0.61046535",
"0.6037856",
"0.6029699",
"0.60194486",
"0.6016596",
"0.60025454",
"0.5961723",
"0.5926681",
"0.5922735... | 0.0 | -1 |
Plot an image of the PSF | def plot_PSF(self, coef, wave_idx):
PSF, strehl = self.compute_PSF(coef, wave_idx)
plt.figure()
plt.imshow(PSF)
plt.title('Strehl: %.3f' %strehl)
plt.colorbar()
plt.clim(vmin=0, vmax=1) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def plot_prodata_psf(self,font_size=28,img_name='prodata_psf.pdf',img_id=0):\n rawimage = self.raw_image\n dataimage = self.data\n len_mask = self.lens_mask\n plu_mask_out = self.plu_mask\n\n fig, (ax1, ax2, ax3, ax4,ax5) = plt.subplots(1, 5, figsize=(19, 10))\n ax1.imshow... | [
"0.68390614",
"0.667332",
"0.6661213",
"0.662219",
"0.655755",
"0.655406",
"0.6526125",
"0.6526125",
"0.6526125",
"0.6519338",
"0.64991987",
"0.64458805",
"0.6437348",
"0.643601",
"0.6406592",
"0.63417786",
"0.6327013",
"0.63187444",
"0.6312867",
"0.6310806",
"0.63035756",
... | 0.6686292 | 1 |
Given an oversampled PSF (typically 0.51.0 mas spaxels), it calculates the Ensquared Energy of the central spaxel in a new_scale (4, 10, 20 mas) It selects a window of size new_scale and adds up the Intensity of those pixels | def ensquared_one_pix(array, pix_scale, new_scale=40, plot=True):
n = int(new_scale // pix_scale)
minPix, maxPix = (pix + 1 - n) // 2, (pix + 1 + n) // 2
ens = array[minPix:maxPix, minPix:maxPix]
# print(ens.shape)
energy = np.sum(ens)
if plot:
mapp = 'viridis'
f, (ax1, ax2) = plt.subplots(1, 2)
ax1 = plt.subplot(1, 2, 1)
square = Rectangle((minPix-0.5, minPix-0.5), n, n, linestyle='--', fill=None, color='white')
ax1.add_patch(square)
img1 = ax1.imshow(array, cmap=mapp)
ax1.set_title('%.1f mas pixels' % (pix_scale))
img1.set_clim(0, 1)
plt.colorbar(img1, ax=ax1, orientation='horizontal')
ax2 = plt.subplot(1, 2, 2)
img2 = ax2.imshow(ens, cmap=mapp)
ax2.set_title('%d mas window' %new_scale)
img1.set_clim(0, 1)
plt.colorbar(img2, ax=ax2, orientation='horizontal')
return energy | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _scale_psf(self, input_irf_file, config):\n\n # Find all \"sigma\" values - tells how many PSF components we have in the IRF file\n column_names = [col.name.lower() for col in input_irf_file['POINT SPREAD FUNCTION'].columns]\n sigma_columns = list(filter(lambda s: \"sigma\" in s.lower(), c... | [
"0.61338806",
"0.6089663",
"0.6083601",
"0.60192114",
"0.58811396",
"0.5845473",
"0.57790524",
"0.56270677",
"0.56215096",
"0.5540787",
"0.5538469",
"0.5513849",
"0.55025077",
"0.54857355",
"0.5447501",
"0.5444619",
"0.5426935",
"0.5422314",
"0.5416228",
"0.5408127",
"0.53833... | 0.65217674 | 0 |
update kth(0indexed) value with a | def set_val(self, k, a):
k += self.n - 1
self.dat[k] = a
while k > 0:
k = (k - 1) // 2 # parent
self.dat[k] = self.op(self.dat[k * 2 + 1], self.dat[k * 2 + 2]) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __setitem__(self, k, v):\n\n self.valores[( zero - k )%self.longitud] = v",
"def _bucket_setitem(self, j, k, v):\n if self._table[j] is None:\n self._table[j] = UnsortedTableMap() # create new bucket at index j\n oldSize = len(self._table[j])\n self._table[j][k] = v\n ... | [
"0.69229925",
"0.6456467",
"0.6364326",
"0.62770015",
"0.6199403",
"0.60915345",
"0.6048265",
"0.6025952",
"0.60192573",
"0.59893894",
"0.59650415",
"0.59532386",
"0.5934357",
"0.59224254",
"0.58959097",
"0.5847799",
"0.5826606",
"0.5785241",
"0.577905",
"0.5765922",
"0.57567... | 0.7316253 | 0 |
recursive version, Ref. Ant Book p.155 | def query_recursive(self, p, q):
if q <= p:
return self.e()
return self._query_recursive(p, q, 0, 0, self.n) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def recursive():\n with Local() as tun:\n tun.call(recursive)",
"def lis_recursive(array):\n\n #TODO",
"def test_scan_recursive(self):\n self.run_scan(self.tempdir, self.root_fcount + self.nest_fcount + 1)",
"def test_level1_recursion(self):\n recursed = recurse_files('filename', s... | [
"0.64885056",
"0.6223022",
"0.60090613",
"0.5734339",
"0.55864066",
"0.55643034",
"0.5554218",
"0.55151844",
"0.55021846",
"0.5453173",
"0.54176205",
"0.5387818",
"0.538237",
"0.536489",
"0.53377",
"0.5313174",
"0.5310064",
"0.5292833",
"0.5277829",
"0.5275689",
"0.52746475",... | 0.0 | -1 |
Returns the number at the nth position in the Fibonacci sequence | def fib(n):
fib = [0, 1]
if n > 2:
for i in range(n):
fib.append(fib[-1] + fib[-2])
return fib[n-1]
else:
return fib[n-1] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_fib(position):\n\n # Base Case: Positions greater thatn 0 or 1, since Fibonacci for 0 is 0 and\n # 1 is 1.\n if position == 0 or position == 1:\n return position\n\n return get_fib(position - 1) + get_fib(position - 2)",
"def fast_fibonacci(n):\n return _fast_fibonacci(n)[0]",
"de... | [
"0.7997541",
"0.79853135",
"0.7872735",
"0.78044224",
"0.7801214",
"0.77594495",
"0.77388746",
"0.7687958",
"0.76830304",
"0.7671803",
"0.7670554",
"0.7667316",
"0.76668704",
"0.76389676",
"0.7613944",
"0.7574987",
"0.7570288",
"0.7553658",
"0.75406444",
"0.75240415",
"0.7495... | 0.74367195 | 32 |
Returns a readbyread fastQ parser analogous to file.readline(). | def __init__(self,filePath,headerSymbols=['@','+']):
if filePath.endswith('.gz'):
self._file = gzip.open(filePath)
else:
self._file = open(filePath, 'rU')
self._currentLineNumber = 0
self._hdSyms = headerSymbols | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def readfq(fp): # this is a generator function\n last = None # this is a buffer keeping the last unprocessed line\n while True: # mimic closure; is it a bad idea?\n if not last: # the first record or a record following a fastq\n for l in fp: # search for the start of the next record\n ... | [
"0.6683479",
"0.60699964",
"0.6053965",
"0.6047205",
"0.60288286",
"0.5997878",
"0.5994087",
"0.5935865",
"0.5871207",
"0.57843333",
"0.5736459",
"0.5680758",
"0.5660535",
"0.55910975",
"0.55550677",
"0.55075556",
"0.54911923",
"0.5433011",
"0.5417076",
"0.5411586",
"0.540513... | 0.0 | -1 |
Reads in next element, parses, and does minimal verification. | def __next__(self):
# ++++ Get Next Four Lines ++++
elemList = []
for i in range(4):
line = self._file.readline()
self._currentLineNumber += 1 ## increment file position
if line:
elemList.append(line.strip('\n'))
else:
elemList.append(None)
# ++++ Check Lines For Expected Form ++++
trues = [bool(x) for x in elemList].count(True)
nones = elemList.count(None)
# -- Check for acceptable end of file --
if nones == 4:
raise StopIteration
# -- Make sure we got 4 full lines of data --
assert trues == 4,\
"** ERROR: It looks like I encountered a premature EOF or empty line.\n\
Please check FastQ file near line number %s (plus or minus ~4 lines) and try again**" % (self._currentLineNumber)
# -- Make sure we are in the correct "register" --
assert elemList[0].startswith(self._hdSyms[0]),\
"** ERROR: The 1st line in fastq element does not start with '%s'.\n\
Please check FastQ file near line number %s (plus or minus ~4 lines) and try again**" % (self._hdSyms[0],self._currentLineNumber)
assert elemList[2].startswith(self._hdSyms[1]),\
"** ERROR: The 3rd line in fastq element does not start with '%s'.\n\
Please check FastQ file near line number %s (plus or minus ~4 lines) and try again**" % (self._hdSyms[1],self._currentLineNumber)
# -- Make sure the seq line and qual line have equal lengths --
assert len(elemList[1]) == len(elemList[3]), "** ERROR: The length of Sequence data and Quality data of the last record aren't equal.\n\
Please check FastQ file near line number %s (plus or minus ~4 lines) and try again**" % (self._currentLineNumber)
# ++++ Return fatsQ data as tuple ++++
return tuple(elemList) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def next():",
"def next():",
"def next_element(self):\n return self.extract_element()",
"def has_next():",
"def next(self):\r\n\t\tself.index += 1\r\n\t\treturn not self.eof()",
"def test_parse_valid(self):\n mock_scraper = MockCtdScraper()\n scrape_gen = mock_scraper.scrape(TEST_CHU... | [
"0.61624813",
"0.61624813",
"0.61127424",
"0.590448",
"0.5778166",
"0.57393956",
"0.5720215",
"0.5717263",
"0.5713561",
"0.5713561",
"0.5713561",
"0.5713561",
"0.55759835",
"0.5551853",
"0.5442391",
"0.542108",
"0.54165864",
"0.5374671",
"0.5373377",
"0.5344817",
"0.53154594"... | 0.55927616 | 12 |
Create or Delete an Override. Since we have the concept of a default for any given preference we only need to store items that are different than the default. So when we 'update' a preference we first check to see if the value is equal to the default and either drop the request on the floor or remove the custom override we have set. | def update(
cls,
auth_token: str,
site_url: str,
key: str,
value: Any,
) -> Preference:
user_id = cls.get_user_id(site_url=site_url, token=auth_token)
site_default = SiteController.default_for_key(site_url=site_url, key=key)
# First we need to check that the value is the correct type and
# determine if we need to add/remove an override for the value.
default_for_site = site_default.serialize()
kind = site_default.kind
try:
serialize_custom_value = site_default.serialize(value)
except Exception:
raise ValueError(f'Expected {kind} for key {key}')
reset_to_default = (default_for_site == serialize_custom_value)
if reset_to_default:
Override.objects.filter(
site__pk=site_url,
user_id=user_id,
key=key,
).delete()
return site_default.to_preference(user_id=user_id)
site = SiteController.get(site_url=site_url)
override, _created = Override.objects.update_or_create(
site=site,
user_id=user_id,
kind=kind,
key=key,
defaults={'value': serialize_custom_value}
)
return override.to_preference() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def override_dict(d, **overrides):\n to_delete = []\n to_restore = {}\n try:\n for k, v in overrides.items():\n if k in d:\n to_restore[k] = d[k]\n else:\n to_delete.append(k)\n if v is None:\n d.pop(k, None) # Delete ke... | [
"0.5960256",
"0.590297",
"0.5773372",
"0.5702012",
"0.5510236",
"0.5490459",
"0.54790086",
"0.5437721",
"0.5424676",
"0.54007906",
"0.5397106",
"0.52891964",
"0.5250817",
"0.5232657",
"0.5229502",
"0.5227945",
"0.52064884",
"0.5171837",
"0.51337427",
"0.51274",
"0.5075617",
... | 0.53815335 | 11 |
Training script for hyperparameter evaluation of Gradient Boosting model | def lgb_trial(args, reporter):
try_import_lightgbm()
import lightgbm as lgb
# list of args which are not model hyperparameters:
nonparam_args = set(['directory', 'task_id', 'lgb_model', 'dataset_train_filename', 'dataset_val_filename'])
trial_id = args.task_id # Note may not start at 0 if HPO has been run for other models with same scheduler
directory = args.directory
file_prefix = "trial_"+str(trial_id)+"_" # append to all file names created during this trial. Do NOT change!
lgb_model = args.lgb_model
lgb_model.params = lgb_model.params.copy() # ensure no remaining pointers across trials
for key in args:
if key not in nonparam_args:
lgb_model.params[key] = args[key] # use these hyperparam values in this trial
dataset_train = lgb.Dataset(directory+args.dataset_train_filename)
dataset_val_filename = args.get('dataset_val_filename', None)
if dataset_val_filename is not None:
dataset_val = lgb.Dataset(directory+dataset_val_filename)
eval_metric = lgb_model.get_eval_metric()
if lgb_model.problem_type == BINARY:
train_loss_name = 'binary_logloss'
elif lgb_model.problem_type == MULTICLASS:
train_loss_name = 'multi_logloss'
elif lgb_model.problem_type == REGRESSION:
train_loss_name = 'l2'
else:
raise ValueError("unknown problem_type for LGBModel: %s" % lgb_model.problem_type)
lgb_model.eval_results = {}
callbacks = []
valid_names = ['train_set']
valid_sets = [dataset_train]
if dataset_val is not None:
callbacks += [
hpo_callback(reporter=reporter, stopping_rounds=150, metrics_to_use=[('valid_set', lgb_model.eval_metric_name)],
max_diff=None, ignore_dart_warning=True, verbose=False, train_loss_name=train_loss_name, eval_results=lgb_model.eval_results)
]
valid_names = ['valid_set'] + valid_names
valid_sets = [dataset_val] + valid_sets
else:
raise NotImplementedError("cannot call gbm hyperparameter_tune without validation dataset")
num_boost_round = lgb_model.params.pop('num_boost_round', 1000)
seed_value = lgb_model.params.pop('seed_value', None)
train_params = {
'params': lgb_model.params.copy(),
'train_set': dataset_train,
'num_boost_round': num_boost_round,
'valid_sets': valid_sets,
'valid_names': valid_names,
'evals_result': lgb_model.eval_results,
'callbacks': callbacks,
'verbose_eval': -1,
}
if type(eval_metric) != str:
train_params['feval'] = eval_metric
if seed_value is not None:
train_params['seed'] = seed_value
random.seed(seed_value)
np.random.seed(seed_value)
lgb_model.model = lgb.train(**train_params)
lgb_model.params['num_boost_round'] = num_boost_round # re-set this value after training
if seed_value is not None:
lgb_model.params['seed_value'] = seed_value
lgb_model.best_iteration = lgb_model.model.best_iteration
# TODO: difficult to ensure these iters always match
# if lgb_model.eval_results['best_iter'] != lgb_model.best_iteration:
# raise ValueError('eval_results[best_iter]=%s does not match lgb_model.best_iteration=%s' % (lgb_model.eval_results['best_iter'], lgb_model.best_iteration) )
# print('eval_results[best_iter]=%s does not match lgb_model.best_iteration=%s' % (lgb_model.eval_results['best_iter'], lgb_model.best_iteration) )
trial_model_file = lgb_model.save(file_prefix=file_prefix, directory=directory, return_filename=True)
reporter(epoch=num_boost_round+1, validation_performance=lgb_model.eval_results['best_valperf'],
train_loss=lgb_model.eval_results['best_trainloss'],
best_iteration=lgb_model.eval_results['best_iter'],
directory=directory, file_prefix=file_prefix, trial_model_file=trial_model_file)
# TODO: add to reporter: time_of_trial without load/save time (isn't this just function of early-stopping point?), memory/inference ?? | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def config1() :\n data_name = \"titanic\" ### in data/input/\n model_class = 'AutoML' ### ACTUAL Class name for model_sklearn.py\n n_sample = 1000\n\n def post_process_fun(y): ### After prediction is done\n return int(y)\n\n def pre_process_fun(y): ### Before the predic... | [
"0.67224866",
"0.6687999",
"0.653288",
"0.65224236",
"0.6393243",
"0.63662755",
"0.6364721",
"0.6355219",
"0.6346097",
"0.63401467",
"0.6327798",
"0.63157797",
"0.6307998",
"0.6305631",
"0.6280537",
"0.6278629",
"0.6274313",
"0.6273152",
"0.62397677",
"0.622105",
"0.62110114"... | 0.0 | -1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.