code
string | signature
string | docstring
string | loss_without_docstring
float64 | loss_with_docstring
float64 | factor
float64 |
|---|---|---|---|---|---|
result = []
names = javabridge.call(self.jobject, "getVariableNames", "()Ljava/util/Set;")
for name in javabridge.iterate_collection(names):
result.append(javabridge.to_string(name))
return result
|
def variable_names(self)
|
Returns the names of all environment variables.
:return: the names of the variables
:rtype: list
| 3.86736
| 3.941799
| 0.981115
|
cls = javabridge.call(self.jobject, "getClass", "()Ljava/lang/Class;")
comptype = javabridge.call(cls, "getComponentType", "()Ljava/lang/Class;")
return javabridge.call(comptype, "getName", "()Ljava/lang/String;")
|
def component_type(self)
|
Returns the classname of the elements.
:return: the class of the elements
:rtype: str
| 2.605774
| 2.591824
| 1.005383
|
return javabridge.static_call(
"Ljava/lang/reflect/Array;",
"newInstance",
"(Ljava/lang/Class;I)Ljava/lang/Object;",
get_jclass(classname=classname), length)
|
def new_instance(cls, classname, length)
|
Creates a new array with the given classname and length; initial values are null.
:param classname: the classname in Java notation (eg "weka.core.DenseInstance")
:type classname: str
:param length: the length of the array
:type length: int
:return: the Java array
:rtype: JB_Object
| 3.638666
| 3.842524
| 0.946947
|
cls = javabridge.call(self.jobject, "getClass", "()Ljava/lang/Class;")
clsname = javabridge.call(cls, "getName", "()Ljava/lang/String;")
l = javabridge.static_call(clsname.replace(".", "/"), "values", "()[L" + clsname.replace(".", "/") + ";")
l = javabridge.get_env().get_object_array_elements(l)
result = []
for item in l:
result.append(Enum(jobject=item))
return result
|
def values(self)
|
Returns list of all enum members.
:return: all enum members
:rtype: list
| 2.821584
| 2.563605
| 1.100631
|
if n is None:
return javabridge.call(self.jobject, "nextInt", "()I")
else:
return javabridge.call(self.jobject, "nextInt", "(I)I", n)
|
def next_int(self, n=None)
|
Next random integer. if n is provided, then between 0 and n-1.
:param n: the upper limit (minus 1) for the random integer
:type n: int
:return: the next random integer
:rtype: int
| 2.366568
| 2.439945
| 0.969927
|
if self.is_optionhandler:
return typeconv.string_array_to_list(javabridge.call(self.jobject, "getOptions", "()[Ljava/lang/String;"))
else:
return []
|
def options(self)
|
Obtains the currently set options as list.
:return: the list of options
:rtype: list
| 7.119604
| 7.558863
| 0.941888
|
if self.is_optionhandler:
javabridge.call(self.jobject, "setOptions", "([Ljava/lang/String;)V", typeconv.string_list_to_array(options))
|
def options(self, options)
|
Sets the command-line options (as list).
:param options: the list of command-line options to set
:type options: list
| 7.408288
| 7.97627
| 0.928791
|
result = []
result.append(self.classname)
result.append("=" * len(self.classname))
result.append("")
result.append("DESCRIPTION")
result.append("")
result.append(self.global_info())
result.append("")
result.append("OPTIONS")
result.append("")
options = javabridge.call(self.jobject, "listOptions", "()Ljava/util/Enumeration;")
enum = javabridge.get_enumeration_wrapper(options)
while enum.hasMoreElements():
opt = Option(enum.nextElement())
result.append(opt.synopsis)
result.append(opt.description)
result.append("")
return '\n'.join(result)
|
def to_help(self)
|
Returns a string that contains the 'global_info' text and the options.
:return: the generated help string
:rtype: str
| 2.786333
| 2.555544
| 1.090309
|
result = super(OptionHandler, self).to_dict()
result["type"] = "OptionHandler"
result["options"] = join_options(self.options)
return result
|
def to_dict(self)
|
Returns a dictionary that represents this object, to be used for JSONification.
:return: the object dictionary
:rtype: dict
| 5.018431
| 5.235815
| 0.958481
|
result = OptionHandler(cls.new_instance(d["class"]))
result.options = split_options(d["options"])
return result
|
def from_dict(cls, d)
|
Restores an object state from a dictionary, used in de-JSONification.
:param d: the object dictionary
:type d: dict
:return: the object
:rtype: object
| 12.137487
| 15.280807
| 0.794296
|
result = None
for t in self.array:
if str(t) == name:
result = Tag(t.jobject)
break
return result
|
def find(self, name)
|
Returns the Tag that matches the name.
:param name: the string representation of the tag
:type name: str
:return: the tag, None if not found
:rtype: Tag
| 7.879306
| 6.271979
| 1.256271
|
return Tags(jobject=javabridge.call(javaobject.jobject, methodname, "()[Lweka/core/Tag;"))
|
def get_object_tags(cls, javaobject, methodname)
|
Instantiates the Tag array obtained from the object using the specified method name.
Example:
cls = Classifier(classname="weka.classifiers.meta.MultiSearch")
tags = Tags.get_object_tags(cls, "getMetricsTags")
:param javaobject: the javaobject to obtain the tags from
:type javaobject: JavaObject
:param methodname: the method name returning the Tag array
:type methodname: str
:return: the Tags objects
:rtype: Tags
| 7.474898
| 4.716753
| 1.584755
|
result = []
a = javabridge.call(self.jobject, "getTags", "()Lweka/core/Tag;]")
length = javabridge.get_env().get_array_length(a)
wrapped = javabridge.get_env().get_object_array_elements(a)
for i in range(length):
result.append(Tag(javabridge.get_env().get_string(wrapped[i])))
return result
|
def tags(self)
|
Returns the associated tags.
:return: the list of Tag objects
:rtype: list
| 3.330917
| 3.285326
| 1.013877
|
jobj = javabridge.call(self.jobject, "getBaseObject", "()Ljava/io/Serializable;")
if OptionHandler.check_type(jobj, "weka.core.OptionHandler"):
return OptionHandler(jobj)
else:
return JavaObject(jobj)
|
def base_object(self)
|
Returns the base object to apply the setups to.
:return: the base object
:rtype: JavaObject or OptionHandler
| 5.11627
| 4.05487
| 1.261759
|
if not obj.is_serializable:
raise Exception("Base object must be serializable: " + obj.classname)
javabridge.call(self.jobject, "setBaseObject", "(Ljava/io/Serializable;)V", obj.jobject)
|
def base_object(self, obj)
|
Sets the base object to apply the setups to.
:param obj: the object to use (must be serializable!)
:type obj: JavaObject
| 4.8561
| 3.919152
| 1.239069
|
array = JavaArray(javabridge.call(self.jobject, "getParameters", "()[Lweka/core/setupgenerator/AbstractParameter;"))
result = []
for item in array:
result.append(AbstractParameter(jobject=item.jobject))
return result
|
def parameters(self)
|
Returns the list of currently set search parameters.
:return: the list of AbstractSearchParameter objects
:rtype: list
| 6.418454
| 7.317327
| 0.877158
|
array = JavaArray(jobject=JavaArray.new_instance("weka.core.setupgenerator.AbstractParameter", len(params)))
for idx, obj in enumerate(params):
array[idx] = obj.jobject
javabridge.call(self.jobject, "setParameters", "([Lweka/core/setupgenerator/AbstractParameter;)V", array.jobject)
|
def parameters(self, params)
|
Sets the list of search parameters to use.
:param params: list of AbstractSearchParameter objects
:type params: list
| 5.059152
| 5.884021
| 0.859812
|
result = []
has_options = self.base_object.is_optionhandler
enm = javabridge.get_enumeration_wrapper(javabridge.call(self.jobject, "setups", "()Ljava/util/Enumeration;"))
while enm.hasMoreElements():
if has_options:
result.append(OptionHandler(enm.nextElement()))
else:
result.append(JavaObject(enm.nextElement()))
return result
|
def setups(self)
|
Generates and returns all the setups according to the parameter search space.
:return: the list of configured objects (of type JavaObject)
:rtype: list
| 5.138428
| 4.531825
| 1.133854
|
if isinstance(o, str) and o.startswith("@{") and o.endswith("}"):
return o
else:
return classes.to_commandline(o)
|
def to_commandline(o)
|
Turns the object into a commandline string. However, first checks whether a string represents
a internal value placeholder (@{...}).
:param o: the object to turn into commandline
:type o: object
:return: the commandline
:rtype: str
| 4.446142
| 3.551415
| 1.251935
|
result = name
if self.parent is not None:
index = self.index
bname = re.sub(r'-[0-9]+$', '', name)
names = []
for idx, actor in enumerate(self.parent.actors):
if idx != index:
names.append(actor.name)
result = bname
count = 0
while result in names:
count += 1
result = bname + "-" + str(count)
return result
|
def unique_name(self, name)
|
Generates a unique name.
:param name: the name to check
:type name: str
:return: the unique name
:rtype: str
| 3.352046
| 3.445946
| 0.97275
|
self._name = self.unique_name(self._name)
self._full_name = None
self._logger = None
self._parent = parent
|
def parent(self, parent)
|
Sets the parent of the actor.
:param parent: the parent
:type parent: Actor
| 6.064452
| 8.335482
| 0.727547
|
if self._full_name is None:
fn = self.name.replace(".", "\\.")
parent = self._parent
if parent is not None:
fn = parent.full_name + "." + fn
self._full_name = fn
return self._full_name
|
def full_name(self)
|
Obtains the full name of the actor.
:return: the full name
:rtype: str
| 3.130739
| 3.354239
| 0.933368
|
opt = "annotation"
if opt not in options:
options[opt] = None
if opt not in self.help:
self.help[opt] = "The (optional) annotation for this actor (string)."
opt = "skip"
if opt not in options:
options[opt] = False
if opt not in self.help:
self.help[opt] = "Whether to skip (disable) this actor (bool)."
return super(Actor, self).fix_config(options)
|
def fix_config(self, options)
|
Fixes the options, if necessary. I.e., it adds all required elements to the dictionary.
:param options: the options to fix
:type options: dict
:return: the (potentially) fixed options
:rtype: dict
| 3.537053
| 3.646428
| 0.970005
|
result = super(Actor, self).to_dict()
result["type"] = "Actor"
result["name"] = self.name
return result
|
def to_dict(self)
|
Returns a dictionary that represents this object, to be used for JSONification.
:return: the object dictionary
:rtype: dict
| 3.865102
| 3.864309
| 1.000205
|
conf = {}
for k in d["config"]:
v = d["config"][k]
if isinstance(v, dict):
if u"type" in v:
typestr = v[u"type"]
else:
typestr = v["type"]
conf[str(k)] = classes.get_dict_handler(typestr)(v)
else:
conf[str(k)] = v
return classes.get_class(d["class"])(name=d["name"], config=conf)
|
def from_dict(cls, d)
|
Restores an object state from a dictionary, used in de-JSONification.
:param d: the object dictionary
:type d: dict
:return: the object
:rtype: object
| 3.305866
| 3.406315
| 0.970511
|
value = self.config[name]
if value is None:
return default
elif isinstance(value, str) \
and value.startswith("@{") \
and value.endswith("}") \
and (value.find("@{", 1) == -1):
stname = value[2:len(value)-1]
if (self.storagehandler is not None) and (stname in self.storagehandler.storage):
return self.storagehandler.storage[stname]
else:
return default
else:
return value
|
def resolve_option(self, name, default=None)
|
Resolves the option, i.e., interprets "@{...}" values and retrievs them instead from internal
storage.
:param name: the name of the option
:type name: str
:param default: the optional default value
:type default: object
:return: the resolved value
:rtype: object
| 3.059749
| 2.846262
| 1.075006
|
if isinstance(self, StorageHandler):
return self
elif self.parent is not None:
return self.parent.storagehandler
else:
return None
|
def storagehandler(self)
|
Returns the storage handler available to thise actor.
:return: the storage handler, None if not available
| 3.073113
| 3.575494
| 0.859493
|
if self.skip:
return None
result = self.pre_execute()
if result is None:
try:
result = self.do_execute()
except Exception as e:
result = traceback.format_exc()
print(self.full_name + "\n" + result)
if result is None:
result = self.post_execute()
return result
|
def execute(self)
|
Executes the actor.
:return: None if successful, otherwise error message
:rtype: str
| 3.442988
| 3.351134
| 1.02741
|
if (self._output is None) or (len(self._output) == 0):
result = None
else:
result = self._output.pop(0)
return result
|
def output(self)
|
Returns the next available output token.
:return: the next token, None if none available
:rtype: Token
| 3.306227
| 3.052227
| 1.083218
|
result = s
while result.find("@{") > -1:
start = result.index("@{")
end = result.index("}", start)
name = result[start + 2:end]
value = self.storage[name]
if value is None:
raise("Storage value '" + name + "' not present, failed to expand string: " + s)
else:
result = result[0:start] + str(value) + result[end + 1:]
return result
|
def expand(self, s)
|
Expands all occurrences of "@{...}" within the string with the actual values currently stored
in internal storage.
:param s: the string to expand
:type s: str
:return: the expanded string
:rtype: str
| 3.00763
| 2.506941
| 1.199721
|
if padded.startswith("@{") and padded.endswith("}"):
return padded[2:len(padded)-1]
else:
return padded
|
def extract(cls, padded)
|
Removes the surrounding "@{...}" from the name.
:param padded: the padded string
:type padded: str
:return: the extracted name
:rtype: str
| 4.688678
| 2.843696
| 1.648797
|
options = super(ActorHandler, self).fix_config(options)
opt = "actors"
if opt not in options:
options[opt] = self.default_actors()
if opt not in self.help:
self.help[opt] = "The list of sub-actors that this actor manages."
return options
|
def fix_config(self, options)
|
Fixes the options, if necessary. I.e., it adds all required elements to the dictionary.
:param options: the options to fix
:type options: dict
:return: the (potentially) fixed options
:rtype: dict
| 4.863182
| 5.458702
| 0.890904
|
result = super(ActorHandler, self).to_dict()
result["type"] = "ActorHandler"
del result["config"]["actors"]
result["actors"] = []
for actor in self.actors:
result["actors"].append(actor.to_dict())
return result
|
def to_dict(self)
|
Returns a dictionary that represents this object, to be used for JSONification.
:return: the object dictionary
:rtype: dict
| 3.420422
| 3.510233
| 0.974414
|
result = super(ActorHandler, cls).from_dict(d)
if "actors" in d:
l = d["actors"]
for e in l:
if u"type" in e:
typestr = e[u"type"]
else:
typestr = e["type"]
result.actors.append(classes.get_dict_handler(typestr)(e))
return result
|
def from_dict(cls, d)
|
Restores an object state from a dictionary, used in de-JSONification.
:param d: the object dictionary
:type d: dict
:return: the object
:rtype: object
| 4.226474
| 4.547175
| 0.929472
|
if actors is None:
actors = self.default_actors()
self.check_actors(actors)
self.config["actors"] = actors
|
def actors(self, actors)
|
Sets the sub-actors of the actor.
:param actors: the sub-actors
:type actors: list
| 3.953598
| 6.754673
| 0.585313
|
result = 0
for actor in self.actors:
if not actor.skip:
result += 1
return result
|
def active(self)
|
Returns the count of non-skipped actors.
:return: the count
:rtype: int
| 5.887525
| 3.317454
| 1.774712
|
result = None
for actor in self.actors:
if not actor.skip:
result = actor
break
return result
|
def first_active(self)
|
Returns the first non-skipped actor.
:return: the first active actor, None if not available
:rtype: Actor
| 5.573334
| 3.892825
| 1.431694
|
result = None
for actor in reversed(self.actors):
if not actor.skip:
result = actor
break
return result
|
def last_active(self)
|
Returns the last non-skipped actor.
:return: the last active actor, None if not available
:rtype: Actor
| 6.230399
| 4.085077
| 1.525161
|
result = -1
for index, actor in enumerate(self.actors):
if actor.name == name:
result = index
break
return result
|
def index_of(self, name)
|
Returns the index of the actor with the given name.
:param name: the name of the Actor to find
:type name: str
:return: the index, -1 if not found
:rtype: int
| 3.072366
| 2.513223
| 1.222481
|
result = super(ActorHandler, self).setup()
if result is None:
self.update_parent()
try:
self.check_actors(self.actors)
except Exception as e:
result = str(e)
if result is None:
for actor in self.actors:
name = actor.name
newname = actor.unique_name(actor.name)
if name != newname:
actor.name = newname
if result is None:
for actor in self.actors:
if actor.skip:
continue
result = actor.setup()
if result is not None:
break
if result is None:
result = self._director.setup()
return result
|
def setup(self)
|
Configures the actor before execution.
:return: None if successful, otherwise error message
:rtype: str
| 3.429972
| 3.094355
| 1.108461
|
for actor in self.actors:
if actor.skip:
continue
actor.wrapup()
super(ActorHandler, self).wrapup()
|
def wrapup(self)
|
Finishes up after execution finishes, does not remove any graphical output.
| 6.024958
| 5.6696
| 1.062678
|
for actor in self.actors:
if actor.skip:
continue
actor.cleanup()
super(ActorHandler, self).cleanup()
|
def cleanup(self)
|
Destructive finishing up after execution stopped.
| 6.326975
| 5.70747
| 1.108543
|
if not (self._stopping or self._stopped):
for actor in self.owner.actors:
actor.stop_execution()
self._stopping = True
|
def stop_execution(self)
|
Triggers the stopping of the object.
| 6.042375
| 5.068565
| 1.192127
|
self._stopped = False
self._stopping = False
not_finished_actor = self.owner.first_active
pending_actors = []
finished = False
actor_result = None
while not (self.is_stopping() or self.is_stopped()) and not finished:
# determing starting point of next iteration
if len(pending_actors) > 0:
start_index = self.owner.index_of(pending_actors[-1].name)
else:
start_index = self.owner.index_of(not_finished_actor.name)
not_finished_actor = None
# iterate over actors
token = None
last_active = -1
if self.owner.active > 0:
last_active = self.owner.last_active.index
for i in range(start_index, last_active + 1):
# do we have to stop the execution?
if self.is_stopped() or self.is_stopping():
break
curr = self.owner.actors[i]
if curr.skip:
continue
# no token? get pending one or produce new one
if token is None:
if isinstance(curr, OutputProducer) and curr.has_output():
pending_actors.pop()
else:
actor_result = curr.execute()
if actor_result is not None:
self.owner.logger.error(
curr.full_name + " generated following error output:\n" + actor_result)
break
if isinstance(curr, OutputProducer) and curr.has_output():
token = curr.output()
else:
token = None
# still more to come?
if isinstance(curr, OutputProducer) and curr.has_output():
pending_actors.append(curr)
else:
# process token
curr.input = token
actor_result = curr.execute()
if actor_result is not None:
self.owner.logger.error(
curr.full_name + " generated following error output:\n" + actor_result)
break
# was a new token produced?
if isinstance(curr, OutputProducer):
if curr.has_output():
token = curr.output()
else:
token = None
# still more to come?
if curr.has_output():
pending_actors.append(curr)
else:
token = None
# token from last actor generated? -> store
if (i == self.owner.last_active.index) and (token is not None):
if self._record_output:
self._recorded_output.append(token)
# no token produced, ignore rest of actors
if isinstance(curr, OutputProducer) and (token is None):
break
# all actors finished?
finished = (not_finished_actor is None) and (len(pending_actors) == 0)
return actor_result
|
def do_execute(self)
|
Actual execution of the director.
:return: None if successful, otherwise error message
:rtype: str
| 3.214465
| 3.159067
| 1.017536
|
super(Flow, self).check_actors(actors)
actor = self.first_active
if (actor is not None) and not base.is_source(actor):
raise Exception("First active actor is not a source: " + actor.full_name)
|
def check_actors(self, actors)
|
Performs checks on the actors that are to be used. Raises an exception if invalid setup.
:param actors: the actors to check
:type actors: list
| 6.817731
| 7.26034
| 0.939037
|
with open(fname) as f:
content = f.readlines()
return Flow.from_json(''.join(content))
|
def load(cls, fname)
|
Loads the flow from a JSON file.
:param fname: the file to load
:type fname: str
:return: the flow
:rtype: Flow
| 6.168649
| 5.677999
| 1.086412
|
result = SequentialDirector(self)
result.record_output = False
result.allow_source = False
return result
|
def new_director(self)
|
Creates the director to use for handling the sub-actors.
:return: the director instance
:rtype: Director
| 16.413773
| 19.180418
| 0.855757
|
super(Sequence, self).check_actors(actors)
actor = self.first_active
if (actor is not None) and not isinstance(actor, InputConsumer):
raise Exception("First active actor does not accept input: " + actor.full_name)
|
def check_actors(self, actors)
|
Performs checks on the actors that are to be used. Raises an exception if invalid setup.
:param actors: the actors to check
:type actors: list
| 6.643405
| 7.699221
| 0.862867
|
self.first_active.input = self.input
result = self._director.execute()
if result is None:
self._output.append(self.input)
return result
|
def do_execute(self)
|
The actual execution of the actor.
:return: None if successful, otherwise error message
:rtype: str
| 10.945373
| 11.010391
| 0.994095
|
options = super(Tee, self).fix_config(options)
opt = "condition"
if opt not in options:
options[opt] = "True"
if opt not in self.help:
self.help[opt] = "The (optional) condition for teeing off the tokens; uses the 'eval' method, "\
"ie the expression must evaluate to a boolean value; storage values placeholders "\
"'@{...}' get replaced with their string representations before evaluating the "\
"expression (string)."
return options
|
def fix_config(self, options)
|
Fixes the options, if necessary. I.e., it adds all required elements to the dictionary.
:param options: the options to fix
:type options: dict
:return: the (potentially) fixed options
:rtype: dict
| 12.049687
| 12.825914
| 0.93948
|
super(Tee, self).check_actors(actors)
actor = self.first_active
if actor is None:
if self._requires_active_actors:
raise Exception("No active actor!")
elif not isinstance(actor, InputConsumer):
raise Exception("First active actor does not accept input: " + actor.full_name)
|
def check_actors(self, actors)
|
Performs checks on the actors that are to be used. Raises an exception if invalid setup.
:param actors: the actors to check
:type actors: list
| 6.764783
| 7.40647
| 0.913361
|
result = None
teeoff = True
cond = self.storagehandler.expand(str(self.resolve_option("condition")))
if len(cond) > 0:
teeoff = bool(eval(cond))
if teeoff:
self.first_active.input = self.input
result = self._director.execute()
if result is None:
self._output.append(self.input)
return result
|
def do_execute(self)
|
The actual execution of the actor.
:return: None if successful, otherwise error message
:rtype: str
| 9.326387
| 9.448761
| 0.987049
|
options = super(Trigger, self).fix_config(options)
opt = "condition"
if opt not in options:
options[opt] = "True"
if opt not in self.help:
self.help[opt] = "The (optional) condition for teeing off the tokens; uses the 'eval' method, "\
"ie the expression must evaluate to a boolean value; storage values placeholders "\
"'@{...}' get replaced with their string representations before evaluating the "\
"expression (string)."
return options
|
def fix_config(self, options)
|
Fixes the options, if necessary. I.e., it adds all required elements to the dictionary.
:param options: the options to fix
:type options: dict
:return: the (potentially) fixed options
:rtype: dict
| 12.137281
| 13.249087
| 0.916084
|
actors = []
for actor in self.owner.actors:
if actor.skip:
continue
actors.append(actor)
if len(actors) == 0:
return
for actor in actors:
if not isinstance(actor, InputConsumer):
raise Exception("Actor does not accept any input: " + actor.full_name)
|
def check_actors(self)
|
Checks the actors of the owner. Raises an exception if invalid.
| 4.586056
| 3.684227
| 1.244781
|
result = None
self._stopped = False
self._stopping = False
for actor in self.owner.actors:
if self.is_stopping() or self.is_stopped():
break
actor.input = self.owner.input
result = actor.execute()
if result is not None:
break
return result
|
def do_execute(self)
|
Actual execution of the director.
:return: None if successful, otherwise error message
:rtype: str
| 5.060192
| 4.753039
| 1.064622
|
options = super(ContainerValuePicker, self).fix_config(options)
opt = "value"
if opt not in options:
options[opt] = "Model"
if opt not in self.help:
self.help[opt] = "The name of the container value to pick from the container (string)."
opt = "switch"
if opt not in options:
options[opt] = False
if opt not in self.help:
self.help[opt] = "Whether to switch the ouputs, i.e., forward the container to the sub-flow and the " \
+ "container value to the following actor instead (bool)."
return options
|
def fix_config(self, options)
|
Fixes the options, if necessary. I.e., it adds all required elements to the dictionary.
:param options: the options to fix
:type options: dict
:return: the (potentially) fixed options
:rtype: dict
| 5.30996
| 5.616788
| 0.945373
|
result = None
cont = self.input.payload
name = str(self.resolve_option("value"))
value = cont.get(name)
switch = bool(self.resolve_option("switch"))
if switch:
if self.first_active is not None:
self.first_active.input = self.input
result = self._director.execute()
if result is None:
self._output.append(Token(value))
else:
if self.first_active is not None:
self.first_active.input = Token(value)
result = self._director.execute()
if result is None:
self._output.append(self.input)
return result
|
def do_execute(self)
|
The actual execution of the actor.
:return: None if successful, otherwise error message
:rtype: str
| 4.40064
| 4.404368
| 0.999153
|
options = super(CommandlineToAny, self).fix_config(options)
opt = "wrapper"
if opt not in options:
options[opt] = "weka.core.classes.OptionHandler"
if opt not in self.help:
self.help[opt] = "The name of the wrapper class to use (string)."
return options
|
def fix_config(self, options)
|
Fixes the options, if necessary. I.e., it adds all required elements to the dictionary.
:param options: the options to fix
:type options: dict
:return: the (potentially) fixed options
:rtype: dict
| 6.682126
| 7.437073
| 0.898489
|
if isinstance(obj, str):
return
if isinstance(obj, unicode):
return
raise Exception("Unsupported class: " + self._input.__class__.__name__)
|
def check_input(self, obj)
|
Performs checks on the input object. Raises an exception if unsupported.
:param obj: the object to check
:type obj: object
| 6.462538
| 6.383549
| 1.012374
|
cname = str(self.config["wrapper"])
self._output = classes.from_commandline(self._input, classname=cname)
return None
|
def convert(self)
|
Performs the actual conversion.
:return: None if successful, otherwise errors message
:rtype: str
| 22.888205
| 24.028816
| 0.952532
|
if not plot.matplotlib_available:
logger.error("Matplotlib is not installed, plotting unavailable!")
return
if not isinstance(mat, ResultMatrix):
logger.error("Need to supply a result matrix!")
return
fig, ax = plt.subplots()
if axes_swapped:
ax.set_xlabel(measure)
ax.set_ylabel("Classifiers")
else:
ax.set_xlabel("Classifiers")
ax.set_ylabel(measure)
ax.set_title(title)
fig.canvas.set_window_title(title)
ax.grid(True)
ticksx = []
ticks = []
inc = 1.0 / float(mat.columns)
for i in range(mat.columns):
ticksx.append((i + 0.5) * inc)
ticks.append("[" + str(i+1) + "]")
plt.xticks(ticksx, ticks)
plt.xlim([0.0, 1.0])
for r in range(mat.rows):
x = []
means = []
stdevs = []
for c in range(mat.columns):
mean = mat.get_mean(c, r)
stdev = mat.get_stdev(c, r)
if not math.isnan(mean):
x.append((c + 0.5) * inc)
means.append(mean)
if not math.isnan(stdev):
stdevs.append(stdev)
plot_label = mat.get_row_name(r)
if show_stdev:
ax.errorbar(x, means, yerr=stdevs, fmt='-o', ls="-", label=plot_label)
else:
ax.plot(x, means, "o-", label=plot_label)
plt.draw()
plt.legend(loc=key_loc, shadow=True)
if outfile is not None:
plt.savefig(outfile)
if wait:
plt.show()
|
def plot_experiment(mat, title="Experiment", axes_swapped=False, measure="Statistic", show_stdev=False,
key_loc="lower right", outfile=None, wait=True)
|
Plots the results from an experiment.
:param mat: the result matrix to plot
:type mat: ResultMatrix
:param title: the title for the experiment
:type title: str
:param axes_swapped: whether the axes whether swapped ("sets x cls" or "cls x sets")
:type axes_swapped: bool
:param measure: the measure that is being displayed
:type measure: str
:param show_stdev: whether to show the standard deviation as error bar
:type show_stdev: bool
:param key_loc: the location string for the key
:type key_loc: str
:param outfile: the output file, ignored if None
:type outfile: str
:param wait: whether to wait for the user to close the plot
:type wait: bool
| 2.154227
| 2.10416
| 1.023794
|
if percent <= 0 or percent >= 100:
return data
data = Instances.copy_instances(data)
data.randomize(Random(seed))
data = Instances.copy_instances(data, 0, int(round(data.num_instances * percent / 100.0)))
return data
|
def create_subsample(data, percent, seed=1)
|
Generates a subsample of the dataset.
:param data: the data to create the subsample from
:type data: Instances
:param percent: the percentage (0-100)
:type percent: float
:param seed: the seed value to use
:type seed: int
| 3.74644
| 3.325949
| 1.126427
|
if len(preds) == 0:
return None
is_numeric = isinstance(preds[0], NumericPrediction)
# create header
atts = []
if is_numeric:
atts.append(Attribute.create_numeric("index"))
atts.append(Attribute.create_numeric("weight"))
atts.append(Attribute.create_numeric("actual"))
atts.append(Attribute.create_numeric("predicted"))
atts.append(Attribute.create_numeric("error"))
else:
atts.append(Attribute.create_numeric("index"))
atts.append(Attribute.create_numeric("weight"))
atts.append(data.class_attribute.copy(name="actual"))
atts.append(data.class_attribute.copy(name="predicted"))
atts.append(Attribute.create_nominal("error", ["no", "yes"]))
atts.append(Attribute.create_numeric("classification"))
for i in range(data.class_attribute.num_values):
atts.append(Attribute.create_numeric("distribution-" + data.class_attribute.value(i)))
result = Instances.create_instances("Predictions", atts, len(preds))
count = 0
for pred in preds:
count += 1
if is_numeric:
values = array([count, pred.weight, pred.actual, pred.predicted, pred.error])
else:
if pred.actual == pred.predicted:
error = 0.0
else:
error = 1.0
l = [count, pred.weight, pred.actual, pred.predicted, error, max(pred.distribution)]
for i in range(data.class_attribute.num_values):
l.append(pred.distribution[i])
values = array(l)
inst = Instance.create_instance(values)
result.add_instance(inst)
return result
|
def predictions_to_instances(data, preds)
|
Turns the predictions turned into an Instances object.
:param data: the original dataset format
:type data: Instances
:param preds: the predictions to convert
:type preds: list
:return: the predictions, None if no predictions present
:rtype: Instances
| 2.2226
| 2.286524
| 0.972043
|
if self.is_batchpredictor:
return typeconv.double_matrix_to_ndarray(self.__distributions(data.jobject))
else:
return None
|
def distributions_for_instances(self, data)
|
Peforms predictions, returning the class distributions.
:param data: the Instances to get the class distributions for
:type data: Instances
:return: the class distribution matrix, None if not a batch predictor
:rtype: ndarray
| 22.877647
| 14.09586
| 1.623005
|
if self.is_batchpredictor:
javabridge.call(self.jobject, "setBatchSize", "(Ljava/lang/String;)V", size)
|
def batch_size(self, size)
|
Sets the batch size, in case this classifier is a batch predictor.
:param size: the size of the batch
:type size: str
| 6.719282
| 4.295274
| 1.564343
|
if not self.check_type(self.jobject, "weka.classifiers.Sourcable"):
return None
return javabridge.call(self.jobject, "toSource", "(Ljava/lang/String;)Ljava/lang/String;", classname)
|
def to_source(self, classname)
|
Returns the model as Java source code if the classifier implements weka.classifiers.Sourcable.
:param classname: the classname for the generated Java code
:type classname: str
:return: the model as source code string
:rtype: str
| 4.361536
| 3.517056
| 1.24011
|
if isinstance(evl, str):
evl = self.tags_evaluation.find(evl)
if isinstance(evl, Tag):
evl = SelectedTag(tag_id=evl.ident, tags=self.tags_evaluation)
javabridge.call(self.jobject, "setEvaluation", "(Lweka/core/SelectedTag;)V", evl.jobject)
|
def evaluation(self, evl)
|
Sets the statistic to use for evaluation.
:param evl: the statistic
:type evl: SelectedTag, Tag or str
| 4.560258
| 3.632719
| 1.255329
|
result = {}
result["property"] = javabridge.call(self.jobject, "getXProperty", "()Ljava/lang/String;")
result["min"] = javabridge.call(self.jobject, "getXMin", "()D")
result["max"] = javabridge.call(self.jobject, "getXMax", "()D")
result["step"] = javabridge.call(self.jobject, "getXStep", "()D")
result["base"] = javabridge.call(self.jobject, "getXBase", "()D")
result["expression"] = javabridge.call(self.jobject, "getXExpression", "()Ljava/lang/String;")
return result
|
def x(self)
|
Returns a dictionary with all the current values for the X of the grid.
Keys for the dictionary: property, min, max, step, base, expression
Types: property=str, min=float, max=float, step=float, base=float, expression=str
:return: the dictionary with the parameters
:rtype: dict
| 1.849737
| 1.481595
| 1.248477
|
if "property" in d:
javabridge.call(self.jobject, "setXProperty", "(Ljava/lang/String;)V", d["property"])
if "min" in d:
javabridge.call(self.jobject, "setXMin", "(D)V", d["min"])
if "max" in d:
javabridge.call(self.jobject, "setXMax", "(D)V", d["max"])
if "step" in d:
javabridge.call(self.jobject, "setXStep", "(D)V", d["step"])
if "base" in d:
javabridge.call(self.jobject, "setXBase", "(D)V", d["base"])
if "expression" in d:
javabridge.call(self.jobject, "setXExpression", "(Ljava/lang/String;)V", d["expression"])
|
def x(self, d)
|
Allows to configure the X of the grid with one method call.
Keys for the dictionary: property, min, max, step, base, expression
Types: property=str, min=float, max=float, step=float, base=float, expression=str
:param d: the dictionary with the parameters
:type d: dict
| 1.56284
| 1.337292
| 1.16866
|
result = {}
result["property"] = javabridge.call(self.jobject, "getYProperty", "()Ljava/lang/String;")
result["min"] = javabridge.call(self.jobject, "getYMin", "()D")
result["max"] = javabridge.call(self.jobject, "getYMax", "()D")
result["step"] = javabridge.call(self.jobject, "getYStep", "()D")
result["base"] = javabridge.call(self.jobject, "getYBase", "()D")
result["expression"] = javabridge.call(self.jobject, "getYExpression", "()Ljava/lang/String;")
return result
|
def y(self)
|
Returns a dictionary with all the current values for the Y of the grid.
Keys for the dictionary: property, min, max, step, base, expression
Types: property=str, min=float, max=float, step=float, base=float, expression=str
:return: the dictionary with the parameters
:rtype: dict
| 1.849688
| 1.475399
| 1.253686
|
if "property" in d:
javabridge.call(self.jobject, "setYProperty", "(Ljava/lang/String;)V", d["property"])
if "min" in d:
javabridge.call(self.jobject, "setYMin", "(D)V", d["min"])
if "max" in d:
javabridge.call(self.jobject, "setYMax", "(D)V", d["max"])
if "step" in d:
javabridge.call(self.jobject, "setYStep", "(D)V", d["step"])
if "base" in d:
javabridge.call(self.jobject, "setYBase", "(D)V", d["base"])
if "expression" in d:
javabridge.call(self.jobject, "setYExpression", "(Ljava/lang/String;)V", d["expression"])
|
def y(self, d)
|
Allows to configure the Y of the grid with one method call.
Keys for the dictionary: property, min, max, step, base, expression
Types: property=str, min=float, max=float, step=float, base=float, expression=str
:param d: the dictionary with the parameters
:type d: dict
| 1.553662
| 1.315687
| 1.180875
|
objects = javabridge.get_env().get_object_array_elements(
javabridge.call(self.jobject, "getClassifiers", "()[Lweka/classifiers/Classifier;"))
result = []
for obj in objects:
result.append(Classifier(jobject=obj))
return result
|
def classifiers(self)
|
Returns the list of base classifiers.
:return: the classifier list
:rtype: list
| 3.080954
| 3.158396
| 0.97548
|
obj = []
for classifier in classifiers:
obj.append(classifier.jobject)
javabridge.call(self.jobject, "setClassifiers", "([Lweka/classifiers/Classifier;)V", obj)
|
def classifiers(self, classifiers)
|
Sets the base classifiers.
:param classifiers: the list of base classifiers to use
:type classifiers: list
| 3.670161
| 4.211043
| 0.871556
|
jinst1 = None
if inst1 is not None:
jinst1 = inst1.jobject
return javabridge.call(self.jobject, "eval", "(IILweka/core/Instance;)D", id1, id2, jinst1)
|
def eval(self, id1, id2, inst1)
|
Computes the result of the kernel function for two instances. If id1 == -1, eval use inst1 instead of an
instance in the dataset.
:param id1: the index of the first instance in the dataset
:type id1: int
:param id2: the index of the second instance in the dataset
:type id2: int
:param inst1: the instance corresponding to id1 (used if id1 == -1)
:type inst1: Instance
| 4.688893
| 4.291958
| 1.092483
|
result = javabridge.static_call(
"weka/classifiers/KernelHelper", "getKernel",
"(Ljava/lang/Object;)Lweka/classifiers/functions/supportVector/Kernel;",
self.jobject)
if result is None:
return None
else:
return Kernel(jobject=result)
|
def kernel(self)
|
Returns the current kernel.
:return: the kernel or None if none found
:rtype: Kernel
| 3.737587
| 3.448769
| 1.083745
|
result = javabridge.static_call(
"weka/classifiers/KernelHelper", "setKernel",
"(Ljava/lang/Object;Lweka/classifiers/functions/supportVector/Kernel;)Z",
self.jobject, kernel.jobject)
if not result:
raise Exception("Failed to set kernel!")
|
def kernel(self, kernel)
|
Sets the kernel.
:param kernel: the kernel to set
:type kernel: Kernel
| 3.729146
| 3.807507
| 0.97942
|
return Instances(
javabridge.call(
self.jobject, "applyCostMatrix", "(Lweka/core/Instances;Ljava/util/Random;)Lweka/core/Instances;",
data.jobject, rnd.jobject))
|
def apply_cost_matrix(self, data, rnd)
|
Applies the cost matrix to the data.
:param data: the data to apply to
:type data: Instances
:param rnd: the random number generator
:type rnd: Random
| 4.105083
| 4.021314
| 1.020831
|
if inst is None:
costs = javabridge.call(
self.jobject, "expectedCosts", "([D)[D", javabridge.get_env().make_double_array(class_probs))
return javabridge.get_env().get_double_array_elements(costs)
else:
costs = javabridge.call(
self.jobject, "expectedCosts", "([DLweka/core/Instance;)[D",
javabridge.get_env().make_double_array(class_probs), inst.jobject)
return javabridge.get_env().get_double_array_elements(costs)
|
def expected_costs(self, class_probs, inst=None)
|
Calculates the expected misclassification cost for each possible class value, given class probability
estimates.
:param class_probs: the class probabilities
:type class_probs: ndarray
:return: the calculated costs
:rtype: ndarray
| 2.50518
| 2.483672
| 1.00866
|
return javabridge.call(
self.jobject, "getCell", "(II)Ljava/lang/Object;", row, col)
|
def get_cell(self, row, col)
|
Returns the JB_Object at the specified location.
:param row: the 0-based index of the row
:type row: int
:param col: the 0-based index of the column
:type col: int
:return: the object in that cell
:rtype: JB_Object
| 6.854106
| 7.215421
| 0.949925
|
if isinstance(obj, JavaObject):
obj = obj.jobject
javabridge.call(
self.jobject, "setCell", "(IILjava/lang/Object;)V", row, col, obj)
|
def set_cell(self, row, col, obj)
|
Sets the JB_Object at the specified location. Automatically unwraps JavaObject.
:param row: the 0-based index of the row
:type row: int
:param col: the 0-based index of the column
:type col: int
:param obj: the object for that cell
:type obj: object
| 4.242689
| 4.065327
| 1.043628
|
if inst is None:
return javabridge.call(
self.jobject, "getElement", "(II)D", row, col)
else:
return javabridge.call(
self.jobject, "getElement", "(IILweka/core/Instance;)D", row, col, inst.jobject)
|
def get_element(self, row, col, inst=None)
|
Returns the value at the specified location.
:param row: the 0-based index of the row
:type row: int
:param col: the 0-based index of the column
:type col: int
:param inst: the Instace
:type inst: Instance
:return: the value in that cell
:rtype: float
| 3.133723
| 2.867018
| 1.093025
|
javabridge.call(
self.jobject, "setElement", "(IID)V", row, col, value)
|
def set_element(self, row, col, value)
|
Sets the float value at the specified location.
:param row: the 0-based index of the row
:type row: int
:param col: the 0-based index of the column
:type col: int
:param value: the float value for that cell
:type value: float
| 8.56471
| 8.109188
| 1.056174
|
if inst is None:
return javabridge.call(
self.jobject, "getMaxCost", "(I)D", class_value)
else:
return javabridge.call(
self.jobject, "getElement", "(ILweka/core/Instance;)D", class_value, inst.jobject)
|
def get_max_cost(self, class_value, inst=None)
|
Gets the maximum cost for a particular class value.
:param class_value: the class value to get the maximum cost for
:type class_value: int
:param inst: the Instance
:type inst: Instance
:return: the cost
:rtype: float
| 3.550163
| 3.226193
| 1.100419
|
if output is None:
generator = []
else:
generator = [output.jobject]
javabridge.call(
self.jobject, "crossValidateModel",
"(Lweka/classifiers/Classifier;Lweka/core/Instances;ILjava/util/Random;[Ljava/lang/Object;)V",
classifier.jobject, data.jobject, num_folds, rnd.jobject, generator)
|
def crossvalidate_model(self, classifier, data, num_folds, rnd, output=None)
|
Crossvalidates the model using the specified data, number of folds and random number generator wrapper.
:param classifier: the classifier to cross-validate
:type classifier: Classifier
:param data: the data to evaluate on
:type data: Instances
:param num_folds: the number of folds
:type num_folds: int
:param rnd: the random number generator to use
:type rnd: Random
:param output: the output generator to use
:type output: PredictionOutput
| 2.843779
| 2.779538
| 1.023112
|
if title is None:
return javabridge.call(
self.jobject, "toSummaryString", "()Ljava/lang/String;")
else:
return javabridge.call(
self.jobject, "toSummaryString", "(Ljava/lang/String;Z)Ljava/lang/String;", title, complexity)
|
def summary(self, title=None, complexity=False)
|
Generates a summary.
:param title: optional title
:type title: str
:param complexity: whether to print the complexity information as well
:type complexity: bool
:return: the summary
:rtype: str
| 2.538503
| 2.559868
| 0.991654
|
if title is None:
return javabridge.call(
self.jobject, "toClassDetailsString", "()Ljava/lang/String;")
else:
return javabridge.call(
self.jobject, "toClassDetailsString", "(Ljava/lang/String;)Ljava/lang/String;", title)
|
def class_details(self, title=None)
|
Generates the class details.
:param title: optional title
:type title: str
:return: the details
:rtype: str
| 2.634666
| 2.622409
| 1.004674
|
if title is None:
return javabridge.call(self.jobject, "toMatrixString", "()Ljava/lang/String;")
else:
return javabridge.call(self.jobject, "toMatrixString", "(Ljava/lang/String;)Ljava/lang/String;", title)
|
def matrix(self, title=None)
|
Generates the confusion matrix.
:param title: optional title
:type title: str
:return: the matrix
:rtype: str
| 2.349232
| 2.192837
| 1.071321
|
preds = javabridge.get_collection_wrapper(
javabridge.call(self.jobject, "predictions", "()Ljava/util/ArrayList;"))
if self.discard_predictions:
result = None
else:
result = []
for pred in preds:
if is_instance_of(pred, "weka.classifiers.evaluation.NominalPrediction"):
result.append(NominalPrediction(pred))
elif is_instance_of(pred, "weka.classifiers.evaluation.NumericPrediction"):
result.append(NumericPrediction(pred))
else:
result.append(Prediction(pred))
return result
|
def predictions(self)
|
Returns the predictions.
:return: the predictions. None if not available
:rtype: list
| 2.76897
| 2.752521
| 1.005976
|
javabridge.call(
self.jobject, "print", "(Lweka/classifiers/Classifier;Lweka/core/Instances;)V",
cls.jobject, data.jobject)
|
def print_all(self, cls, data)
|
Prints the header, classifications and footer to the buffer.
:param cls: the classifier
:type cls: Classifier
:param data: the test data
:type data: Instances
| 4.667285
| 3.610682
| 1.292633
|
javabridge.call(
self.jobject, "printClassifications", "(Lweka/classifiers/Classifier;Lweka/core/Instances;)V",
cls.jobject, data.jobject)
|
def print_classifications(self, cls, data)
|
Prints the classifications to the buffer.
:param cls: the classifier
:type cls: Classifier
:param data: the test data
:type data: Instances
| 3.788831
| 3.078274
| 1.23083
|
javabridge.call(
self.jobject, "printClassification", "(Lweka/classifiers/Classifier;Lweka/core/Instance;I)V",
cls.jobject, inst.jobject, index)
|
def print_classification(self, cls, inst, index)
|
Prints the classification to the buffer.
:param cls: the classifier
:type cls: Classifier
:param inst: the test instance
:type inst: Instance
:param index: the 0-based index of the test instance
:type index: int
| 3.153171
| 2.810025
| 1.122115
|
javabridge.call(self.jobject, "tokenize", "(Ljava/lang/String;)V", s)
return TokenIterator(self)
|
def tokenize(self, s)
|
Tokenizes the string.
:param s: the string to tokenize
:type s: str
:return: the iterator
:rtype: TokenIterator
| 5.553123
| 5.123833
| 1.083783
|
parser = argparse.ArgumentParser(
description='Executes a data generator from the command-line. Calls JVM start/stop automatically.')
parser.add_argument("-j", metavar="classpath", dest="classpath", help="additional classpath, jars/directories")
parser.add_argument("-X", metavar="heap", dest="heap", help="max heap size for jvm, e.g., 512m")
parser.add_argument("datagenerator", help="data generator classname, e.g., "
+ "weka.datagenerators.classifiers.classification.LED24")
parser.add_argument("option", nargs=argparse.REMAINDER, help="additional data generator options")
parsed = parser.parse_args()
jars = []
if parsed.classpath is not None:
jars = parsed.classpath.split(os.pathsep)
jvm.start(jars, max_heap_size=parsed.heap, packages=True)
logger.debug("Commandline: " + join_options(sys.argv[1:]))
try:
generator = DataGenerator(classname=parsed.datagenerator)
if len(parsed.option) > 0:
generator.options = parsed.option
DataGenerator.make_data(generator, parsed.option)
except Exception as e:
print(e)
finally:
jvm.stop()
|
def main()
|
Runs a datagenerator from the command-line. Calls JVM start/stop automatically.
Use -h to see all options.
| 3.856717
| 3.25036
| 1.186551
|
data = javabridge.call(self.jobject, "defineDataFormat", "()Lweka/core/Instances;")
if data is None:
return None
else:
return Instances(data)
|
def define_data_format(self)
|
Returns the data format.
:return: the data format
:rtype: Instances
| 4.287526
| 4.594821
| 0.933121
|
data = javabridge.call(self.jobject, "getDatasetFormat", "()Lweka/core/Instances;")
if data is None:
return None
else:
return Instances(data)
|
def dataset_format(self)
|
Returns the dataset format.
:return: the format
:rtype: Instances
| 4.017037
| 3.814374
| 1.053131
|
data = javabridge.call(self.jobject, "generateExample", "()Lweka/core/Instance;")
if data is None:
return None
else:
return Instance(data)
|
def generate_example(self)
|
Returns a single Instance.
:return: the next example
:rtype: Instance
| 4.123404
| 3.782936
| 1.090001
|
data = javabridge.call(self.jobject, "generateExamples", "()Lweka/core/Instances;")
if data is None:
return None
else:
return Instances(data)
|
def generate_examples(self)
|
Returns complete dataset.
:return: the generated dataset
:rtype: Instances
| 4.425352
| 4.225058
| 1.047406
|
return from_commandline(
to_commandline(generator), classname=classes.get_classname(DataGenerator()))
|
def make_copy(cls, generator)
|
Creates a copy of the generator.
:param generator: the generator to copy
:type generator: DataGenerator
:return: the copy of the generator
:rtype: DataGenerator
| 35.117493
| 34.649239
| 1.013514
|
options = super(FileSupplier, self).fix_config(options)
opt = "files"
if opt not in options:
options[opt] = []
if opt not in self.help:
self.help[opt] = "The files to output (list of string)."
return options
|
def fix_config(self, options)
|
Fixes the options, if necessary. I.e., it adds all required elements to the dictionary.
:param options: the options to fix
:type options: dict
:return: the (potentially) fixed options
:rtype: dict
| 5.024352
| 5.742596
| 0.874927
|
for f in self.resolve_option("files"):
self._output.append(Token(f))
return None
|
def do_execute(self)
|
The actual execution of the actor.
:return: None if successful, otherwise error message
:rtype: str
| 24.938322
| 27.995625
| 0.890794
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.