id int32 0 252k | repo stringlengths 7 55 | path stringlengths 4 127 | func_name stringlengths 1 88 | original_string stringlengths 75 19.8k | language stringclasses 1 value | code stringlengths 75 19.8k | code_tokens list | docstring stringlengths 3 17.3k | docstring_tokens list | sha stringlengths 40 40 | url stringlengths 87 242 |
|---|---|---|---|---|---|---|---|---|---|---|---|
225,500 | danielfrg/word2vec | word2vec/wordvectors.py | WordVectors.from_text | def from_text(cls, fname, vocabUnicodeSize=78, desired_vocab=None, encoding="utf-8"):
"""
Create a WordVectors class based on a word2vec text file
Parameters
----------
fname : path to file
vocabUnicodeSize: the maximum string length (78, by default)
desired_vocab: if set, this will ignore any word and vector that
doesn't fall inside desired_vocab.
Returns
-------
WordVectors instance
"""
with open(fname, "rb") as fin:
header = fin.readline()
vocab_size, vector_size = list(map(int, header.split()))
vocab = np.empty(vocab_size, dtype="<U%s" % vocabUnicodeSize)
vectors = np.empty((vocab_size, vector_size), dtype=np.float)
for i, line in enumerate(fin):
line = line.decode(encoding).rstrip()
parts = line.split(" ")
word = parts[0]
include = desired_vocab is None or word in desired_vocab
if include:
vector = np.array(parts[1:], dtype=np.float)
vocab[i] = word
vectors[i] = unitvec(vector)
if desired_vocab is not None:
vectors = vectors[vocab != "", :]
vocab = vocab[vocab != ""]
return cls(vocab=vocab, vectors=vectors) | python | def from_text(cls, fname, vocabUnicodeSize=78, desired_vocab=None, encoding="utf-8"):
"""
Create a WordVectors class based on a word2vec text file
Parameters
----------
fname : path to file
vocabUnicodeSize: the maximum string length (78, by default)
desired_vocab: if set, this will ignore any word and vector that
doesn't fall inside desired_vocab.
Returns
-------
WordVectors instance
"""
with open(fname, "rb") as fin:
header = fin.readline()
vocab_size, vector_size = list(map(int, header.split()))
vocab = np.empty(vocab_size, dtype="<U%s" % vocabUnicodeSize)
vectors = np.empty((vocab_size, vector_size), dtype=np.float)
for i, line in enumerate(fin):
line = line.decode(encoding).rstrip()
parts = line.split(" ")
word = parts[0]
include = desired_vocab is None or word in desired_vocab
if include:
vector = np.array(parts[1:], dtype=np.float)
vocab[i] = word
vectors[i] = unitvec(vector)
if desired_vocab is not None:
vectors = vectors[vocab != "", :]
vocab = vocab[vocab != ""]
return cls(vocab=vocab, vectors=vectors) | [
"def",
"from_text",
"(",
"cls",
",",
"fname",
",",
"vocabUnicodeSize",
"=",
"78",
",",
"desired_vocab",
"=",
"None",
",",
"encoding",
"=",
"\"utf-8\"",
")",
":",
"with",
"open",
"(",
"fname",
",",
"\"rb\"",
")",
"as",
"fin",
":",
"header",
"=",
"fin",
... | Create a WordVectors class based on a word2vec text file
Parameters
----------
fname : path to file
vocabUnicodeSize: the maximum string length (78, by default)
desired_vocab: if set, this will ignore any word and vector that
doesn't fall inside desired_vocab.
Returns
-------
WordVectors instance | [
"Create",
"a",
"WordVectors",
"class",
"based",
"on",
"a",
"word2vec",
"text",
"file"
] | 762200acec2941a030abed69e946838af35eb2ae | https://github.com/danielfrg/word2vec/blob/762200acec2941a030abed69e946838af35eb2ae/word2vec/wordvectors.py#L233-L267 |
225,501 | danielfrg/word2vec | word2vec/wordvectors.py | WordVectors.from_mmap | def from_mmap(cls, fname):
"""
Create a WordVectors class from a memory map
Parameters
----------
fname : path to file
Returns
-------
WordVectors instance
"""
memmaped = joblib.load(fname, mmap_mode="r+")
return cls(vocab=memmaped.vocab, vectors=memmaped.vectors) | python | def from_mmap(cls, fname):
"""
Create a WordVectors class from a memory map
Parameters
----------
fname : path to file
Returns
-------
WordVectors instance
"""
memmaped = joblib.load(fname, mmap_mode="r+")
return cls(vocab=memmaped.vocab, vectors=memmaped.vectors) | [
"def",
"from_mmap",
"(",
"cls",
",",
"fname",
")",
":",
"memmaped",
"=",
"joblib",
".",
"load",
"(",
"fname",
",",
"mmap_mode",
"=",
"\"r+\"",
")",
"return",
"cls",
"(",
"vocab",
"=",
"memmaped",
".",
"vocab",
",",
"vectors",
"=",
"memmaped",
".",
"v... | Create a WordVectors class from a memory map
Parameters
----------
fname : path to file
Returns
-------
WordVectors instance | [
"Create",
"a",
"WordVectors",
"class",
"from",
"a",
"memory",
"map"
] | 762200acec2941a030abed69e946838af35eb2ae | https://github.com/danielfrg/word2vec/blob/762200acec2941a030abed69e946838af35eb2ae/word2vec/wordvectors.py#L270-L283 |
225,502 | danielfrg/word2vec | word2vec/utils.py | distance | def distance(a, b, metric="cosine"):
"""
Calculate distance between two vectors based on a Metric
Metrics:
1. cosine distance. Note that in word2vec all the norms are 1 so the dot product is the same as cosine distance
"""
if metric == "cosine":
return np.dot(a, b.T)
raise Exception("Unknown metric '{metric}'".format(metric=metric)) | python | def distance(a, b, metric="cosine"):
"""
Calculate distance between two vectors based on a Metric
Metrics:
1. cosine distance. Note that in word2vec all the norms are 1 so the dot product is the same as cosine distance
"""
if metric == "cosine":
return np.dot(a, b.T)
raise Exception("Unknown metric '{metric}'".format(metric=metric)) | [
"def",
"distance",
"(",
"a",
",",
"b",
",",
"metric",
"=",
"\"cosine\"",
")",
":",
"if",
"metric",
"==",
"\"cosine\"",
":",
"return",
"np",
".",
"dot",
"(",
"a",
",",
"b",
".",
"T",
")",
"raise",
"Exception",
"(",
"\"Unknown metric '{metric}'\"",
".",
... | Calculate distance between two vectors based on a Metric
Metrics:
1. cosine distance. Note that in word2vec all the norms are 1 so the dot product is the same as cosine distance | [
"Calculate",
"distance",
"between",
"two",
"vectors",
"based",
"on",
"a",
"Metric"
] | 762200acec2941a030abed69e946838af35eb2ae | https://github.com/danielfrg/word2vec/blob/762200acec2941a030abed69e946838af35eb2ae/word2vec/utils.py#L8-L17 |
225,503 | danielfrg/word2vec | word2vec/io.py | load | def load(fname, kind="auto", *args, **kwargs):
"""
Loads a word vectors file
"""
if kind == "auto":
if fname.endswith(".bin"):
kind = "bin"
elif fname.endswith(".txt"):
kind = "txt"
else:
raise Exception("Could not identify kind")
if kind == "bin":
return word2vec.WordVectors.from_binary(fname, *args, **kwargs)
elif kind == "txt":
return word2vec.WordVectors.from_text(fname, *args, **kwargs)
elif kind == "mmap":
return word2vec.WordVectors.from_mmap(fname, *args, **kwargs)
else:
raise Exception("Unknown kind") | python | def load(fname, kind="auto", *args, **kwargs):
"""
Loads a word vectors file
"""
if kind == "auto":
if fname.endswith(".bin"):
kind = "bin"
elif fname.endswith(".txt"):
kind = "txt"
else:
raise Exception("Could not identify kind")
if kind == "bin":
return word2vec.WordVectors.from_binary(fname, *args, **kwargs)
elif kind == "txt":
return word2vec.WordVectors.from_text(fname, *args, **kwargs)
elif kind == "mmap":
return word2vec.WordVectors.from_mmap(fname, *args, **kwargs)
else:
raise Exception("Unknown kind") | [
"def",
"load",
"(",
"fname",
",",
"kind",
"=",
"\"auto\"",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
":",
"if",
"kind",
"==",
"\"auto\"",
":",
"if",
"fname",
".",
"endswith",
"(",
"\".bin\"",
")",
":",
"kind",
"=",
"\"bin\"",
"elif",
"fname",... | Loads a word vectors file | [
"Loads",
"a",
"word",
"vectors",
"file"
] | 762200acec2941a030abed69e946838af35eb2ae | https://github.com/danielfrg/word2vec/blob/762200acec2941a030abed69e946838af35eb2ae/word2vec/io.py#L4-L22 |
225,504 | django-crispy-forms/django-crispy-forms | crispy_forms/templatetags/crispy_forms_tags.py | ForLoopSimulator.iterate | def iterate(self):
"""
Updates values as if we had iterated over the for
"""
self.counter += 1
self.counter0 += 1
self.revcounter -= 1
self.revcounter0 -= 1
self.first = False
self.last = (self.revcounter0 == self.len_values - 1) | python | def iterate(self):
"""
Updates values as if we had iterated over the for
"""
self.counter += 1
self.counter0 += 1
self.revcounter -= 1
self.revcounter0 -= 1
self.first = False
self.last = (self.revcounter0 == self.len_values - 1) | [
"def",
"iterate",
"(",
"self",
")",
":",
"self",
".",
"counter",
"+=",
"1",
"self",
".",
"counter0",
"+=",
"1",
"self",
".",
"revcounter",
"-=",
"1",
"self",
".",
"revcounter0",
"-=",
"1",
"self",
".",
"first",
"=",
"False",
"self",
".",
"last",
"=... | Updates values as if we had iterated over the for | [
"Updates",
"values",
"as",
"if",
"we",
"had",
"iterated",
"over",
"the",
"for"
] | cd476927a756133c667c199bb12120f877bf6b7e | https://github.com/django-crispy-forms/django-crispy-forms/blob/cd476927a756133c667c199bb12120f877bf6b7e/crispy_forms/templatetags/crispy_forms_tags.py#L43-L52 |
225,505 | django-crispy-forms/django-crispy-forms | crispy_forms/templatetags/crispy_forms_tags.py | BasicNode.get_render | def get_render(self, context):
"""
Returns a `Context` object with all the necessary stuff for rendering the form
:param context: `django.template.Context` variable holding the context for the node
`self.form` and `self.helper` are resolved into real Python objects resolving them
from the `context`. The `actual_form` can be a form or a formset. If it's a formset
`is_formset` is set to True. If the helper has a layout we use it, for rendering the
form or the formset's forms.
"""
# Nodes are not thread safe in multithreaded environments
# https://docs.djangoproject.com/en/dev/howto/custom-template-tags/#thread-safety-considerations
if self not in context.render_context:
context.render_context[self] = (
template.Variable(self.form),
template.Variable(self.helper) if self.helper else None
)
form, helper = context.render_context[self]
actual_form = form.resolve(context)
if self.helper is not None:
helper = helper.resolve(context)
else:
# If the user names the helper within the form `helper` (standard), we use it
# This allows us to have simplified tag syntax: {% crispy form %}
helper = FormHelper() if not hasattr(actual_form, 'helper') else actual_form.helper
# use template_pack from helper, if defined
try:
if helper.template_pack:
self.template_pack = helper.template_pack
except AttributeError:
pass
self.actual_helper = helper
# We get the response dictionary
is_formset = isinstance(actual_form, BaseFormSet)
response_dict = self.get_response_dict(helper, context, is_formset)
node_context = context.__copy__()
node_context.update(response_dict)
final_context = node_context.__copy__()
# If we have a helper's layout we use it, for the form or the formset's forms
if helper and helper.layout:
if not is_formset:
actual_form.form_html = helper.render_layout(actual_form, node_context, template_pack=self.template_pack)
else:
forloop = ForLoopSimulator(actual_form)
helper.render_hidden_fields = True
for form in actual_form:
node_context.update({'forloop': forloop})
node_context.update({'formset_form': form})
form.form_html = helper.render_layout(form, node_context, template_pack=self.template_pack)
forloop.iterate()
if is_formset:
final_context['formset'] = actual_form
else:
final_context['form'] = actual_form
return final_context | python | def get_render(self, context):
"""
Returns a `Context` object with all the necessary stuff for rendering the form
:param context: `django.template.Context` variable holding the context for the node
`self.form` and `self.helper` are resolved into real Python objects resolving them
from the `context`. The `actual_form` can be a form or a formset. If it's a formset
`is_formset` is set to True. If the helper has a layout we use it, for rendering the
form or the formset's forms.
"""
# Nodes are not thread safe in multithreaded environments
# https://docs.djangoproject.com/en/dev/howto/custom-template-tags/#thread-safety-considerations
if self not in context.render_context:
context.render_context[self] = (
template.Variable(self.form),
template.Variable(self.helper) if self.helper else None
)
form, helper = context.render_context[self]
actual_form = form.resolve(context)
if self.helper is not None:
helper = helper.resolve(context)
else:
# If the user names the helper within the form `helper` (standard), we use it
# This allows us to have simplified tag syntax: {% crispy form %}
helper = FormHelper() if not hasattr(actual_form, 'helper') else actual_form.helper
# use template_pack from helper, if defined
try:
if helper.template_pack:
self.template_pack = helper.template_pack
except AttributeError:
pass
self.actual_helper = helper
# We get the response dictionary
is_formset = isinstance(actual_form, BaseFormSet)
response_dict = self.get_response_dict(helper, context, is_formset)
node_context = context.__copy__()
node_context.update(response_dict)
final_context = node_context.__copy__()
# If we have a helper's layout we use it, for the form or the formset's forms
if helper and helper.layout:
if not is_formset:
actual_form.form_html = helper.render_layout(actual_form, node_context, template_pack=self.template_pack)
else:
forloop = ForLoopSimulator(actual_form)
helper.render_hidden_fields = True
for form in actual_form:
node_context.update({'forloop': forloop})
node_context.update({'formset_form': form})
form.form_html = helper.render_layout(form, node_context, template_pack=self.template_pack)
forloop.iterate()
if is_formset:
final_context['formset'] = actual_form
else:
final_context['form'] = actual_form
return final_context | [
"def",
"get_render",
"(",
"self",
",",
"context",
")",
":",
"# Nodes are not thread safe in multithreaded environments",
"# https://docs.djangoproject.com/en/dev/howto/custom-template-tags/#thread-safety-considerations",
"if",
"self",
"not",
"in",
"context",
".",
"render_context",
... | Returns a `Context` object with all the necessary stuff for rendering the form
:param context: `django.template.Context` variable holding the context for the node
`self.form` and `self.helper` are resolved into real Python objects resolving them
from the `context`. The `actual_form` can be a form or a formset. If it's a formset
`is_formset` is set to True. If the helper has a layout we use it, for rendering the
form or the formset's forms. | [
"Returns",
"a",
"Context",
"object",
"with",
"all",
"the",
"necessary",
"stuff",
"for",
"rendering",
"the",
"form"
] | cd476927a756133c667c199bb12120f877bf6b7e | https://github.com/django-crispy-forms/django-crispy-forms/blob/cd476927a756133c667c199bb12120f877bf6b7e/crispy_forms/templatetags/crispy_forms_tags.py#L71-L133 |
225,506 | django-crispy-forms/django-crispy-forms | crispy_forms/templatetags/crispy_forms_utils.py | specialspaceless | def specialspaceless(parser, token):
"""
Removes whitespace between HTML tags, and introduces a whitespace
after buttons an inputs, necessary for Bootstrap to place them
correctly in the layout.
"""
nodelist = parser.parse(('endspecialspaceless',))
parser.delete_first_token()
return SpecialSpacelessNode(nodelist) | python | def specialspaceless(parser, token):
"""
Removes whitespace between HTML tags, and introduces a whitespace
after buttons an inputs, necessary for Bootstrap to place them
correctly in the layout.
"""
nodelist = parser.parse(('endspecialspaceless',))
parser.delete_first_token()
return SpecialSpacelessNode(nodelist) | [
"def",
"specialspaceless",
"(",
"parser",
",",
"token",
")",
":",
"nodelist",
"=",
"parser",
".",
"parse",
"(",
"(",
"'endspecialspaceless'",
",",
")",
")",
"parser",
".",
"delete_first_token",
"(",
")",
"return",
"SpecialSpacelessNode",
"(",
"nodelist",
")"
] | Removes whitespace between HTML tags, and introduces a whitespace
after buttons an inputs, necessary for Bootstrap to place them
correctly in the layout. | [
"Removes",
"whitespace",
"between",
"HTML",
"tags",
"and",
"introduces",
"a",
"whitespace",
"after",
"buttons",
"an",
"inputs",
"necessary",
"for",
"Bootstrap",
"to",
"place",
"them",
"correctly",
"in",
"the",
"layout",
"."
] | cd476927a756133c667c199bb12120f877bf6b7e | https://github.com/django-crispy-forms/django-crispy-forms/blob/cd476927a756133c667c199bb12120f877bf6b7e/crispy_forms/templatetags/crispy_forms_utils.py#L38-L47 |
225,507 | django-crispy-forms/django-crispy-forms | crispy_forms/bootstrap.py | ContainerHolder.first_container_with_errors | def first_container_with_errors(self, errors):
"""
Returns the first container with errors, otherwise returns None.
"""
for tab in self.fields:
errors_here = any(error in tab for error in errors)
if errors_here:
return tab
return None | python | def first_container_with_errors(self, errors):
"""
Returns the first container with errors, otherwise returns None.
"""
for tab in self.fields:
errors_here = any(error in tab for error in errors)
if errors_here:
return tab
return None | [
"def",
"first_container_with_errors",
"(",
"self",
",",
"errors",
")",
":",
"for",
"tab",
"in",
"self",
".",
"fields",
":",
"errors_here",
"=",
"any",
"(",
"error",
"in",
"tab",
"for",
"error",
"in",
"errors",
")",
"if",
"errors_here",
":",
"return",
"ta... | Returns the first container with errors, otherwise returns None. | [
"Returns",
"the",
"first",
"container",
"with",
"errors",
"otherwise",
"returns",
"None",
"."
] | cd476927a756133c667c199bb12120f877bf6b7e | https://github.com/django-crispy-forms/django-crispy-forms/blob/cd476927a756133c667c199bb12120f877bf6b7e/crispy_forms/bootstrap.py#L230-L238 |
225,508 | django-crispy-forms/django-crispy-forms | crispy_forms/bootstrap.py | ContainerHolder.open_target_group_for_form | def open_target_group_for_form(self, form):
"""
Makes sure that the first group that should be open is open.
This is either the first group with errors or the first group
in the container, unless that first group was originally set to
active=False.
"""
target = self.first_container_with_errors(form.errors.keys())
if target is None:
target = self.fields[0]
if not getattr(target, '_active_originally_included', None):
target.active = True
return target
target.active = True
return target | python | def open_target_group_for_form(self, form):
"""
Makes sure that the first group that should be open is open.
This is either the first group with errors or the first group
in the container, unless that first group was originally set to
active=False.
"""
target = self.first_container_with_errors(form.errors.keys())
if target is None:
target = self.fields[0]
if not getattr(target, '_active_originally_included', None):
target.active = True
return target
target.active = True
return target | [
"def",
"open_target_group_for_form",
"(",
"self",
",",
"form",
")",
":",
"target",
"=",
"self",
".",
"first_container_with_errors",
"(",
"form",
".",
"errors",
".",
"keys",
"(",
")",
")",
"if",
"target",
"is",
"None",
":",
"target",
"=",
"self",
".",
"fi... | Makes sure that the first group that should be open is open.
This is either the first group with errors or the first group
in the container, unless that first group was originally set to
active=False. | [
"Makes",
"sure",
"that",
"the",
"first",
"group",
"that",
"should",
"be",
"open",
"is",
"open",
".",
"This",
"is",
"either",
"the",
"first",
"group",
"with",
"errors",
"or",
"the",
"first",
"group",
"in",
"the",
"container",
"unless",
"that",
"first",
"g... | cd476927a756133c667c199bb12120f877bf6b7e | https://github.com/django-crispy-forms/django-crispy-forms/blob/cd476927a756133c667c199bb12120f877bf6b7e/crispy_forms/bootstrap.py#L240-L255 |
225,509 | django-crispy-forms/django-crispy-forms | crispy_forms/bootstrap.py | Tab.render_link | def render_link(self, template_pack=TEMPLATE_PACK, **kwargs):
"""
Render the link for the tab-pane. It must be called after render so css_class is updated
with active if needed.
"""
link_template = self.link_template % template_pack
return render_to_string(link_template, {'link': self}) | python | def render_link(self, template_pack=TEMPLATE_PACK, **kwargs):
"""
Render the link for the tab-pane. It must be called after render so css_class is updated
with active if needed.
"""
link_template = self.link_template % template_pack
return render_to_string(link_template, {'link': self}) | [
"def",
"render_link",
"(",
"self",
",",
"template_pack",
"=",
"TEMPLATE_PACK",
",",
"*",
"*",
"kwargs",
")",
":",
"link_template",
"=",
"self",
".",
"link_template",
"%",
"template_pack",
"return",
"render_to_string",
"(",
"link_template",
",",
"{",
"'link'",
... | Render the link for the tab-pane. It must be called after render so css_class is updated
with active if needed. | [
"Render",
"the",
"link",
"for",
"the",
"tab",
"-",
"pane",
".",
"It",
"must",
"be",
"called",
"after",
"render",
"so",
"css_class",
"is",
"updated",
"with",
"active",
"if",
"needed",
"."
] | cd476927a756133c667c199bb12120f877bf6b7e | https://github.com/django-crispy-forms/django-crispy-forms/blob/cd476927a756133c667c199bb12120f877bf6b7e/crispy_forms/bootstrap.py#L268-L274 |
225,510 | django-crispy-forms/django-crispy-forms | crispy_forms/layout_slice.py | LayoutSlice.wrapped_object | def wrapped_object(self, LayoutClass, fields, *args, **kwargs):
"""
Returns a layout object of type `LayoutClass` with `args` and `kwargs` that
wraps `fields` inside.
"""
if args:
if isinstance(fields, list):
fields = tuple(fields)
else:
fields = (fields,)
if LayoutClass in self.args_first:
arguments = args + fields
else:
arguments = fields + args
return LayoutClass(*arguments, **kwargs)
else:
if isinstance(fields, list):
return LayoutClass(*fields, **kwargs)
else:
return LayoutClass(fields, **kwargs) | python | def wrapped_object(self, LayoutClass, fields, *args, **kwargs):
"""
Returns a layout object of type `LayoutClass` with `args` and `kwargs` that
wraps `fields` inside.
"""
if args:
if isinstance(fields, list):
fields = tuple(fields)
else:
fields = (fields,)
if LayoutClass in self.args_first:
arguments = args + fields
else:
arguments = fields + args
return LayoutClass(*arguments, **kwargs)
else:
if isinstance(fields, list):
return LayoutClass(*fields, **kwargs)
else:
return LayoutClass(fields, **kwargs) | [
"def",
"wrapped_object",
"(",
"self",
",",
"LayoutClass",
",",
"fields",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
":",
"if",
"args",
":",
"if",
"isinstance",
"(",
"fields",
",",
"list",
")",
":",
"fields",
"=",
"tuple",
"(",
"fields",
")",
"... | Returns a layout object of type `LayoutClass` with `args` and `kwargs` that
wraps `fields` inside. | [
"Returns",
"a",
"layout",
"object",
"of",
"type",
"LayoutClass",
"with",
"args",
"and",
"kwargs",
"that",
"wraps",
"fields",
"inside",
"."
] | cd476927a756133c667c199bb12120f877bf6b7e | https://github.com/django-crispy-forms/django-crispy-forms/blob/cd476927a756133c667c199bb12120f877bf6b7e/crispy_forms/layout_slice.py#L19-L40 |
225,511 | django-crispy-forms/django-crispy-forms | crispy_forms/layout_slice.py | LayoutSlice.pre_map | def pre_map(self, function):
"""
Iterates over layout objects pointed in `self.slice` executing `function` on them.
It passes `function` penultimate layout object and the position where to find last one
"""
if isinstance(self.slice, slice):
for i in range(*self.slice.indices(len(self.layout.fields))):
function(self.layout, i)
elif isinstance(self.slice, list):
# A list of pointers Ex: [[[0, 0], 'div'], [[0, 2, 3], 'field_name']]
for pointer in self.slice:
position = pointer[0]
# If it's pointing first level
if len(position) == 1:
function(self.layout, position[-1])
else:
layout_object = self.layout.fields[position[0]]
for i in position[1:-1]:
layout_object = layout_object.fields[i]
try:
function(layout_object, position[-1])
except IndexError:
# We could avoid this exception, recalculating pointers.
# However this case is most of the time an undesired behavior
raise DynamicError("Trying to wrap a field within an already wrapped field, \
recheck your filter or layout") | python | def pre_map(self, function):
"""
Iterates over layout objects pointed in `self.slice` executing `function` on them.
It passes `function` penultimate layout object and the position where to find last one
"""
if isinstance(self.slice, slice):
for i in range(*self.slice.indices(len(self.layout.fields))):
function(self.layout, i)
elif isinstance(self.slice, list):
# A list of pointers Ex: [[[0, 0], 'div'], [[0, 2, 3], 'field_name']]
for pointer in self.slice:
position = pointer[0]
# If it's pointing first level
if len(position) == 1:
function(self.layout, position[-1])
else:
layout_object = self.layout.fields[position[0]]
for i in position[1:-1]:
layout_object = layout_object.fields[i]
try:
function(layout_object, position[-1])
except IndexError:
# We could avoid this exception, recalculating pointers.
# However this case is most of the time an undesired behavior
raise DynamicError("Trying to wrap a field within an already wrapped field, \
recheck your filter or layout") | [
"def",
"pre_map",
"(",
"self",
",",
"function",
")",
":",
"if",
"isinstance",
"(",
"self",
".",
"slice",
",",
"slice",
")",
":",
"for",
"i",
"in",
"range",
"(",
"*",
"self",
".",
"slice",
".",
"indices",
"(",
"len",
"(",
"self",
".",
"layout",
".... | Iterates over layout objects pointed in `self.slice` executing `function` on them.
It passes `function` penultimate layout object and the position where to find last one | [
"Iterates",
"over",
"layout",
"objects",
"pointed",
"in",
"self",
".",
"slice",
"executing",
"function",
"on",
"them",
".",
"It",
"passes",
"function",
"penultimate",
"layout",
"object",
"and",
"the",
"position",
"where",
"to",
"find",
"last",
"one"
] | cd476927a756133c667c199bb12120f877bf6b7e | https://github.com/django-crispy-forms/django-crispy-forms/blob/cd476927a756133c667c199bb12120f877bf6b7e/crispy_forms/layout_slice.py#L42-L70 |
225,512 | django-crispy-forms/django-crispy-forms | crispy_forms/layout_slice.py | LayoutSlice.wrap | def wrap(self, LayoutClass, *args, **kwargs):
"""
Wraps every layout object pointed in `self.slice` under a `LayoutClass` instance with
`args` and `kwargs` passed.
"""
def wrap_object(layout_object, j):
layout_object.fields[j] = self.wrapped_object(
LayoutClass, layout_object.fields[j], *args, **kwargs
)
self.pre_map(wrap_object) | python | def wrap(self, LayoutClass, *args, **kwargs):
"""
Wraps every layout object pointed in `self.slice` under a `LayoutClass` instance with
`args` and `kwargs` passed.
"""
def wrap_object(layout_object, j):
layout_object.fields[j] = self.wrapped_object(
LayoutClass, layout_object.fields[j], *args, **kwargs
)
self.pre_map(wrap_object) | [
"def",
"wrap",
"(",
"self",
",",
"LayoutClass",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
":",
"def",
"wrap_object",
"(",
"layout_object",
",",
"j",
")",
":",
"layout_object",
".",
"fields",
"[",
"j",
"]",
"=",
"self",
".",
"wrapped_object",
"(... | Wraps every layout object pointed in `self.slice` under a `LayoutClass` instance with
`args` and `kwargs` passed. | [
"Wraps",
"every",
"layout",
"object",
"pointed",
"in",
"self",
".",
"slice",
"under",
"a",
"LayoutClass",
"instance",
"with",
"args",
"and",
"kwargs",
"passed",
"."
] | cd476927a756133c667c199bb12120f877bf6b7e | https://github.com/django-crispy-forms/django-crispy-forms/blob/cd476927a756133c667c199bb12120f877bf6b7e/crispy_forms/layout_slice.py#L72-L82 |
225,513 | django-crispy-forms/django-crispy-forms | crispy_forms/layout_slice.py | LayoutSlice.wrap_once | def wrap_once(self, LayoutClass, *args, **kwargs):
"""
Wraps every layout object pointed in `self.slice` under a `LayoutClass` instance with
`args` and `kwargs` passed, unless layout object's parent is already a subclass of
`LayoutClass`.
"""
def wrap_object_once(layout_object, j):
if not isinstance(layout_object, LayoutClass):
layout_object.fields[j] = self.wrapped_object(
LayoutClass, layout_object.fields[j], *args, **kwargs
)
self.pre_map(wrap_object_once) | python | def wrap_once(self, LayoutClass, *args, **kwargs):
"""
Wraps every layout object pointed in `self.slice` under a `LayoutClass` instance with
`args` and `kwargs` passed, unless layout object's parent is already a subclass of
`LayoutClass`.
"""
def wrap_object_once(layout_object, j):
if not isinstance(layout_object, LayoutClass):
layout_object.fields[j] = self.wrapped_object(
LayoutClass, layout_object.fields[j], *args, **kwargs
)
self.pre_map(wrap_object_once) | [
"def",
"wrap_once",
"(",
"self",
",",
"LayoutClass",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
":",
"def",
"wrap_object_once",
"(",
"layout_object",
",",
"j",
")",
":",
"if",
"not",
"isinstance",
"(",
"layout_object",
",",
"LayoutClass",
")",
":",
... | Wraps every layout object pointed in `self.slice` under a `LayoutClass` instance with
`args` and `kwargs` passed, unless layout object's parent is already a subclass of
`LayoutClass`. | [
"Wraps",
"every",
"layout",
"object",
"pointed",
"in",
"self",
".",
"slice",
"under",
"a",
"LayoutClass",
"instance",
"with",
"args",
"and",
"kwargs",
"passed",
"unless",
"layout",
"object",
"s",
"parent",
"is",
"already",
"a",
"subclass",
"of",
"LayoutClass",... | cd476927a756133c667c199bb12120f877bf6b7e | https://github.com/django-crispy-forms/django-crispy-forms/blob/cd476927a756133c667c199bb12120f877bf6b7e/crispy_forms/layout_slice.py#L84-L96 |
225,514 | django-crispy-forms/django-crispy-forms | crispy_forms/layout_slice.py | LayoutSlice.wrap_together | def wrap_together(self, LayoutClass, *args, **kwargs):
"""
Wraps all layout objects pointed in `self.slice` together under a `LayoutClass`
instance with `args` and `kwargs` passed.
"""
if isinstance(self.slice, slice):
# The start of the slice is replaced
start = self.slice.start if self.slice.start is not None else 0
self.layout.fields[start] = self.wrapped_object(
LayoutClass, self.layout.fields[self.slice], *args, **kwargs
)
# The rest of places of the slice are removed, as they are included in the previous
for i in reversed(range(*self.slice.indices(len(self.layout.fields)))):
if i != start:
del self.layout.fields[i]
elif isinstance(self.slice, list):
raise DynamicError("wrap_together doesn't work with filter, only with [] operator") | python | def wrap_together(self, LayoutClass, *args, **kwargs):
"""
Wraps all layout objects pointed in `self.slice` together under a `LayoutClass`
instance with `args` and `kwargs` passed.
"""
if isinstance(self.slice, slice):
# The start of the slice is replaced
start = self.slice.start if self.slice.start is not None else 0
self.layout.fields[start] = self.wrapped_object(
LayoutClass, self.layout.fields[self.slice], *args, **kwargs
)
# The rest of places of the slice are removed, as they are included in the previous
for i in reversed(range(*self.slice.indices(len(self.layout.fields)))):
if i != start:
del self.layout.fields[i]
elif isinstance(self.slice, list):
raise DynamicError("wrap_together doesn't work with filter, only with [] operator") | [
"def",
"wrap_together",
"(",
"self",
",",
"LayoutClass",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
":",
"if",
"isinstance",
"(",
"self",
".",
"slice",
",",
"slice",
")",
":",
"# The start of the slice is replaced",
"start",
"=",
"self",
".",
"slice",... | Wraps all layout objects pointed in `self.slice` together under a `LayoutClass`
instance with `args` and `kwargs` passed. | [
"Wraps",
"all",
"layout",
"objects",
"pointed",
"in",
"self",
".",
"slice",
"together",
"under",
"a",
"LayoutClass",
"instance",
"with",
"args",
"and",
"kwargs",
"passed",
"."
] | cd476927a756133c667c199bb12120f877bf6b7e | https://github.com/django-crispy-forms/django-crispy-forms/blob/cd476927a756133c667c199bb12120f877bf6b7e/crispy_forms/layout_slice.py#L98-L116 |
225,515 | django-crispy-forms/django-crispy-forms | crispy_forms/layout_slice.py | LayoutSlice.map | def map(self, function):
"""
Iterates over layout objects pointed in `self.slice` executing `function` on them
It passes `function` last layout object
"""
if isinstance(self.slice, slice):
for i in range(*self.slice.indices(len(self.layout.fields))):
function(self.layout.fields[i])
elif isinstance(self.slice, list):
# A list of pointers Ex: [[[0, 0], 'div'], [[0, 2, 3], 'field_name']]
for pointer in self.slice:
position = pointer[0]
layout_object = self.layout.fields[position[0]]
for i in position[1:]:
previous_layout_object = layout_object
layout_object = layout_object.fields[i]
# If update_attrs is applied to a string, we call to its wrapping layout object
if (
function.__name__ == 'update_attrs'
and isinstance(layout_object, string_types)
):
function(previous_layout_object)
else:
function(layout_object) | python | def map(self, function):
"""
Iterates over layout objects pointed in `self.slice` executing `function` on them
It passes `function` last layout object
"""
if isinstance(self.slice, slice):
for i in range(*self.slice.indices(len(self.layout.fields))):
function(self.layout.fields[i])
elif isinstance(self.slice, list):
# A list of pointers Ex: [[[0, 0], 'div'], [[0, 2, 3], 'field_name']]
for pointer in self.slice:
position = pointer[0]
layout_object = self.layout.fields[position[0]]
for i in position[1:]:
previous_layout_object = layout_object
layout_object = layout_object.fields[i]
# If update_attrs is applied to a string, we call to its wrapping layout object
if (
function.__name__ == 'update_attrs'
and isinstance(layout_object, string_types)
):
function(previous_layout_object)
else:
function(layout_object) | [
"def",
"map",
"(",
"self",
",",
"function",
")",
":",
"if",
"isinstance",
"(",
"self",
".",
"slice",
",",
"slice",
")",
":",
"for",
"i",
"in",
"range",
"(",
"*",
"self",
".",
"slice",
".",
"indices",
"(",
"len",
"(",
"self",
".",
"layout",
".",
... | Iterates over layout objects pointed in `self.slice` executing `function` on them
It passes `function` last layout object | [
"Iterates",
"over",
"layout",
"objects",
"pointed",
"in",
"self",
".",
"slice",
"executing",
"function",
"on",
"them",
"It",
"passes",
"function",
"last",
"layout",
"object"
] | cd476927a756133c667c199bb12120f877bf6b7e | https://github.com/django-crispy-forms/django-crispy-forms/blob/cd476927a756133c667c199bb12120f877bf6b7e/crispy_forms/layout_slice.py#L118-L144 |
225,516 | django-crispy-forms/django-crispy-forms | crispy_forms/layout_slice.py | LayoutSlice.update_attributes | def update_attributes(self, **original_kwargs):
"""
Updates attributes of every layout object pointed in `self.slice` using kwargs
"""
def update_attrs(layout_object):
kwargs = original_kwargs.copy()
if hasattr(layout_object, 'attrs'):
if 'css_class' in kwargs:
if 'class' in layout_object.attrs:
layout_object.attrs['class'] += " %s" % kwargs.pop('css_class')
else:
layout_object.attrs['class'] = kwargs.pop('css_class')
layout_object.attrs.update(kwargs)
self.map(update_attrs) | python | def update_attributes(self, **original_kwargs):
"""
Updates attributes of every layout object pointed in `self.slice` using kwargs
"""
def update_attrs(layout_object):
kwargs = original_kwargs.copy()
if hasattr(layout_object, 'attrs'):
if 'css_class' in kwargs:
if 'class' in layout_object.attrs:
layout_object.attrs['class'] += " %s" % kwargs.pop('css_class')
else:
layout_object.attrs['class'] = kwargs.pop('css_class')
layout_object.attrs.update(kwargs)
self.map(update_attrs) | [
"def",
"update_attributes",
"(",
"self",
",",
"*",
"*",
"original_kwargs",
")",
":",
"def",
"update_attrs",
"(",
"layout_object",
")",
":",
"kwargs",
"=",
"original_kwargs",
".",
"copy",
"(",
")",
"if",
"hasattr",
"(",
"layout_object",
",",
"'attrs'",
")",
... | Updates attributes of every layout object pointed in `self.slice` using kwargs | [
"Updates",
"attributes",
"of",
"every",
"layout",
"object",
"pointed",
"in",
"self",
".",
"slice",
"using",
"kwargs"
] | cd476927a756133c667c199bb12120f877bf6b7e | https://github.com/django-crispy-forms/django-crispy-forms/blob/cd476927a756133c667c199bb12120f877bf6b7e/crispy_forms/layout_slice.py#L146-L160 |
225,517 | django-crispy-forms/django-crispy-forms | crispy_forms/helper.py | DynamicLayoutHandler.all | def all(self):
"""
Returns all layout objects of first level of depth
"""
self._check_layout()
return LayoutSlice(self.layout, slice(0, len(self.layout.fields), 1)) | python | def all(self):
"""
Returns all layout objects of first level of depth
"""
self._check_layout()
return LayoutSlice(self.layout, slice(0, len(self.layout.fields), 1)) | [
"def",
"all",
"(",
"self",
")",
":",
"self",
".",
"_check_layout",
"(",
")",
"return",
"LayoutSlice",
"(",
"self",
".",
"layout",
",",
"slice",
"(",
"0",
",",
"len",
"(",
"self",
".",
"layout",
".",
"fields",
")",
",",
"1",
")",
")"
] | Returns all layout objects of first level of depth | [
"Returns",
"all",
"layout",
"objects",
"of",
"first",
"level",
"of",
"depth"
] | cd476927a756133c667c199bb12120f877bf6b7e | https://github.com/django-crispy-forms/django-crispy-forms/blob/cd476927a756133c667c199bb12120f877bf6b7e/crispy_forms/helper.py#L31-L36 |
225,518 | django-crispy-forms/django-crispy-forms | crispy_forms/helper.py | DynamicLayoutHandler.filter | def filter(self, *LayoutClasses, **kwargs):
"""
Returns a LayoutSlice pointing to layout objects of type `LayoutClass`
"""
self._check_layout()
max_level = kwargs.pop('max_level', 0)
greedy = kwargs.pop('greedy', False)
filtered_layout_objects = self.layout.get_layout_objects(LayoutClasses, max_level=max_level, greedy=greedy)
return LayoutSlice(self.layout, filtered_layout_objects) | python | def filter(self, *LayoutClasses, **kwargs):
"""
Returns a LayoutSlice pointing to layout objects of type `LayoutClass`
"""
self._check_layout()
max_level = kwargs.pop('max_level', 0)
greedy = kwargs.pop('greedy', False)
filtered_layout_objects = self.layout.get_layout_objects(LayoutClasses, max_level=max_level, greedy=greedy)
return LayoutSlice(self.layout, filtered_layout_objects) | [
"def",
"filter",
"(",
"self",
",",
"*",
"LayoutClasses",
",",
"*",
"*",
"kwargs",
")",
":",
"self",
".",
"_check_layout",
"(",
")",
"max_level",
"=",
"kwargs",
".",
"pop",
"(",
"'max_level'",
",",
"0",
")",
"greedy",
"=",
"kwargs",
".",
"pop",
"(",
... | Returns a LayoutSlice pointing to layout objects of type `LayoutClass` | [
"Returns",
"a",
"LayoutSlice",
"pointing",
"to",
"layout",
"objects",
"of",
"type",
"LayoutClass"
] | cd476927a756133c667c199bb12120f877bf6b7e | https://github.com/django-crispy-forms/django-crispy-forms/blob/cd476927a756133c667c199bb12120f877bf6b7e/crispy_forms/helper.py#L38-L47 |
225,519 | django-crispy-forms/django-crispy-forms | crispy_forms/helper.py | DynamicLayoutHandler.filter_by_widget | def filter_by_widget(self, widget_type):
"""
Returns a LayoutSlice pointing to fields with widgets of `widget_type`
"""
self._check_layout_and_form()
layout_field_names = self.layout.get_field_names()
# Let's filter all fields with widgets like widget_type
filtered_fields = []
for pointer in layout_field_names:
if isinstance(self.form.fields[pointer[1]].widget, widget_type):
filtered_fields.append(pointer)
return LayoutSlice(self.layout, filtered_fields) | python | def filter_by_widget(self, widget_type):
"""
Returns a LayoutSlice pointing to fields with widgets of `widget_type`
"""
self._check_layout_and_form()
layout_field_names = self.layout.get_field_names()
# Let's filter all fields with widgets like widget_type
filtered_fields = []
for pointer in layout_field_names:
if isinstance(self.form.fields[pointer[1]].widget, widget_type):
filtered_fields.append(pointer)
return LayoutSlice(self.layout, filtered_fields) | [
"def",
"filter_by_widget",
"(",
"self",
",",
"widget_type",
")",
":",
"self",
".",
"_check_layout_and_form",
"(",
")",
"layout_field_names",
"=",
"self",
".",
"layout",
".",
"get_field_names",
"(",
")",
"# Let's filter all fields with widgets like widget_type",
"filtere... | Returns a LayoutSlice pointing to fields with widgets of `widget_type` | [
"Returns",
"a",
"LayoutSlice",
"pointing",
"to",
"fields",
"with",
"widgets",
"of",
"widget_type"
] | cd476927a756133c667c199bb12120f877bf6b7e | https://github.com/django-crispy-forms/django-crispy-forms/blob/cd476927a756133c667c199bb12120f877bf6b7e/crispy_forms/helper.py#L49-L62 |
225,520 | django-crispy-forms/django-crispy-forms | crispy_forms/helper.py | FormHelper.get_attributes | def get_attributes(self, template_pack=TEMPLATE_PACK):
"""
Used by crispy_forms_tags to get helper attributes
"""
items = {
'form_method': self.form_method.strip(),
'form_tag': self.form_tag,
'form_style': self.form_style.strip(),
'form_show_errors': self.form_show_errors,
'help_text_inline': self.help_text_inline,
'error_text_inline': self.error_text_inline,
'html5_required': self.html5_required,
'form_show_labels': self.form_show_labels,
'disable_csrf': self.disable_csrf,
'label_class': self.label_class,
'field_class': self.field_class,
'include_media': self.include_media
}
if template_pack == 'bootstrap4':
bootstrap_size_match = re.findall('col-(xl|lg|md|sm)-(\d+)', self.label_class)
if bootstrap_size_match:
if template_pack == 'bootstrap4':
offset_pattern = 'offset-%s-%s'
else:
offset_pattern = 'col-%s-offset-%s'
items['bootstrap_checkbox_offsets'] = [offset_pattern % m for m in bootstrap_size_match]
else:
bootstrap_size_match = re.findall('col-(lg|md|sm|xs)-(\d+)', self.label_class)
if bootstrap_size_match:
if template_pack == 'bootstrap4':
offset_pattern = 'offset-%s-%s'
else:
offset_pattern = 'col-%s-offset-%s'
items['bootstrap_checkbox_offsets'] = [offset_pattern % m for m in bootstrap_size_match]
items['attrs'] = {}
if self.attrs:
items['attrs'] = self.attrs.copy()
if self.form_action:
items['attrs']['action'] = self.form_action.strip()
if self.form_id:
items['attrs']['id'] = self.form_id.strip()
if self.form_class:
# uni_form TEMPLATE PACK has a uniForm class by default
if template_pack == 'uni_form':
items['attrs']['class'] = "uniForm %s" % self.form_class.strip()
else:
items['attrs']['class'] = self.form_class.strip()
else:
if template_pack == 'uni_form':
items['attrs']['class'] = self.attrs.get('class', '') + " uniForm"
if self.form_group_wrapper_class:
items['attrs']['form_group_wrapper_class'] = self.form_group_wrapper_class
items['flat_attrs'] = flatatt(items['attrs'])
if self.inputs:
items['inputs'] = self.inputs
if self.form_error_title:
items['form_error_title'] = self.form_error_title.strip()
if self.formset_error_title:
items['formset_error_title'] = self.formset_error_title.strip()
for attribute_name, value in self.__dict__.items():
if attribute_name not in items and attribute_name not in ['layout', 'inputs'] and not attribute_name.startswith('_'):
items[attribute_name] = value
return items | python | def get_attributes(self, template_pack=TEMPLATE_PACK):
"""
Used by crispy_forms_tags to get helper attributes
"""
items = {
'form_method': self.form_method.strip(),
'form_tag': self.form_tag,
'form_style': self.form_style.strip(),
'form_show_errors': self.form_show_errors,
'help_text_inline': self.help_text_inline,
'error_text_inline': self.error_text_inline,
'html5_required': self.html5_required,
'form_show_labels': self.form_show_labels,
'disable_csrf': self.disable_csrf,
'label_class': self.label_class,
'field_class': self.field_class,
'include_media': self.include_media
}
if template_pack == 'bootstrap4':
bootstrap_size_match = re.findall('col-(xl|lg|md|sm)-(\d+)', self.label_class)
if bootstrap_size_match:
if template_pack == 'bootstrap4':
offset_pattern = 'offset-%s-%s'
else:
offset_pattern = 'col-%s-offset-%s'
items['bootstrap_checkbox_offsets'] = [offset_pattern % m for m in bootstrap_size_match]
else:
bootstrap_size_match = re.findall('col-(lg|md|sm|xs)-(\d+)', self.label_class)
if bootstrap_size_match:
if template_pack == 'bootstrap4':
offset_pattern = 'offset-%s-%s'
else:
offset_pattern = 'col-%s-offset-%s'
items['bootstrap_checkbox_offsets'] = [offset_pattern % m for m in bootstrap_size_match]
items['attrs'] = {}
if self.attrs:
items['attrs'] = self.attrs.copy()
if self.form_action:
items['attrs']['action'] = self.form_action.strip()
if self.form_id:
items['attrs']['id'] = self.form_id.strip()
if self.form_class:
# uni_form TEMPLATE PACK has a uniForm class by default
if template_pack == 'uni_form':
items['attrs']['class'] = "uniForm %s" % self.form_class.strip()
else:
items['attrs']['class'] = self.form_class.strip()
else:
if template_pack == 'uni_form':
items['attrs']['class'] = self.attrs.get('class', '') + " uniForm"
if self.form_group_wrapper_class:
items['attrs']['form_group_wrapper_class'] = self.form_group_wrapper_class
items['flat_attrs'] = flatatt(items['attrs'])
if self.inputs:
items['inputs'] = self.inputs
if self.form_error_title:
items['form_error_title'] = self.form_error_title.strip()
if self.formset_error_title:
items['formset_error_title'] = self.formset_error_title.strip()
for attribute_name, value in self.__dict__.items():
if attribute_name not in items and attribute_name not in ['layout', 'inputs'] and not attribute_name.startswith('_'):
items[attribute_name] = value
return items | [
"def",
"get_attributes",
"(",
"self",
",",
"template_pack",
"=",
"TEMPLATE_PACK",
")",
":",
"items",
"=",
"{",
"'form_method'",
":",
"self",
".",
"form_method",
".",
"strip",
"(",
")",
",",
"'form_tag'",
":",
"self",
".",
"form_tag",
",",
"'form_style'",
"... | Used by crispy_forms_tags to get helper attributes | [
"Used",
"by",
"crispy_forms_tags",
"to",
"get",
"helper",
"attributes"
] | cd476927a756133c667c199bb12120f877bf6b7e | https://github.com/django-crispy-forms/django-crispy-forms/blob/cd476927a756133c667c199bb12120f877bf6b7e/crispy_forms/helper.py#L353-L421 |
225,521 | django-crispy-forms/django-crispy-forms | crispy_forms/utils.py | flatatt | def flatatt(attrs):
"""
Convert a dictionary of attributes to a single string.
Passed attributes are redirected to `django.forms.utils.flatatt()`
with replaced "_" (underscores) by "-" (dashes) in their names.
"""
return _flatatt({k.replace('_', '-'): v for k, v in attrs.items()}) | python | def flatatt(attrs):
"""
Convert a dictionary of attributes to a single string.
Passed attributes are redirected to `django.forms.utils.flatatt()`
with replaced "_" (underscores) by "-" (dashes) in their names.
"""
return _flatatt({k.replace('_', '-'): v for k, v in attrs.items()}) | [
"def",
"flatatt",
"(",
"attrs",
")",
":",
"return",
"_flatatt",
"(",
"{",
"k",
".",
"replace",
"(",
"'_'",
",",
"'-'",
")",
":",
"v",
"for",
"k",
",",
"v",
"in",
"attrs",
".",
"items",
"(",
")",
"}",
")"
] | Convert a dictionary of attributes to a single string.
Passed attributes are redirected to `django.forms.utils.flatatt()`
with replaced "_" (underscores) by "-" (dashes) in their names. | [
"Convert",
"a",
"dictionary",
"of",
"attributes",
"to",
"a",
"single",
"string",
"."
] | cd476927a756133c667c199bb12120f877bf6b7e | https://github.com/django-crispy-forms/django-crispy-forms/blob/cd476927a756133c667c199bb12120f877bf6b7e/crispy_forms/utils.py#L153-L160 |
225,522 | django-crispy-forms/django-crispy-forms | crispy_forms/utils.py | render_crispy_form | def render_crispy_form(form, helper=None, context=None):
"""
Renders a form and returns its HTML output.
This function wraps the template logic in a function easy to use in a Django view.
"""
from crispy_forms.templatetags.crispy_forms_tags import CrispyFormNode
if helper is not None:
node = CrispyFormNode('form', 'helper')
else:
node = CrispyFormNode('form', None)
node_context = Context(context)
node_context.update({
'form': form,
'helper': helper
})
return node.render(node_context) | python | def render_crispy_form(form, helper=None, context=None):
"""
Renders a form and returns its HTML output.
This function wraps the template logic in a function easy to use in a Django view.
"""
from crispy_forms.templatetags.crispy_forms_tags import CrispyFormNode
if helper is not None:
node = CrispyFormNode('form', 'helper')
else:
node = CrispyFormNode('form', None)
node_context = Context(context)
node_context.update({
'form': form,
'helper': helper
})
return node.render(node_context) | [
"def",
"render_crispy_form",
"(",
"form",
",",
"helper",
"=",
"None",
",",
"context",
"=",
"None",
")",
":",
"from",
"crispy_forms",
".",
"templatetags",
".",
"crispy_forms_tags",
"import",
"CrispyFormNode",
"if",
"helper",
"is",
"not",
"None",
":",
"node",
... | Renders a form and returns its HTML output.
This function wraps the template logic in a function easy to use in a Django view. | [
"Renders",
"a",
"form",
"and",
"returns",
"its",
"HTML",
"output",
"."
] | cd476927a756133c667c199bb12120f877bf6b7e | https://github.com/django-crispy-forms/django-crispy-forms/blob/cd476927a756133c667c199bb12120f877bf6b7e/crispy_forms/utils.py#L163-L182 |
225,523 | moderngl/moderngl | moderngl/vertex_array.py | VertexArray.bind | def bind(self, attribute, cls, buffer, fmt, *, offset=0, stride=0, divisor=0, normalize=False) -> None:
'''
Bind individual attributes to buffers.
Args:
location (int): The attribute location.
cls (str): The attribute class. Valid values are ``f``, ``i`` or ``d``.
buffer (Buffer): The buffer.
format (str): The buffer format.
Keyword Args:
offset (int): The offset.
stride (int): The stride.
divisor (int): The divisor.
normalize (bool): The normalize parameter, if applicable.
'''
self.mglo.bind(attribute, cls, buffer.mglo, fmt, offset, stride, divisor, normalize) | python | def bind(self, attribute, cls, buffer, fmt, *, offset=0, stride=0, divisor=0, normalize=False) -> None:
'''
Bind individual attributes to buffers.
Args:
location (int): The attribute location.
cls (str): The attribute class. Valid values are ``f``, ``i`` or ``d``.
buffer (Buffer): The buffer.
format (str): The buffer format.
Keyword Args:
offset (int): The offset.
stride (int): The stride.
divisor (int): The divisor.
normalize (bool): The normalize parameter, if applicable.
'''
self.mglo.bind(attribute, cls, buffer.mglo, fmt, offset, stride, divisor, normalize) | [
"def",
"bind",
"(",
"self",
",",
"attribute",
",",
"cls",
",",
"buffer",
",",
"fmt",
",",
"*",
",",
"offset",
"=",
"0",
",",
"stride",
"=",
"0",
",",
"divisor",
"=",
"0",
",",
"normalize",
"=",
"False",
")",
"->",
"None",
":",
"self",
".",
"mgl... | Bind individual attributes to buffers.
Args:
location (int): The attribute location.
cls (str): The attribute class. Valid values are ``f``, ``i`` or ``d``.
buffer (Buffer): The buffer.
format (str): The buffer format.
Keyword Args:
offset (int): The offset.
stride (int): The stride.
divisor (int): The divisor.
normalize (bool): The normalize parameter, if applicable. | [
"Bind",
"individual",
"attributes",
"to",
"buffers",
"."
] | a8f5dce8dc72ae84a2f9523887fb5f6b620049b9 | https://github.com/moderngl/moderngl/blob/a8f5dce8dc72ae84a2f9523887fb5f6b620049b9/moderngl/vertex_array.py#L173-L190 |
225,524 | moderngl/moderngl | examples/08_compute_shader.py | source | def source(uri, consts):
''' read gl code '''
with open(uri, 'r') as fp:
content = fp.read()
# feed constant values
for key, value in consts.items():
content = content.replace(f"%%{key}%%", str(value))
return content | python | def source(uri, consts):
''' read gl code '''
with open(uri, 'r') as fp:
content = fp.read()
# feed constant values
for key, value in consts.items():
content = content.replace(f"%%{key}%%", str(value))
return content | [
"def",
"source",
"(",
"uri",
",",
"consts",
")",
":",
"with",
"open",
"(",
"uri",
",",
"'r'",
")",
"as",
"fp",
":",
"content",
"=",
"fp",
".",
"read",
"(",
")",
"# feed constant values",
"for",
"key",
",",
"value",
"in",
"consts",
".",
"items",
"("... | read gl code | [
"read",
"gl",
"code"
] | a8f5dce8dc72ae84a2f9523887fb5f6b620049b9 | https://github.com/moderngl/moderngl/blob/a8f5dce8dc72ae84a2f9523887fb5f6b620049b9/examples/08_compute_shader.py#L17-L25 |
225,525 | moderngl/moderngl | moderngl/context.py | create_standalone_context | def create_standalone_context(require=None, **settings) -> 'Context':
'''
Create a standalone ModernGL context.
Example::
# Create a context with highest possible supported version
ctx = moderngl.create_context()
# Require at least OpenGL 4.3
ctx = moderngl.create_context(require=430)
Keyword Arguments:
require (int): OpenGL version code.
Returns:
:py:class:`Context` object
'''
backend = os.environ.get('MODERNGL_BACKEND')
if backend is not None:
settings['backend'] = backend
ctx = Context.__new__(Context)
ctx.mglo, ctx.version_code = mgl.create_standalone_context(settings)
ctx._screen = None
ctx.fbo = None
ctx._info = None
ctx.extra = None
if require is not None and ctx.version_code < require:
raise ValueError('Requested OpenGL version {}, got version {}'.format(
require, ctx.version_code))
return ctx | python | def create_standalone_context(require=None, **settings) -> 'Context':
'''
Create a standalone ModernGL context.
Example::
# Create a context with highest possible supported version
ctx = moderngl.create_context()
# Require at least OpenGL 4.3
ctx = moderngl.create_context(require=430)
Keyword Arguments:
require (int): OpenGL version code.
Returns:
:py:class:`Context` object
'''
backend = os.environ.get('MODERNGL_BACKEND')
if backend is not None:
settings['backend'] = backend
ctx = Context.__new__(Context)
ctx.mglo, ctx.version_code = mgl.create_standalone_context(settings)
ctx._screen = None
ctx.fbo = None
ctx._info = None
ctx.extra = None
if require is not None and ctx.version_code < require:
raise ValueError('Requested OpenGL version {}, got version {}'.format(
require, ctx.version_code))
return ctx | [
"def",
"create_standalone_context",
"(",
"require",
"=",
"None",
",",
"*",
"*",
"settings",
")",
"->",
"'Context'",
":",
"backend",
"=",
"os",
".",
"environ",
".",
"get",
"(",
"'MODERNGL_BACKEND'",
")",
"if",
"backend",
"is",
"not",
"None",
":",
"settings"... | Create a standalone ModernGL context.
Example::
# Create a context with highest possible supported version
ctx = moderngl.create_context()
# Require at least OpenGL 4.3
ctx = moderngl.create_context(require=430)
Keyword Arguments:
require (int): OpenGL version code.
Returns:
:py:class:`Context` object | [
"Create",
"a",
"standalone",
"ModernGL",
"context",
"."
] | a8f5dce8dc72ae84a2f9523887fb5f6b620049b9 | https://github.com/moderngl/moderngl/blob/a8f5dce8dc72ae84a2f9523887fb5f6b620049b9/moderngl/context.py#L1135-L1169 |
225,526 | moderngl/moderngl | moderngl/context.py | Context.copy_buffer | def copy_buffer(self, dst, src, size=-1, *, read_offset=0, write_offset=0) -> None:
'''
Copy buffer content.
Args:
dst (Buffer): The destination buffer.
src (Buffer): The source buffer.
size (int): The number of bytes to copy.
Keyword Args:
read_offset (int): The read offset.
write_offset (int): The write offset.
'''
self.mglo.copy_buffer(dst.mglo, src.mglo, size, read_offset, write_offset) | python | def copy_buffer(self, dst, src, size=-1, *, read_offset=0, write_offset=0) -> None:
'''
Copy buffer content.
Args:
dst (Buffer): The destination buffer.
src (Buffer): The source buffer.
size (int): The number of bytes to copy.
Keyword Args:
read_offset (int): The read offset.
write_offset (int): The write offset.
'''
self.mglo.copy_buffer(dst.mglo, src.mglo, size, read_offset, write_offset) | [
"def",
"copy_buffer",
"(",
"self",
",",
"dst",
",",
"src",
",",
"size",
"=",
"-",
"1",
",",
"*",
",",
"read_offset",
"=",
"0",
",",
"write_offset",
"=",
"0",
")",
"->",
"None",
":",
"self",
".",
"mglo",
".",
"copy_buffer",
"(",
"dst",
".",
"mglo"... | Copy buffer content.
Args:
dst (Buffer): The destination buffer.
src (Buffer): The source buffer.
size (int): The number of bytes to copy.
Keyword Args:
read_offset (int): The read offset.
write_offset (int): The write offset. | [
"Copy",
"buffer",
"content",
"."
] | a8f5dce8dc72ae84a2f9523887fb5f6b620049b9 | https://github.com/moderngl/moderngl/blob/a8f5dce8dc72ae84a2f9523887fb5f6b620049b9/moderngl/context.py#L505-L519 |
225,527 | moderngl/moderngl | moderngl/context.py | Context.copy_framebuffer | def copy_framebuffer(self, dst, src) -> None:
'''
Copy framebuffer content.
Use this method to:
- blit framebuffers.
- copy framebuffer content into a texture.
- downsample framebuffers. (it will allow to read the framebuffer's content)
- downsample a framebuffer directly to a texture.
Args:
dst (Framebuffer or Texture): Destination framebuffer or texture.
src (Framebuffer): Source framebuffer.
'''
self.mglo.copy_framebuffer(dst.mglo, src.mglo) | python | def copy_framebuffer(self, dst, src) -> None:
'''
Copy framebuffer content.
Use this method to:
- blit framebuffers.
- copy framebuffer content into a texture.
- downsample framebuffers. (it will allow to read the framebuffer's content)
- downsample a framebuffer directly to a texture.
Args:
dst (Framebuffer or Texture): Destination framebuffer or texture.
src (Framebuffer): Source framebuffer.
'''
self.mglo.copy_framebuffer(dst.mglo, src.mglo) | [
"def",
"copy_framebuffer",
"(",
"self",
",",
"dst",
",",
"src",
")",
"->",
"None",
":",
"self",
".",
"mglo",
".",
"copy_framebuffer",
"(",
"dst",
".",
"mglo",
",",
"src",
".",
"mglo",
")"
] | Copy framebuffer content.
Use this method to:
- blit framebuffers.
- copy framebuffer content into a texture.
- downsample framebuffers. (it will allow to read the framebuffer's content)
- downsample a framebuffer directly to a texture.
Args:
dst (Framebuffer or Texture): Destination framebuffer or texture.
src (Framebuffer): Source framebuffer. | [
"Copy",
"framebuffer",
"content",
"."
] | a8f5dce8dc72ae84a2f9523887fb5f6b620049b9 | https://github.com/moderngl/moderngl/blob/a8f5dce8dc72ae84a2f9523887fb5f6b620049b9/moderngl/context.py#L521-L537 |
225,528 | moderngl/moderngl | moderngl/context.py | Context.detect_framebuffer | def detect_framebuffer(self, glo=None) -> 'Framebuffer':
'''
Detect framebuffer.
Args:
glo (int): Framebuffer object.
Returns:
:py:class:`Framebuffer` object
'''
res = Framebuffer.__new__(Framebuffer)
res.mglo, res._size, res._samples, res._glo = self.mglo.detect_framebuffer(glo)
res._color_attachments = None
res._depth_attachment = None
res.ctx = self
res.extra = None
return res | python | def detect_framebuffer(self, glo=None) -> 'Framebuffer':
'''
Detect framebuffer.
Args:
glo (int): Framebuffer object.
Returns:
:py:class:`Framebuffer` object
'''
res = Framebuffer.__new__(Framebuffer)
res.mglo, res._size, res._samples, res._glo = self.mglo.detect_framebuffer(glo)
res._color_attachments = None
res._depth_attachment = None
res.ctx = self
res.extra = None
return res | [
"def",
"detect_framebuffer",
"(",
"self",
",",
"glo",
"=",
"None",
")",
"->",
"'Framebuffer'",
":",
"res",
"=",
"Framebuffer",
".",
"__new__",
"(",
"Framebuffer",
")",
"res",
".",
"mglo",
",",
"res",
".",
"_size",
",",
"res",
".",
"_samples",
",",
"res... | Detect framebuffer.
Args:
glo (int): Framebuffer object.
Returns:
:py:class:`Framebuffer` object | [
"Detect",
"framebuffer",
"."
] | a8f5dce8dc72ae84a2f9523887fb5f6b620049b9 | https://github.com/moderngl/moderngl/blob/a8f5dce8dc72ae84a2f9523887fb5f6b620049b9/moderngl/context.py#L539-L556 |
225,529 | moderngl/moderngl | moderngl/context.py | Context.core_profile_check | def core_profile_check(self) -> None:
'''
Core profile check.
FOR DEBUG PURPOSES ONLY
'''
profile_mask = self.info['GL_CONTEXT_PROFILE_MASK']
if profile_mask != 1:
warnings.warn('The window should request a CORE OpenGL profile')
version_code = self.version_code
if not version_code:
major, minor = map(int, self.info['GL_VERSION'].split('.', 2)[:2])
version_code = major * 100 + minor * 10
if version_code < 330:
warnings.warn('The window should support OpenGL 3.3+ (version_code=%d)' % version_code) | python | def core_profile_check(self) -> None:
'''
Core profile check.
FOR DEBUG PURPOSES ONLY
'''
profile_mask = self.info['GL_CONTEXT_PROFILE_MASK']
if profile_mask != 1:
warnings.warn('The window should request a CORE OpenGL profile')
version_code = self.version_code
if not version_code:
major, minor = map(int, self.info['GL_VERSION'].split('.', 2)[:2])
version_code = major * 100 + minor * 10
if version_code < 330:
warnings.warn('The window should support OpenGL 3.3+ (version_code=%d)' % version_code) | [
"def",
"core_profile_check",
"(",
"self",
")",
"->",
"None",
":",
"profile_mask",
"=",
"self",
".",
"info",
"[",
"'GL_CONTEXT_PROFILE_MASK'",
"]",
"if",
"profile_mask",
"!=",
"1",
":",
"warnings",
".",
"warn",
"(",
"'The window should request a CORE OpenGL profile'"... | Core profile check.
FOR DEBUG PURPOSES ONLY | [
"Core",
"profile",
"check",
"."
] | a8f5dce8dc72ae84a2f9523887fb5f6b620049b9 | https://github.com/moderngl/moderngl/blob/a8f5dce8dc72ae84a2f9523887fb5f6b620049b9/moderngl/context.py#L1072-L1089 |
225,530 | moderngl/moderngl | examples/window/glfw/window.py | Window.mouse_button_callback | def mouse_button_callback(self, window, button, action, mods):
"""
Handle mouse button events and forward them to the example
"""
# Offset button index by 1 to make it match the other libraries
button += 1
# Support left and right mouse button for now
if button not in [1, 2]:
return
xpos, ypos = glfw.get_cursor_pos(self.window)
if action == glfw.PRESS:
self.example.mouse_press_event(xpos, ypos, button)
else:
self.example.mouse_release_event(xpos, ypos, button) | python | def mouse_button_callback(self, window, button, action, mods):
"""
Handle mouse button events and forward them to the example
"""
# Offset button index by 1 to make it match the other libraries
button += 1
# Support left and right mouse button for now
if button not in [1, 2]:
return
xpos, ypos = glfw.get_cursor_pos(self.window)
if action == glfw.PRESS:
self.example.mouse_press_event(xpos, ypos, button)
else:
self.example.mouse_release_event(xpos, ypos, button) | [
"def",
"mouse_button_callback",
"(",
"self",
",",
"window",
",",
"button",
",",
"action",
",",
"mods",
")",
":",
"# Offset button index by 1 to make it match the other libraries\r",
"button",
"+=",
"1",
"# Support left and right mouse button for now\r",
"if",
"button",
"not... | Handle mouse button events and forward them to the example | [
"Handle",
"mouse",
"button",
"events",
"and",
"forward",
"them",
"to",
"the",
"example"
] | a8f5dce8dc72ae84a2f9523887fb5f6b620049b9 | https://github.com/moderngl/moderngl/blob/a8f5dce8dc72ae84a2f9523887fb5f6b620049b9/examples/window/glfw/window.py#L121-L136 |
225,531 | moderngl/moderngl | moderngl/buffer.py | Buffer.write_chunks | def write_chunks(self, data, start, step, count) -> None:
'''
Split data to count equal parts.
Write the chunks using offsets calculated from start, step and stop.
Args:
data (bytes): The data.
start (int): First offset.
step (int): Offset increment.
count (int): The number of offsets.
'''
self.mglo.write_chunks(data, start, step, count) | python | def write_chunks(self, data, start, step, count) -> None:
'''
Split data to count equal parts.
Write the chunks using offsets calculated from start, step and stop.
Args:
data (bytes): The data.
start (int): First offset.
step (int): Offset increment.
count (int): The number of offsets.
'''
self.mglo.write_chunks(data, start, step, count) | [
"def",
"write_chunks",
"(",
"self",
",",
"data",
",",
"start",
",",
"step",
",",
"count",
")",
"->",
"None",
":",
"self",
".",
"mglo",
".",
"write_chunks",
"(",
"data",
",",
"start",
",",
"step",
",",
"count",
")"
] | Split data to count equal parts.
Write the chunks using offsets calculated from start, step and stop.
Args:
data (bytes): The data.
start (int): First offset.
step (int): Offset increment.
count (int): The number of offsets. | [
"Split",
"data",
"to",
"count",
"equal",
"parts",
"."
] | a8f5dce8dc72ae84a2f9523887fb5f6b620049b9 | https://github.com/moderngl/moderngl/blob/a8f5dce8dc72ae84a2f9523887fb5f6b620049b9/moderngl/buffer.py#L72-L85 |
225,532 | moderngl/moderngl | moderngl/buffer.py | Buffer.read_into | def read_into(self, buffer, size=-1, *, offset=0, write_offset=0) -> None:
'''
Read the content into a buffer.
Args:
buffer (bytarray): The buffer that will receive the content.
size (int): The size. Value ``-1`` means all.
Keyword Args:
offset (int): The read offset.
write_offset (int): The write offset.
'''
return self.mglo.read_into(buffer, size, offset, write_offset) | python | def read_into(self, buffer, size=-1, *, offset=0, write_offset=0) -> None:
'''
Read the content into a buffer.
Args:
buffer (bytarray): The buffer that will receive the content.
size (int): The size. Value ``-1`` means all.
Keyword Args:
offset (int): The read offset.
write_offset (int): The write offset.
'''
return self.mglo.read_into(buffer, size, offset, write_offset) | [
"def",
"read_into",
"(",
"self",
",",
"buffer",
",",
"size",
"=",
"-",
"1",
",",
"*",
",",
"offset",
"=",
"0",
",",
"write_offset",
"=",
"0",
")",
"->",
"None",
":",
"return",
"self",
".",
"mglo",
".",
"read_into",
"(",
"buffer",
",",
"size",
","... | Read the content into a buffer.
Args:
buffer (bytarray): The buffer that will receive the content.
size (int): The size. Value ``-1`` means all.
Keyword Args:
offset (int): The read offset.
write_offset (int): The write offset. | [
"Read",
"the",
"content",
"into",
"a",
"buffer",
"."
] | a8f5dce8dc72ae84a2f9523887fb5f6b620049b9 | https://github.com/moderngl/moderngl/blob/a8f5dce8dc72ae84a2f9523887fb5f6b620049b9/moderngl/buffer.py#L103-L116 |
225,533 | moderngl/moderngl | moderngl/buffer.py | Buffer.clear | def clear(self, size=-1, *, offset=0, chunk=None) -> None:
'''
Clear the content.
Args:
size (int): The size. Value ``-1`` means all.
Keyword Args:
offset (int): The offset.
chunk (bytes): The chunk to use repeatedly.
'''
self.mglo.clear(size, offset, chunk) | python | def clear(self, size=-1, *, offset=0, chunk=None) -> None:
'''
Clear the content.
Args:
size (int): The size. Value ``-1`` means all.
Keyword Args:
offset (int): The offset.
chunk (bytes): The chunk to use repeatedly.
'''
self.mglo.clear(size, offset, chunk) | [
"def",
"clear",
"(",
"self",
",",
"size",
"=",
"-",
"1",
",",
"*",
",",
"offset",
"=",
"0",
",",
"chunk",
"=",
"None",
")",
"->",
"None",
":",
"self",
".",
"mglo",
".",
"clear",
"(",
"size",
",",
"offset",
",",
"chunk",
")"
] | Clear the content.
Args:
size (int): The size. Value ``-1`` means all.
Keyword Args:
offset (int): The offset.
chunk (bytes): The chunk to use repeatedly. | [
"Clear",
"the",
"content",
"."
] | a8f5dce8dc72ae84a2f9523887fb5f6b620049b9 | https://github.com/moderngl/moderngl/blob/a8f5dce8dc72ae84a2f9523887fb5f6b620049b9/moderngl/buffer.py#L157-L169 |
225,534 | moderngl/moderngl | moderngl/buffer.py | Buffer.bind_to_uniform_block | def bind_to_uniform_block(self, binding=0, *, offset=0, size=-1) -> None:
'''
Bind the buffer to a uniform block.
Args:
binding (int): The uniform block binding.
Keyword Args:
offset (int): The offset.
size (int): The size. Value ``-1`` means all.
'''
self.mglo.bind_to_uniform_block(binding, offset, size) | python | def bind_to_uniform_block(self, binding=0, *, offset=0, size=-1) -> None:
'''
Bind the buffer to a uniform block.
Args:
binding (int): The uniform block binding.
Keyword Args:
offset (int): The offset.
size (int): The size. Value ``-1`` means all.
'''
self.mglo.bind_to_uniform_block(binding, offset, size) | [
"def",
"bind_to_uniform_block",
"(",
"self",
",",
"binding",
"=",
"0",
",",
"*",
",",
"offset",
"=",
"0",
",",
"size",
"=",
"-",
"1",
")",
"->",
"None",
":",
"self",
".",
"mglo",
".",
"bind_to_uniform_block",
"(",
"binding",
",",
"offset",
",",
"size... | Bind the buffer to a uniform block.
Args:
binding (int): The uniform block binding.
Keyword Args:
offset (int): The offset.
size (int): The size. Value ``-1`` means all. | [
"Bind",
"the",
"buffer",
"to",
"a",
"uniform",
"block",
"."
] | a8f5dce8dc72ae84a2f9523887fb5f6b620049b9 | https://github.com/moderngl/moderngl/blob/a8f5dce8dc72ae84a2f9523887fb5f6b620049b9/moderngl/buffer.py#L171-L183 |
225,535 | moderngl/moderngl | moderngl/buffer.py | Buffer.bind_to_storage_buffer | def bind_to_storage_buffer(self, binding=0, *, offset=0, size=-1) -> None:
'''
Bind the buffer to a shader storage buffer.
Args:
binding (int): The shader storage binding.
Keyword Args:
offset (int): The offset.
size (int): The size. Value ``-1`` means all.
'''
self.mglo.bind_to_storage_buffer(binding, offset, size) | python | def bind_to_storage_buffer(self, binding=0, *, offset=0, size=-1) -> None:
'''
Bind the buffer to a shader storage buffer.
Args:
binding (int): The shader storage binding.
Keyword Args:
offset (int): The offset.
size (int): The size. Value ``-1`` means all.
'''
self.mglo.bind_to_storage_buffer(binding, offset, size) | [
"def",
"bind_to_storage_buffer",
"(",
"self",
",",
"binding",
"=",
"0",
",",
"*",
",",
"offset",
"=",
"0",
",",
"size",
"=",
"-",
"1",
")",
"->",
"None",
":",
"self",
".",
"mglo",
".",
"bind_to_storage_buffer",
"(",
"binding",
",",
"offset",
",",
"si... | Bind the buffer to a shader storage buffer.
Args:
binding (int): The shader storage binding.
Keyword Args:
offset (int): The offset.
size (int): The size. Value ``-1`` means all. | [
"Bind",
"the",
"buffer",
"to",
"a",
"shader",
"storage",
"buffer",
"."
] | a8f5dce8dc72ae84a2f9523887fb5f6b620049b9 | https://github.com/moderngl/moderngl/blob/a8f5dce8dc72ae84a2f9523887fb5f6b620049b9/moderngl/buffer.py#L185-L197 |
225,536 | moderngl/moderngl | examples/window/pyqt5/window.py | Window.swap_buffers | def swap_buffers(self):
"""
Swap buffers, set viewport, trigger events and increment frame counter
"""
self.widget.swapBuffers()
self.set_default_viewport()
self.app.processEvents()
self.frames += 1 | python | def swap_buffers(self):
"""
Swap buffers, set viewport, trigger events and increment frame counter
"""
self.widget.swapBuffers()
self.set_default_viewport()
self.app.processEvents()
self.frames += 1 | [
"def",
"swap_buffers",
"(",
"self",
")",
":",
"self",
".",
"widget",
".",
"swapBuffers",
"(",
")",
"self",
".",
"set_default_viewport",
"(",
")",
"self",
".",
"app",
".",
"processEvents",
"(",
")",
"self",
".",
"frames",
"+=",
"1"
] | Swap buffers, set viewport, trigger events and increment frame counter | [
"Swap",
"buffers",
"set",
"viewport",
"trigger",
"events",
"and",
"increment",
"frame",
"counter"
] | a8f5dce8dc72ae84a2f9523887fb5f6b620049b9 | https://github.com/moderngl/moderngl/blob/a8f5dce8dc72ae84a2f9523887fb5f6b620049b9/examples/window/pyqt5/window.py#L100-L107 |
225,537 | moderngl/moderngl | examples/window/pyqt5/window.py | Window.resize | def resize(self, width: int, height: int):
"""
Replacement for Qt's resizeGL method.
"""
self.width = width // self.widget.devicePixelRatio()
self.height = height // self.widget.devicePixelRatio()
self.buffer_width = width
self.buffer_height = height
if self.ctx:
self.set_default_viewport()
# Make sure we notify the example about the resize
super().resize(self.buffer_width, self.buffer_height) | python | def resize(self, width: int, height: int):
"""
Replacement for Qt's resizeGL method.
"""
self.width = width // self.widget.devicePixelRatio()
self.height = height // self.widget.devicePixelRatio()
self.buffer_width = width
self.buffer_height = height
if self.ctx:
self.set_default_viewport()
# Make sure we notify the example about the resize
super().resize(self.buffer_width, self.buffer_height) | [
"def",
"resize",
"(",
"self",
",",
"width",
":",
"int",
",",
"height",
":",
"int",
")",
":",
"self",
".",
"width",
"=",
"width",
"//",
"self",
".",
"widget",
".",
"devicePixelRatio",
"(",
")",
"self",
".",
"height",
"=",
"height",
"//",
"self",
"."... | Replacement for Qt's resizeGL method. | [
"Replacement",
"for",
"Qt",
"s",
"resizeGL",
"method",
"."
] | a8f5dce8dc72ae84a2f9523887fb5f6b620049b9 | https://github.com/moderngl/moderngl/blob/a8f5dce8dc72ae84a2f9523887fb5f6b620049b9/examples/window/pyqt5/window.py#L109-L122 |
225,538 | moderngl/moderngl | examples/window/pyqt5/window.py | Window.key_pressed_event | def key_pressed_event(self, event):
"""
Process Qt key press events forwarding them to the example
"""
if event.key() == self.keys.ESCAPE:
self.close()
self.example.key_event(event.key(), self.keys.ACTION_PRESS) | python | def key_pressed_event(self, event):
"""
Process Qt key press events forwarding them to the example
"""
if event.key() == self.keys.ESCAPE:
self.close()
self.example.key_event(event.key(), self.keys.ACTION_PRESS) | [
"def",
"key_pressed_event",
"(",
"self",
",",
"event",
")",
":",
"if",
"event",
".",
"key",
"(",
")",
"==",
"self",
".",
"keys",
".",
"ESCAPE",
":",
"self",
".",
"close",
"(",
")",
"self",
".",
"example",
".",
"key_event",
"(",
"event",
".",
"key",... | Process Qt key press events forwarding them to the example | [
"Process",
"Qt",
"key",
"press",
"events",
"forwarding",
"them",
"to",
"the",
"example"
] | a8f5dce8dc72ae84a2f9523887fb5f6b620049b9 | https://github.com/moderngl/moderngl/blob/a8f5dce8dc72ae84a2f9523887fb5f6b620049b9/examples/window/pyqt5/window.py#L124-L131 |
225,539 | moderngl/moderngl | examples/window/pyqt5/window.py | Window.key_release_event | def key_release_event(self, event):
"""
Process Qt key release events forwarding them to the example
"""
self.example.key_event(event.key(), self.keys.ACTION_RELEASE) | python | def key_release_event(self, event):
"""
Process Qt key release events forwarding them to the example
"""
self.example.key_event(event.key(), self.keys.ACTION_RELEASE) | [
"def",
"key_release_event",
"(",
"self",
",",
"event",
")",
":",
"self",
".",
"example",
".",
"key_event",
"(",
"event",
".",
"key",
"(",
")",
",",
"self",
".",
"keys",
".",
"ACTION_RELEASE",
")"
] | Process Qt key release events forwarding them to the example | [
"Process",
"Qt",
"key",
"release",
"events",
"forwarding",
"them",
"to",
"the",
"example"
] | a8f5dce8dc72ae84a2f9523887fb5f6b620049b9 | https://github.com/moderngl/moderngl/blob/a8f5dce8dc72ae84a2f9523887fb5f6b620049b9/examples/window/pyqt5/window.py#L133-L137 |
225,540 | moderngl/moderngl | examples/window/pyqt5/window.py | Window.mouse_move_event | def mouse_move_event(self, event):
"""
Forward mouse cursor position events to the example
"""
self.example.mouse_position_event(event.x(), event.y()) | python | def mouse_move_event(self, event):
"""
Forward mouse cursor position events to the example
"""
self.example.mouse_position_event(event.x(), event.y()) | [
"def",
"mouse_move_event",
"(",
"self",
",",
"event",
")",
":",
"self",
".",
"example",
".",
"mouse_position_event",
"(",
"event",
".",
"x",
"(",
")",
",",
"event",
".",
"y",
"(",
")",
")"
] | Forward mouse cursor position events to the example | [
"Forward",
"mouse",
"cursor",
"position",
"events",
"to",
"the",
"example"
] | a8f5dce8dc72ae84a2f9523887fb5f6b620049b9 | https://github.com/moderngl/moderngl/blob/a8f5dce8dc72ae84a2f9523887fb5f6b620049b9/examples/window/pyqt5/window.py#L139-L143 |
225,541 | moderngl/moderngl | examples/window/pyqt5/window.py | Window.mouse_press_event | def mouse_press_event(self, event):
"""
Forward mouse press events to the example
"""
# Support left and right mouse button for now
if event.button() not in [1, 2]:
return
self.example.mouse_press_event(event.x(), event.y(), event.button()) | python | def mouse_press_event(self, event):
"""
Forward mouse press events to the example
"""
# Support left and right mouse button for now
if event.button() not in [1, 2]:
return
self.example.mouse_press_event(event.x(), event.y(), event.button()) | [
"def",
"mouse_press_event",
"(",
"self",
",",
"event",
")",
":",
"# Support left and right mouse button for now\r",
"if",
"event",
".",
"button",
"(",
")",
"not",
"in",
"[",
"1",
",",
"2",
"]",
":",
"return",
"self",
".",
"example",
".",
"mouse_press_event",
... | Forward mouse press events to the example | [
"Forward",
"mouse",
"press",
"events",
"to",
"the",
"example"
] | a8f5dce8dc72ae84a2f9523887fb5f6b620049b9 | https://github.com/moderngl/moderngl/blob/a8f5dce8dc72ae84a2f9523887fb5f6b620049b9/examples/window/pyqt5/window.py#L145-L153 |
225,542 | moderngl/moderngl | examples/window/pyqt5/window.py | Window.mouse_release_event | def mouse_release_event(self, event):
"""
Forward mouse release events to the example
"""
# Support left and right mouse button for now
if event.button() not in [1, 2]:
return
self.example.mouse_release_event(event.x(), event.y(), event.button()) | python | def mouse_release_event(self, event):
"""
Forward mouse release events to the example
"""
# Support left and right mouse button for now
if event.button() not in [1, 2]:
return
self.example.mouse_release_event(event.x(), event.y(), event.button()) | [
"def",
"mouse_release_event",
"(",
"self",
",",
"event",
")",
":",
"# Support left and right mouse button for now\r",
"if",
"event",
".",
"button",
"(",
")",
"not",
"in",
"[",
"1",
",",
"2",
"]",
":",
"return",
"self",
".",
"example",
".",
"mouse_release_event... | Forward mouse release events to the example | [
"Forward",
"mouse",
"release",
"events",
"to",
"the",
"example"
] | a8f5dce8dc72ae84a2f9523887fb5f6b620049b9 | https://github.com/moderngl/moderngl/blob/a8f5dce8dc72ae84a2f9523887fb5f6b620049b9/examples/window/pyqt5/window.py#L155-L163 |
225,543 | moderngl/moderngl | moderngl/framebuffer.py | Framebuffer.read | def read(self, viewport=None, components=3, *, attachment=0, alignment=1, dtype='f1') -> bytes:
'''
Read the content of the framebuffer.
Args:
viewport (tuple): The viewport.
components (int): The number of components to read.
Keyword Args:
attachment (int): The color attachment.
alignment (int): The byte alignment of the pixels.
dtype (str): Data type.
Returns:
bytes
'''
return self.mglo.read(viewport, components, attachment, alignment, dtype) | python | def read(self, viewport=None, components=3, *, attachment=0, alignment=1, dtype='f1') -> bytes:
'''
Read the content of the framebuffer.
Args:
viewport (tuple): The viewport.
components (int): The number of components to read.
Keyword Args:
attachment (int): The color attachment.
alignment (int): The byte alignment of the pixels.
dtype (str): Data type.
Returns:
bytes
'''
return self.mglo.read(viewport, components, attachment, alignment, dtype) | [
"def",
"read",
"(",
"self",
",",
"viewport",
"=",
"None",
",",
"components",
"=",
"3",
",",
"*",
",",
"attachment",
"=",
"0",
",",
"alignment",
"=",
"1",
",",
"dtype",
"=",
"'f1'",
")",
"->",
"bytes",
":",
"return",
"self",
".",
"mglo",
".",
"rea... | Read the content of the framebuffer.
Args:
viewport (tuple): The viewport.
components (int): The number of components to read.
Keyword Args:
attachment (int): The color attachment.
alignment (int): The byte alignment of the pixels.
dtype (str): Data type.
Returns:
bytes | [
"Read",
"the",
"content",
"of",
"the",
"framebuffer",
"."
] | a8f5dce8dc72ae84a2f9523887fb5f6b620049b9 | https://github.com/moderngl/moderngl/blob/a8f5dce8dc72ae84a2f9523887fb5f6b620049b9/moderngl/framebuffer.py#L174-L191 |
225,544 | moderngl/moderngl | moderngl/framebuffer.py | Framebuffer.read_into | def read_into(self, buffer, viewport=None, components=3, *,
attachment=0, alignment=1, dtype='f1', write_offset=0) -> None:
'''
Read the content of the framebuffer into a buffer.
Args:
buffer (bytearray): The buffer that will receive the pixels.
viewport (tuple): The viewport.
components (int): The number of components to read.
Keyword Args:
attachment (int): The color attachment.
alignment (int): The byte alignment of the pixels.
dtype (str): Data type.
write_offset (int): The write offset.
'''
if type(buffer) is Buffer:
buffer = buffer.mglo
return self.mglo.read_into(buffer, viewport, components, attachment, alignment, dtype, write_offset) | python | def read_into(self, buffer, viewport=None, components=3, *,
attachment=0, alignment=1, dtype='f1', write_offset=0) -> None:
'''
Read the content of the framebuffer into a buffer.
Args:
buffer (bytearray): The buffer that will receive the pixels.
viewport (tuple): The viewport.
components (int): The number of components to read.
Keyword Args:
attachment (int): The color attachment.
alignment (int): The byte alignment of the pixels.
dtype (str): Data type.
write_offset (int): The write offset.
'''
if type(buffer) is Buffer:
buffer = buffer.mglo
return self.mglo.read_into(buffer, viewport, components, attachment, alignment, dtype, write_offset) | [
"def",
"read_into",
"(",
"self",
",",
"buffer",
",",
"viewport",
"=",
"None",
",",
"components",
"=",
"3",
",",
"*",
",",
"attachment",
"=",
"0",
",",
"alignment",
"=",
"1",
",",
"dtype",
"=",
"'f1'",
",",
"write_offset",
"=",
"0",
")",
"->",
"None... | Read the content of the framebuffer into a buffer.
Args:
buffer (bytearray): The buffer that will receive the pixels.
viewport (tuple): The viewport.
components (int): The number of components to read.
Keyword Args:
attachment (int): The color attachment.
alignment (int): The byte alignment of the pixels.
dtype (str): Data type.
write_offset (int): The write offset. | [
"Read",
"the",
"content",
"of",
"the",
"framebuffer",
"into",
"a",
"buffer",
"."
] | a8f5dce8dc72ae84a2f9523887fb5f6b620049b9 | https://github.com/moderngl/moderngl/blob/a8f5dce8dc72ae84a2f9523887fb5f6b620049b9/moderngl/framebuffer.py#L193-L213 |
225,545 | moderngl/moderngl | examples/window/base.py | BaseWindow.resize | def resize(self, width, height):
"""
Should be called every time window is resized
so the example can adapt to the new size if needed
"""
if self.example:
self.example.resize(width, height) | python | def resize(self, width, height):
"""
Should be called every time window is resized
so the example can adapt to the new size if needed
"""
if self.example:
self.example.resize(width, height) | [
"def",
"resize",
"(",
"self",
",",
"width",
",",
"height",
")",
":",
"if",
"self",
".",
"example",
":",
"self",
".",
"example",
".",
"resize",
"(",
"width",
",",
"height",
")"
] | Should be called every time window is resized
so the example can adapt to the new size if needed | [
"Should",
"be",
"called",
"every",
"time",
"window",
"is",
"resized",
"so",
"the",
"example",
"can",
"adapt",
"to",
"the",
"new",
"size",
"if",
"needed"
] | a8f5dce8dc72ae84a2f9523887fb5f6b620049b9 | https://github.com/moderngl/moderngl/blob/a8f5dce8dc72ae84a2f9523887fb5f6b620049b9/examples/window/base.py#L136-L142 |
225,546 | moderngl/moderngl | examples/window/base.py | BaseWindow.set_default_viewport | def set_default_viewport(self):
"""
Calculates the viewport based on the configured aspect ratio.
Will add black borders and center the viewport if the window
do not match the configured viewport.
If aspect ratio is None the viewport will be scaled
to the entire window size regardless of size.
"""
if self.aspect_ratio:
expected_width = int(self.buffer_height * self.aspect_ratio)
expected_height = int(expected_width / self.aspect_ratio)
if expected_width > self.buffer_width:
expected_width = self.buffer_width
expected_height = int(expected_width / self.aspect_ratio)
blank_space_x = self.buffer_width - expected_width
blank_space_y = self.buffer_height - expected_height
self.ctx.viewport = (
blank_space_x // 2,
blank_space_y // 2,
expected_width,
expected_height,
)
else:
self.ctx.viewport = (0, 0, self.buffer_width, self.buffer_height) | python | def set_default_viewport(self):
"""
Calculates the viewport based on the configured aspect ratio.
Will add black borders and center the viewport if the window
do not match the configured viewport.
If aspect ratio is None the viewport will be scaled
to the entire window size regardless of size.
"""
if self.aspect_ratio:
expected_width = int(self.buffer_height * self.aspect_ratio)
expected_height = int(expected_width / self.aspect_ratio)
if expected_width > self.buffer_width:
expected_width = self.buffer_width
expected_height = int(expected_width / self.aspect_ratio)
blank_space_x = self.buffer_width - expected_width
blank_space_y = self.buffer_height - expected_height
self.ctx.viewport = (
blank_space_x // 2,
blank_space_y // 2,
expected_width,
expected_height,
)
else:
self.ctx.viewport = (0, 0, self.buffer_width, self.buffer_height) | [
"def",
"set_default_viewport",
"(",
"self",
")",
":",
"if",
"self",
".",
"aspect_ratio",
":",
"expected_width",
"=",
"int",
"(",
"self",
".",
"buffer_height",
"*",
"self",
".",
"aspect_ratio",
")",
"expected_height",
"=",
"int",
"(",
"expected_width",
"/",
"... | Calculates the viewport based on the configured aspect ratio.
Will add black borders and center the viewport if the window
do not match the configured viewport.
If aspect ratio is None the viewport will be scaled
to the entire window size regardless of size. | [
"Calculates",
"the",
"viewport",
"based",
"on",
"the",
"configured",
"aspect",
"ratio",
".",
"Will",
"add",
"black",
"borders",
"and",
"center",
"the",
"viewport",
"if",
"the",
"window",
"do",
"not",
"match",
"the",
"configured",
"viewport",
".",
"If",
"aspe... | a8f5dce8dc72ae84a2f9523887fb5f6b620049b9 | https://github.com/moderngl/moderngl/blob/a8f5dce8dc72ae84a2f9523887fb5f6b620049b9/examples/window/base.py#L150-L177 |
225,547 | moderngl/moderngl | examples/window/base.py | BaseWindow.print_context_info | def print_context_info(self):
"""
Prints moderngl context info.
"""
print("Context Version:")
print('ModernGL:', moderngl.__version__)
print('vendor:', self.ctx.info['GL_VENDOR'])
print('renderer:', self.ctx.info['GL_RENDERER'])
print('version:', self.ctx.info['GL_VERSION'])
print('python:', sys.version)
print('platform:', sys.platform)
print('code:', self.ctx.version_code) | python | def print_context_info(self):
"""
Prints moderngl context info.
"""
print("Context Version:")
print('ModernGL:', moderngl.__version__)
print('vendor:', self.ctx.info['GL_VENDOR'])
print('renderer:', self.ctx.info['GL_RENDERER'])
print('version:', self.ctx.info['GL_VERSION'])
print('python:', sys.version)
print('platform:', sys.platform)
print('code:', self.ctx.version_code) | [
"def",
"print_context_info",
"(",
"self",
")",
":",
"print",
"(",
"\"Context Version:\"",
")",
"print",
"(",
"'ModernGL:'",
",",
"moderngl",
".",
"__version__",
")",
"print",
"(",
"'vendor:'",
",",
"self",
".",
"ctx",
".",
"info",
"[",
"'GL_VENDOR'",
"]",
... | Prints moderngl context info. | [
"Prints",
"moderngl",
"context",
"info",
"."
] | a8f5dce8dc72ae84a2f9523887fb5f6b620049b9 | https://github.com/moderngl/moderngl/blob/a8f5dce8dc72ae84a2f9523887fb5f6b620049b9/examples/window/base.py#L187-L198 |
225,548 | moderngl/moderngl | moderngl/texture.py | Texture.read | def read(self, *, level=0, alignment=1) -> bytes:
'''
Read the content of the texture into a buffer.
Keyword Args:
level (int): The mipmap level.
alignment (int): The byte alignment of the pixels.
Returns:
bytes
'''
return self.mglo.read(level, alignment) | python | def read(self, *, level=0, alignment=1) -> bytes:
'''
Read the content of the texture into a buffer.
Keyword Args:
level (int): The mipmap level.
alignment (int): The byte alignment of the pixels.
Returns:
bytes
'''
return self.mglo.read(level, alignment) | [
"def",
"read",
"(",
"self",
",",
"*",
",",
"level",
"=",
"0",
",",
"alignment",
"=",
"1",
")",
"->",
"bytes",
":",
"return",
"self",
".",
"mglo",
".",
"read",
"(",
"level",
",",
"alignment",
")"
] | Read the content of the texture into a buffer.
Keyword Args:
level (int): The mipmap level.
alignment (int): The byte alignment of the pixels.
Returns:
bytes | [
"Read",
"the",
"content",
"of",
"the",
"texture",
"into",
"a",
"buffer",
"."
] | a8f5dce8dc72ae84a2f9523887fb5f6b620049b9 | https://github.com/moderngl/moderngl/blob/a8f5dce8dc72ae84a2f9523887fb5f6b620049b9/moderngl/texture.py#L270-L282 |
225,549 | moderngl/moderngl | examples/window/__init__.py | parse_args | def parse_args(args=None):
"""Parse arguments from sys.argv"""
parser = argparse.ArgumentParser()
parser.add_argument(
'-w', '--window',
default="pyqt5",
choices=find_window_classes(),
help='Name for the window type to use',
)
parser.add_argument(
'-fs', '--fullscreen',
action="store_true",
help='Open the window in fullscreen mode',
)
parser.add_argument(
'-vs', '--vsync',
type=str2bool,
default="1",
help="Enable or disable vsync",
)
parser.add_argument(
'-s', '--samples',
type=int,
default=4,
help="Specify the desired number of samples to use for multisampling",
)
parser.add_argument(
'-c', '--cursor',
type=str2bool,
default="true",
help="Enable or disable displaying the mouse cursor",
)
return parser.parse_args(args or sys.argv[1:]) | python | def parse_args(args=None):
"""Parse arguments from sys.argv"""
parser = argparse.ArgumentParser()
parser.add_argument(
'-w', '--window',
default="pyqt5",
choices=find_window_classes(),
help='Name for the window type to use',
)
parser.add_argument(
'-fs', '--fullscreen',
action="store_true",
help='Open the window in fullscreen mode',
)
parser.add_argument(
'-vs', '--vsync',
type=str2bool,
default="1",
help="Enable or disable vsync",
)
parser.add_argument(
'-s', '--samples',
type=int,
default=4,
help="Specify the desired number of samples to use for multisampling",
)
parser.add_argument(
'-c', '--cursor',
type=str2bool,
default="true",
help="Enable or disable displaying the mouse cursor",
)
return parser.parse_args(args or sys.argv[1:]) | [
"def",
"parse_args",
"(",
"args",
"=",
"None",
")",
":",
"parser",
"=",
"argparse",
".",
"ArgumentParser",
"(",
")",
"parser",
".",
"add_argument",
"(",
"'-w'",
",",
"'--window'",
",",
"default",
"=",
"\"pyqt5\"",
",",
"choices",
"=",
"find_window_classes",
... | Parse arguments from sys.argv | [
"Parse",
"arguments",
"from",
"sys",
".",
"argv"
] | a8f5dce8dc72ae84a2f9523887fb5f6b620049b9 | https://github.com/moderngl/moderngl/blob/a8f5dce8dc72ae84a2f9523887fb5f6b620049b9/examples/window/__init__.py#L65-L99 |
225,550 | moderngl/moderngl | moderngl/compute_shader.py | ComputeShader.run | def run(self, group_x=1, group_y=1, group_z=1) -> None:
'''
Run the compute shader.
Args:
group_x (int): The number of work groups to be launched in the X dimension.
group_y (int): The number of work groups to be launched in the Y dimension.
group_z (int): The number of work groups to be launched in the Z dimension.
'''
return self.mglo.run(group_x, group_y, group_z) | python | def run(self, group_x=1, group_y=1, group_z=1) -> None:
'''
Run the compute shader.
Args:
group_x (int): The number of work groups to be launched in the X dimension.
group_y (int): The number of work groups to be launched in the Y dimension.
group_z (int): The number of work groups to be launched in the Z dimension.
'''
return self.mglo.run(group_x, group_y, group_z) | [
"def",
"run",
"(",
"self",
",",
"group_x",
"=",
"1",
",",
"group_y",
"=",
"1",
",",
"group_z",
"=",
"1",
")",
"->",
"None",
":",
"return",
"self",
".",
"mglo",
".",
"run",
"(",
"group_x",
",",
"group_y",
",",
"group_z",
")"
] | Run the compute shader.
Args:
group_x (int): The number of work groups to be launched in the X dimension.
group_y (int): The number of work groups to be launched in the Y dimension.
group_z (int): The number of work groups to be launched in the Z dimension. | [
"Run",
"the",
"compute",
"shader",
"."
] | a8f5dce8dc72ae84a2f9523887fb5f6b620049b9 | https://github.com/moderngl/moderngl/blob/a8f5dce8dc72ae84a2f9523887fb5f6b620049b9/moderngl/compute_shader.py#L54-L64 |
225,551 | moderngl/moderngl | moderngl/compute_shader.py | ComputeShader.get | def get(self, key, default) -> Union[Uniform, UniformBlock, Subroutine, Attribute, Varying]:
'''
Returns a Uniform, UniformBlock, Subroutine, Attribute or Varying.
Args:
default: This is the value to be returned in case key does not exist.
Returns:
:py:class:`Uniform`, :py:class:`UniformBlock`, :py:class:`Subroutine`,
:py:class:`Attribute` or :py:class:`Varying`
'''
return self._members.get(key, default) | python | def get(self, key, default) -> Union[Uniform, UniformBlock, Subroutine, Attribute, Varying]:
'''
Returns a Uniform, UniformBlock, Subroutine, Attribute or Varying.
Args:
default: This is the value to be returned in case key does not exist.
Returns:
:py:class:`Uniform`, :py:class:`UniformBlock`, :py:class:`Subroutine`,
:py:class:`Attribute` or :py:class:`Varying`
'''
return self._members.get(key, default) | [
"def",
"get",
"(",
"self",
",",
"key",
",",
"default",
")",
"->",
"Union",
"[",
"Uniform",
",",
"UniformBlock",
",",
"Subroutine",
",",
"Attribute",
",",
"Varying",
"]",
":",
"return",
"self",
".",
"_members",
".",
"get",
"(",
"key",
",",
"default",
... | Returns a Uniform, UniformBlock, Subroutine, Attribute or Varying.
Args:
default: This is the value to be returned in case key does not exist.
Returns:
:py:class:`Uniform`, :py:class:`UniformBlock`, :py:class:`Subroutine`,
:py:class:`Attribute` or :py:class:`Varying` | [
"Returns",
"a",
"Uniform",
"UniformBlock",
"Subroutine",
"Attribute",
"or",
"Varying",
"."
] | a8f5dce8dc72ae84a2f9523887fb5f6b620049b9 | https://github.com/moderngl/moderngl/blob/a8f5dce8dc72ae84a2f9523887fb5f6b620049b9/moderngl/compute_shader.py#L66-L78 |
225,552 | moderngl/moderngl | examples/window/sdl2/window.py | Window.resize | def resize(self, width, height):
"""
Sets the new size and buffer size internally
"""
self.width = width
self.height = height
self.buffer_width, self.buffer_height = self.width, self.height
self.set_default_viewport()
super().resize(self.buffer_width, self.buffer_height) | python | def resize(self, width, height):
"""
Sets the new size and buffer size internally
"""
self.width = width
self.height = height
self.buffer_width, self.buffer_height = self.width, self.height
self.set_default_viewport()
super().resize(self.buffer_width, self.buffer_height) | [
"def",
"resize",
"(",
"self",
",",
"width",
",",
"height",
")",
":",
"self",
".",
"width",
"=",
"width",
"self",
".",
"height",
"=",
"height",
"self",
".",
"buffer_width",
",",
"self",
".",
"buffer_height",
"=",
"self",
".",
"width",
",",
"self",
"."... | Sets the new size and buffer size internally | [
"Sets",
"the",
"new",
"size",
"and",
"buffer",
"size",
"internally"
] | a8f5dce8dc72ae84a2f9523887fb5f6b620049b9 | https://github.com/moderngl/moderngl/blob/a8f5dce8dc72ae84a2f9523887fb5f6b620049b9/examples/window/sdl2/window.py#L76-L85 |
225,553 | moderngl/moderngl | examples/window/sdl2/window.py | Window.process_events | def process_events(self):
"""
Loop through and handle all the queued events.
"""
for event in sdl2.ext.get_events():
if event.type == sdl2.SDL_MOUSEMOTION:
self.example.mouse_position_event(event.motion.x, event.motion.y)
elif event.type == sdl2.SDL_MOUSEBUTTONUP:
# Support left and right mouse button for now
if event.button.button in [1, 3]:
self.example.mouse_press_event(
event.motion.x, event.motion.y,
1 if event.button.button == 1 else 2,
)
elif event.type == sdl2.SDL_MOUSEBUTTONDOWN:
# Support left and right mouse button for now
if event.button.button in [1, 3]:
self.example.mouse_release_event(
event.motion.x, event.motion.y,
1 if event.button.button == 1 else 2,
)
elif event.type in [sdl2.SDL_KEYDOWN, sdl2.SDL_KEYUP]:
if event.key.keysym.sym == sdl2.SDLK_ESCAPE:
self.close()
self.example.key_event(event.key.keysym.sym, event.type)
elif event.type == sdl2.SDL_QUIT:
self.close()
elif event.type == sdl2.SDL_WINDOWEVENT:
if event.window.event == sdl2.SDL_WINDOWEVENT_RESIZED:
self.resize(event.window.data1, event.window.data2) | python | def process_events(self):
"""
Loop through and handle all the queued events.
"""
for event in sdl2.ext.get_events():
if event.type == sdl2.SDL_MOUSEMOTION:
self.example.mouse_position_event(event.motion.x, event.motion.y)
elif event.type == sdl2.SDL_MOUSEBUTTONUP:
# Support left and right mouse button for now
if event.button.button in [1, 3]:
self.example.mouse_press_event(
event.motion.x, event.motion.y,
1 if event.button.button == 1 else 2,
)
elif event.type == sdl2.SDL_MOUSEBUTTONDOWN:
# Support left and right mouse button for now
if event.button.button in [1, 3]:
self.example.mouse_release_event(
event.motion.x, event.motion.y,
1 if event.button.button == 1 else 2,
)
elif event.type in [sdl2.SDL_KEYDOWN, sdl2.SDL_KEYUP]:
if event.key.keysym.sym == sdl2.SDLK_ESCAPE:
self.close()
self.example.key_event(event.key.keysym.sym, event.type)
elif event.type == sdl2.SDL_QUIT:
self.close()
elif event.type == sdl2.SDL_WINDOWEVENT:
if event.window.event == sdl2.SDL_WINDOWEVENT_RESIZED:
self.resize(event.window.data1, event.window.data2) | [
"def",
"process_events",
"(",
"self",
")",
":",
"for",
"event",
"in",
"sdl2",
".",
"ext",
".",
"get_events",
"(",
")",
":",
"if",
"event",
".",
"type",
"==",
"sdl2",
".",
"SDL_MOUSEMOTION",
":",
"self",
".",
"example",
".",
"mouse_position_event",
"(",
... | Loop through and handle all the queued events. | [
"Loop",
"through",
"and",
"handle",
"all",
"the",
"queued",
"events",
"."
] | a8f5dce8dc72ae84a2f9523887fb5f6b620049b9 | https://github.com/moderngl/moderngl/blob/a8f5dce8dc72ae84a2f9523887fb5f6b620049b9/examples/window/sdl2/window.py#L87-L122 |
225,554 | moderngl/moderngl | examples/window/sdl2/window.py | Window.destroy | def destroy(self):
"""
Gracefully close the window
"""
sdl2.SDL_GL_DeleteContext(self.context)
sdl2.SDL_DestroyWindow(self.window)
sdl2.SDL_Quit() | python | def destroy(self):
"""
Gracefully close the window
"""
sdl2.SDL_GL_DeleteContext(self.context)
sdl2.SDL_DestroyWindow(self.window)
sdl2.SDL_Quit() | [
"def",
"destroy",
"(",
"self",
")",
":",
"sdl2",
".",
"SDL_GL_DeleteContext",
"(",
"self",
".",
"context",
")",
"sdl2",
".",
"SDL_DestroyWindow",
"(",
"self",
".",
"window",
")",
"sdl2",
".",
"SDL_Quit",
"(",
")"
] | Gracefully close the window | [
"Gracefully",
"close",
"the",
"window"
] | a8f5dce8dc72ae84a2f9523887fb5f6b620049b9 | https://github.com/moderngl/moderngl/blob/a8f5dce8dc72ae84a2f9523887fb5f6b620049b9/examples/window/sdl2/window.py#L124-L130 |
225,555 | moderngl/moderngl | examples/window/pyglet/window.py | Window.on_key_press | def on_key_press(self, symbol, modifiers):
"""
Pyglet specific key press callback.
Forwards and translates the events to the example
"""
self.example.key_event(symbol, self.keys.ACTION_PRESS) | python | def on_key_press(self, symbol, modifiers):
"""
Pyglet specific key press callback.
Forwards and translates the events to the example
"""
self.example.key_event(symbol, self.keys.ACTION_PRESS) | [
"def",
"on_key_press",
"(",
"self",
",",
"symbol",
",",
"modifiers",
")",
":",
"self",
".",
"example",
".",
"key_event",
"(",
"symbol",
",",
"self",
".",
"keys",
".",
"ACTION_PRESS",
")"
] | Pyglet specific key press callback.
Forwards and translates the events to the example | [
"Pyglet",
"specific",
"key",
"press",
"callback",
".",
"Forwards",
"and",
"translates",
"the",
"events",
"to",
"the",
"example"
] | a8f5dce8dc72ae84a2f9523887fb5f6b620049b9 | https://github.com/moderngl/moderngl/blob/a8f5dce8dc72ae84a2f9523887fb5f6b620049b9/examples/window/pyglet/window.py#L96-L101 |
225,556 | moderngl/moderngl | examples/window/pyglet/window.py | Window.on_key_release | def on_key_release(self, symbol, modifiers):
"""
Pyglet specific key release callback.
Forwards and translates the events to the example
"""
self.example.key_event(symbol, self.keys.ACTION_RELEASE) | python | def on_key_release(self, symbol, modifiers):
"""
Pyglet specific key release callback.
Forwards and translates the events to the example
"""
self.example.key_event(symbol, self.keys.ACTION_RELEASE) | [
"def",
"on_key_release",
"(",
"self",
",",
"symbol",
",",
"modifiers",
")",
":",
"self",
".",
"example",
".",
"key_event",
"(",
"symbol",
",",
"self",
".",
"keys",
".",
"ACTION_RELEASE",
")"
] | Pyglet specific key release callback.
Forwards and translates the events to the example | [
"Pyglet",
"specific",
"key",
"release",
"callback",
".",
"Forwards",
"and",
"translates",
"the",
"events",
"to",
"the",
"example"
] | a8f5dce8dc72ae84a2f9523887fb5f6b620049b9 | https://github.com/moderngl/moderngl/blob/a8f5dce8dc72ae84a2f9523887fb5f6b620049b9/examples/window/pyglet/window.py#L103-L108 |
225,557 | moderngl/moderngl | examples/window/pyglet/window.py | Window.on_mouse_motion | def on_mouse_motion(self, x, y, dx, dy):
"""
Pyglet specific mouse motion callback.
Forwards and traslates the event to the example
"""
# Screen coordinates relative to the lower-left corner
# so we have to flip the y axis to make this consistent with
# other window libraries
self.example.mouse_position_event(x, self.buffer_height - y) | python | def on_mouse_motion(self, x, y, dx, dy):
"""
Pyglet specific mouse motion callback.
Forwards and traslates the event to the example
"""
# Screen coordinates relative to the lower-left corner
# so we have to flip the y axis to make this consistent with
# other window libraries
self.example.mouse_position_event(x, self.buffer_height - y) | [
"def",
"on_mouse_motion",
"(",
"self",
",",
"x",
",",
"y",
",",
"dx",
",",
"dy",
")",
":",
"# Screen coordinates relative to the lower-left corner\r",
"# so we have to flip the y axis to make this consistent with\r",
"# other window libraries\r",
"self",
".",
"example",
".",
... | Pyglet specific mouse motion callback.
Forwards and traslates the event to the example | [
"Pyglet",
"specific",
"mouse",
"motion",
"callback",
".",
"Forwards",
"and",
"traslates",
"the",
"event",
"to",
"the",
"example"
] | a8f5dce8dc72ae84a2f9523887fb5f6b620049b9 | https://github.com/moderngl/moderngl/blob/a8f5dce8dc72ae84a2f9523887fb5f6b620049b9/examples/window/pyglet/window.py#L110-L118 |
225,558 | moderngl/moderngl | examples/window/pyglet/window.py | Window.on_mouse_press | def on_mouse_press(self, x: int, y: int, button, mods):
"""
Handle mouse press events and forward to example window
"""
if button in [1, 4]:
self.example.mouse_press_event(
x, self.buffer_height - y,
1 if button == 1 else 2,
) | python | def on_mouse_press(self, x: int, y: int, button, mods):
"""
Handle mouse press events and forward to example window
"""
if button in [1, 4]:
self.example.mouse_press_event(
x, self.buffer_height - y,
1 if button == 1 else 2,
) | [
"def",
"on_mouse_press",
"(",
"self",
",",
"x",
":",
"int",
",",
"y",
":",
"int",
",",
"button",
",",
"mods",
")",
":",
"if",
"button",
"in",
"[",
"1",
",",
"4",
"]",
":",
"self",
".",
"example",
".",
"mouse_press_event",
"(",
"x",
",",
"self",
... | Handle mouse press events and forward to example window | [
"Handle",
"mouse",
"press",
"events",
"and",
"forward",
"to",
"example",
"window"
] | a8f5dce8dc72ae84a2f9523887fb5f6b620049b9 | https://github.com/moderngl/moderngl/blob/a8f5dce8dc72ae84a2f9523887fb5f6b620049b9/examples/window/pyglet/window.py#L120-L128 |
225,559 | moderngl/moderngl | examples/window/pyglet/window.py | Window.on_mouse_release | def on_mouse_release(self, x: int, y: int, button, mods):
"""
Handle mouse release events and forward to example window
"""
if button in [1, 4]:
self.example.mouse_release_event(
x, self.buffer_height - y,
1 if button == 1 else 2,
) | python | def on_mouse_release(self, x: int, y: int, button, mods):
"""
Handle mouse release events and forward to example window
"""
if button in [1, 4]:
self.example.mouse_release_event(
x, self.buffer_height - y,
1 if button == 1 else 2,
) | [
"def",
"on_mouse_release",
"(",
"self",
",",
"x",
":",
"int",
",",
"y",
":",
"int",
",",
"button",
",",
"mods",
")",
":",
"if",
"button",
"in",
"[",
"1",
",",
"4",
"]",
":",
"self",
".",
"example",
".",
"mouse_release_event",
"(",
"x",
",",
"self... | Handle mouse release events and forward to example window | [
"Handle",
"mouse",
"release",
"events",
"and",
"forward",
"to",
"example",
"window"
] | a8f5dce8dc72ae84a2f9523887fb5f6b620049b9 | https://github.com/moderngl/moderngl/blob/a8f5dce8dc72ae84a2f9523887fb5f6b620049b9/examples/window/pyglet/window.py#L130-L138 |
225,560 | moderngl/moderngl | moderngl/texture_cube.py | TextureCube.write | def write(self, face, data, viewport=None, *, alignment=1) -> None:
'''
Update the content of the texture.
Args:
face (int): The face to update.
data (bytes): The pixel data.
viewport (tuple): The viewport.
Keyword Args:
alignment (int): The byte alignment of the pixels.
'''
if type(data) is Buffer:
data = data.mglo
self.mglo.write(face, data, viewport, alignment) | python | def write(self, face, data, viewport=None, *, alignment=1) -> None:
'''
Update the content of the texture.
Args:
face (int): The face to update.
data (bytes): The pixel data.
viewport (tuple): The viewport.
Keyword Args:
alignment (int): The byte alignment of the pixels.
'''
if type(data) is Buffer:
data = data.mglo
self.mglo.write(face, data, viewport, alignment) | [
"def",
"write",
"(",
"self",
",",
"face",
",",
"data",
",",
"viewport",
"=",
"None",
",",
"*",
",",
"alignment",
"=",
"1",
")",
"->",
"None",
":",
"if",
"type",
"(",
"data",
")",
"is",
"Buffer",
":",
"data",
"=",
"data",
".",
"mglo",
"self",
".... | Update the content of the texture.
Args:
face (int): The face to update.
data (bytes): The pixel data.
viewport (tuple): The viewport.
Keyword Args:
alignment (int): The byte alignment of the pixels. | [
"Update",
"the",
"content",
"of",
"the",
"texture",
"."
] | a8f5dce8dc72ae84a2f9523887fb5f6b620049b9 | https://github.com/moderngl/moderngl/blob/a8f5dce8dc72ae84a2f9523887fb5f6b620049b9/moderngl/texture_cube.py#L170-L186 |
225,561 | moderngl/moderngl | examples/00_empty_window.py | EmptyWindow.key_event | def key_event(self, key, action):
"""
Handle key events in a generic way
supporting all window types.
"""
if action == self.wnd.keys.ACTION_PRESS:
if key == self.wnd.keys.SPACE:
print("Space was pressed")
if action == self.wnd.keys.ACTION_RELEASE:
if key == self.wnd.keys.SPACE:
print("Space was released") | python | def key_event(self, key, action):
"""
Handle key events in a generic way
supporting all window types.
"""
if action == self.wnd.keys.ACTION_PRESS:
if key == self.wnd.keys.SPACE:
print("Space was pressed")
if action == self.wnd.keys.ACTION_RELEASE:
if key == self.wnd.keys.SPACE:
print("Space was released") | [
"def",
"key_event",
"(",
"self",
",",
"key",
",",
"action",
")",
":",
"if",
"action",
"==",
"self",
".",
"wnd",
".",
"keys",
".",
"ACTION_PRESS",
":",
"if",
"key",
"==",
"self",
".",
"wnd",
".",
"keys",
".",
"SPACE",
":",
"print",
"(",
"\"Space was... | Handle key events in a generic way
supporting all window types. | [
"Handle",
"key",
"events",
"in",
"a",
"generic",
"way",
"supporting",
"all",
"window",
"types",
"."
] | a8f5dce8dc72ae84a2f9523887fb5f6b620049b9 | https://github.com/moderngl/moderngl/blob/a8f5dce8dc72ae84a2f9523887fb5f6b620049b9/examples/00_empty_window.py#L24-L35 |
225,562 | moderngl/moderngl | examples/00_empty_window.py | EmptyWindow.mouse_press_event | def mouse_press_event(self, x, y, button):
"""Reports left and right mouse button presses + position"""
if button == 1:
print("Left mouse button pressed @", x, y)
if button == 2:
print("Right mouse button pressed @", x, y) | python | def mouse_press_event(self, x, y, button):
"""Reports left and right mouse button presses + position"""
if button == 1:
print("Left mouse button pressed @", x, y)
if button == 2:
print("Right mouse button pressed @", x, y) | [
"def",
"mouse_press_event",
"(",
"self",
",",
"x",
",",
"y",
",",
"button",
")",
":",
"if",
"button",
"==",
"1",
":",
"print",
"(",
"\"Left mouse button pressed @\"",
",",
"x",
",",
"y",
")",
"if",
"button",
"==",
"2",
":",
"print",
"(",
"\"Right mouse... | Reports left and right mouse button presses + position | [
"Reports",
"left",
"and",
"right",
"mouse",
"button",
"presses",
"+",
"position"
] | a8f5dce8dc72ae84a2f9523887fb5f6b620049b9 | https://github.com/moderngl/moderngl/blob/a8f5dce8dc72ae84a2f9523887fb5f6b620049b9/examples/00_empty_window.py#L44-L49 |
225,563 | moderngl/moderngl | examples/00_empty_window.py | EmptyWindow.mouse_release_event | def mouse_release_event(self, x, y, button):
"""Reports left and right mouse button releases + position"""
if button == 1:
print("Left mouse button released @", x, y)
if button == 2:
print("Right mouse button released @", x, y) | python | def mouse_release_event(self, x, y, button):
"""Reports left and right mouse button releases + position"""
if button == 1:
print("Left mouse button released @", x, y)
if button == 2:
print("Right mouse button released @", x, y) | [
"def",
"mouse_release_event",
"(",
"self",
",",
"x",
",",
"y",
",",
"button",
")",
":",
"if",
"button",
"==",
"1",
":",
"print",
"(",
"\"Left mouse button released @\"",
",",
"x",
",",
"y",
")",
"if",
"button",
"==",
"2",
":",
"print",
"(",
"\"Right mo... | Reports left and right mouse button releases + position | [
"Reports",
"left",
"and",
"right",
"mouse",
"button",
"releases",
"+",
"position"
] | a8f5dce8dc72ae84a2f9523887fb5f6b620049b9 | https://github.com/moderngl/moderngl/blob/a8f5dce8dc72ae84a2f9523887fb5f6b620049b9/examples/00_empty_window.py#L51-L56 |
225,564 | moderngl/moderngl | moderngl/program.py | detect_format | def detect_format(program, attributes) -> str:
'''
Detect format for vertex attributes.
The format returned does not contain padding.
Args:
program (Program): The program.
attributes (list): A list of attribute names.
Returns:
str
'''
def fmt(attr):
'''
For internal use only.
'''
return attr.array_length * attr.dimension, attr.shape
return ' '.join('%d%s' % fmt(program[a]) for a in attributes) | python | def detect_format(program, attributes) -> str:
'''
Detect format for vertex attributes.
The format returned does not contain padding.
Args:
program (Program): The program.
attributes (list): A list of attribute names.
Returns:
str
'''
def fmt(attr):
'''
For internal use only.
'''
return attr.array_length * attr.dimension, attr.shape
return ' '.join('%d%s' % fmt(program[a]) for a in attributes) | [
"def",
"detect_format",
"(",
"program",
",",
"attributes",
")",
"->",
"str",
":",
"def",
"fmt",
"(",
"attr",
")",
":",
"'''\n For internal use only.\n '''",
"return",
"attr",
".",
"array_length",
"*",
"attr",
".",
"dimension",
",",
"attr",
".",... | Detect format for vertex attributes.
The format returned does not contain padding.
Args:
program (Program): The program.
attributes (list): A list of attribute names.
Returns:
str | [
"Detect",
"format",
"for",
"vertex",
"attributes",
".",
"The",
"format",
"returned",
"does",
"not",
"contain",
"padding",
"."
] | a8f5dce8dc72ae84a2f9523887fb5f6b620049b9 | https://github.com/moderngl/moderngl/blob/a8f5dce8dc72ae84a2f9523887fb5f6b620049b9/moderngl/program.py#L115-L135 |
225,565 | dswah/pyGAM | pygam/callbacks.py | validate_callback_data | def validate_callback_data(method):
"""
wraps a callback's method to pull the desired arguments from the vars dict
also checks to ensure the method's arguments are in the vars dict
Parameters
----------
method : callable
Returns
-------
validated callable
"""
@wraps(method)
def method_wrapper(*args, **kwargs):
"""
Parameters
----------
*args
**kwargs
Returns
-------
method's output
"""
expected = method.__code__.co_varnames
# rename curret gam object
if 'self' in kwargs:
gam = kwargs['self']
del(kwargs['self'])
kwargs['gam'] = gam
# loop once to check any missing
missing = []
for e in expected:
if e == 'self':
continue
if e not in kwargs:
missing.append(e)
assert len(missing) == 0, 'CallBack cannot reference: {}'.\
format(', '.join(missing))
# loop again to extract desired
kwargs_subset = {}
for e in expected:
if e == 'self':
continue
kwargs_subset[e] = kwargs[e]
return method(*args, **kwargs_subset)
return method_wrapper | python | def validate_callback_data(method):
"""
wraps a callback's method to pull the desired arguments from the vars dict
also checks to ensure the method's arguments are in the vars dict
Parameters
----------
method : callable
Returns
-------
validated callable
"""
@wraps(method)
def method_wrapper(*args, **kwargs):
"""
Parameters
----------
*args
**kwargs
Returns
-------
method's output
"""
expected = method.__code__.co_varnames
# rename curret gam object
if 'self' in kwargs:
gam = kwargs['self']
del(kwargs['self'])
kwargs['gam'] = gam
# loop once to check any missing
missing = []
for e in expected:
if e == 'self':
continue
if e not in kwargs:
missing.append(e)
assert len(missing) == 0, 'CallBack cannot reference: {}'.\
format(', '.join(missing))
# loop again to extract desired
kwargs_subset = {}
for e in expected:
if e == 'self':
continue
kwargs_subset[e] = kwargs[e]
return method(*args, **kwargs_subset)
return method_wrapper | [
"def",
"validate_callback_data",
"(",
"method",
")",
":",
"@",
"wraps",
"(",
"method",
")",
"def",
"method_wrapper",
"(",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
":",
"\"\"\"\n\n Parameters\n ----------\n *args\n **kwargs\n\n Returns\... | wraps a callback's method to pull the desired arguments from the vars dict
also checks to ensure the method's arguments are in the vars dict
Parameters
----------
method : callable
Returns
-------
validated callable | [
"wraps",
"a",
"callback",
"s",
"method",
"to",
"pull",
"the",
"desired",
"arguments",
"from",
"the",
"vars",
"dict",
"also",
"checks",
"to",
"ensure",
"the",
"method",
"s",
"arguments",
"are",
"in",
"the",
"vars",
"dict"
] | b3e5c3cd580f0a3ad69f9372861624f67760c325 | https://github.com/dswah/pyGAM/blob/b3e5c3cd580f0a3ad69f9372861624f67760c325/pygam/callbacks.py#L13-L66 |
225,566 | dswah/pyGAM | pygam/callbacks.py | validate_callback | def validate_callback(callback):
"""
validates a callback's on_loop_start and on_loop_end methods
Parameters
----------
callback : Callback object
Returns
-------
validated callback
"""
if not(hasattr(callback, '_validated')) or callback._validated == False:
assert hasattr(callback, 'on_loop_start') \
or hasattr(callback, 'on_loop_end'), \
'callback must have `on_loop_start` or `on_loop_end` method'
if hasattr(callback, 'on_loop_start'):
setattr(callback, 'on_loop_start',
validate_callback_data(callback.on_loop_start))
if hasattr(callback, 'on_loop_end'):
setattr(callback, 'on_loop_end',
validate_callback_data(callback.on_loop_end))
setattr(callback, '_validated', True)
return callback | python | def validate_callback(callback):
"""
validates a callback's on_loop_start and on_loop_end methods
Parameters
----------
callback : Callback object
Returns
-------
validated callback
"""
if not(hasattr(callback, '_validated')) or callback._validated == False:
assert hasattr(callback, 'on_loop_start') \
or hasattr(callback, 'on_loop_end'), \
'callback must have `on_loop_start` or `on_loop_end` method'
if hasattr(callback, 'on_loop_start'):
setattr(callback, 'on_loop_start',
validate_callback_data(callback.on_loop_start))
if hasattr(callback, 'on_loop_end'):
setattr(callback, 'on_loop_end',
validate_callback_data(callback.on_loop_end))
setattr(callback, '_validated', True)
return callback | [
"def",
"validate_callback",
"(",
"callback",
")",
":",
"if",
"not",
"(",
"hasattr",
"(",
"callback",
",",
"'_validated'",
")",
")",
"or",
"callback",
".",
"_validated",
"==",
"False",
":",
"assert",
"hasattr",
"(",
"callback",
",",
"'on_loop_start'",
")",
... | validates a callback's on_loop_start and on_loop_end methods
Parameters
----------
callback : Callback object
Returns
-------
validated callback | [
"validates",
"a",
"callback",
"s",
"on_loop_start",
"and",
"on_loop_end",
"methods"
] | b3e5c3cd580f0a3ad69f9372861624f67760c325 | https://github.com/dswah/pyGAM/blob/b3e5c3cd580f0a3ad69f9372861624f67760c325/pygam/callbacks.py#L68-L91 |
225,567 | dswah/pyGAM | pygam/distributions.py | Distribution.phi | def phi(self, y, mu, edof, weights):
"""
GLM scale parameter.
for Binomial and Poisson families this is unity
for Normal family this is variance
Parameters
----------
y : array-like of length n
target values
mu : array-like of length n
expected values
edof : float
estimated degrees of freedom
weights : array-like shape (n,) or None, default: None
sample weights
if None, defaults to array of ones
Returns
-------
scale : estimated model scale
"""
if self._known_scale:
return self.scale
else:
return (np.sum(weights * self.V(mu)**-1 * (y - mu)**2) /
(len(mu) - edof)) | python | def phi(self, y, mu, edof, weights):
"""
GLM scale parameter.
for Binomial and Poisson families this is unity
for Normal family this is variance
Parameters
----------
y : array-like of length n
target values
mu : array-like of length n
expected values
edof : float
estimated degrees of freedom
weights : array-like shape (n,) or None, default: None
sample weights
if None, defaults to array of ones
Returns
-------
scale : estimated model scale
"""
if self._known_scale:
return self.scale
else:
return (np.sum(weights * self.V(mu)**-1 * (y - mu)**2) /
(len(mu) - edof)) | [
"def",
"phi",
"(",
"self",
",",
"y",
",",
"mu",
",",
"edof",
",",
"weights",
")",
":",
"if",
"self",
".",
"_known_scale",
":",
"return",
"self",
".",
"scale",
"else",
":",
"return",
"(",
"np",
".",
"sum",
"(",
"weights",
"*",
"self",
".",
"V",
... | GLM scale parameter.
for Binomial and Poisson families this is unity
for Normal family this is variance
Parameters
----------
y : array-like of length n
target values
mu : array-like of length n
expected values
edof : float
estimated degrees of freedom
weights : array-like shape (n,) or None, default: None
sample weights
if None, defaults to array of ones
Returns
-------
scale : estimated model scale | [
"GLM",
"scale",
"parameter",
".",
"for",
"Binomial",
"and",
"Poisson",
"families",
"this",
"is",
"unity",
"for",
"Normal",
"family",
"this",
"is",
"variance"
] | b3e5c3cd580f0a3ad69f9372861624f67760c325 | https://github.com/dswah/pyGAM/blob/b3e5c3cd580f0a3ad69f9372861624f67760c325/pygam/distributions.py#L61-L87 |
225,568 | dswah/pyGAM | pygam/distributions.py | GammaDist.sample | def sample(self, mu):
"""
Return random samples from this Gamma distribution.
Parameters
----------
mu : array-like of shape n_samples or shape (n_simulations, n_samples)
expected values
Returns
-------
random_samples : np.array of same shape as mu
"""
# in numpy.random.gamma, `shape` is the parameter sometimes denoted by
# `k` that corresponds to `nu` in S. Wood (2006) Table 2.1
shape = 1. / self.scale
# in numpy.random.gamma, `scale` is the parameter sometimes denoted by
# `theta` that corresponds to mu / nu in S. Wood (2006) Table 2.1
scale = mu / shape
return np.random.gamma(shape=shape, scale=scale, size=None) | python | def sample(self, mu):
"""
Return random samples from this Gamma distribution.
Parameters
----------
mu : array-like of shape n_samples or shape (n_simulations, n_samples)
expected values
Returns
-------
random_samples : np.array of same shape as mu
"""
# in numpy.random.gamma, `shape` is the parameter sometimes denoted by
# `k` that corresponds to `nu` in S. Wood (2006) Table 2.1
shape = 1. / self.scale
# in numpy.random.gamma, `scale` is the parameter sometimes denoted by
# `theta` that corresponds to mu / nu in S. Wood (2006) Table 2.1
scale = mu / shape
return np.random.gamma(shape=shape, scale=scale, size=None) | [
"def",
"sample",
"(",
"self",
",",
"mu",
")",
":",
"# in numpy.random.gamma, `shape` is the parameter sometimes denoted by",
"# `k` that corresponds to `nu` in S. Wood (2006) Table 2.1",
"shape",
"=",
"1.",
"/",
"self",
".",
"scale",
"# in numpy.random.gamma, `scale` is the paramet... | Return random samples from this Gamma distribution.
Parameters
----------
mu : array-like of shape n_samples or shape (n_simulations, n_samples)
expected values
Returns
-------
random_samples : np.array of same shape as mu | [
"Return",
"random",
"samples",
"from",
"this",
"Gamma",
"distribution",
"."
] | b3e5c3cd580f0a3ad69f9372861624f67760c325 | https://github.com/dswah/pyGAM/blob/b3e5c3cd580f0a3ad69f9372861624f67760c325/pygam/distributions.py#L535-L554 |
225,569 | dswah/pyGAM | pygam/datasets/load_datasets.py | _clean_X_y | def _clean_X_y(X, y):
"""ensure that X and y data are float and correct shapes
"""
return make_2d(X, verbose=False).astype('float'), y.astype('float') | python | def _clean_X_y(X, y):
"""ensure that X and y data are float and correct shapes
"""
return make_2d(X, verbose=False).astype('float'), y.astype('float') | [
"def",
"_clean_X_y",
"(",
"X",
",",
"y",
")",
":",
"return",
"make_2d",
"(",
"X",
",",
"verbose",
"=",
"False",
")",
".",
"astype",
"(",
"'float'",
")",
",",
"y",
".",
"astype",
"(",
"'float'",
")"
] | ensure that X and y data are float and correct shapes | [
"ensure",
"that",
"X",
"and",
"y",
"data",
"are",
"float",
"and",
"correct",
"shapes"
] | b3e5c3cd580f0a3ad69f9372861624f67760c325 | https://github.com/dswah/pyGAM/blob/b3e5c3cd580f0a3ad69f9372861624f67760c325/pygam/datasets/load_datasets.py#L17-L20 |
225,570 | dswah/pyGAM | pygam/datasets/load_datasets.py | mcycle | def mcycle(return_X_y=True):
"""motorcyle acceleration dataset
Parameters
----------
return_X_y : bool,
if True, returns a model-ready tuple of data (X, y)
otherwise, returns a Pandas DataFrame
Returns
-------
model-ready tuple of data (X, y)
OR
Pandas DataFrame
Notes
-----
X contains the times after the impact.
y contains the acceleration.
Source:
https://vincentarelbundock.github.io/Rdatasets/doc/MASS/mcycle.html
"""
# y is real
# recommend LinearGAM
motor = pd.read_csv(PATH + '/mcycle.csv', index_col=0)
if return_X_y:
X = motor.times.values
y = motor.accel
return _clean_X_y(X, y)
return motor | python | def mcycle(return_X_y=True):
"""motorcyle acceleration dataset
Parameters
----------
return_X_y : bool,
if True, returns a model-ready tuple of data (X, y)
otherwise, returns a Pandas DataFrame
Returns
-------
model-ready tuple of data (X, y)
OR
Pandas DataFrame
Notes
-----
X contains the times after the impact.
y contains the acceleration.
Source:
https://vincentarelbundock.github.io/Rdatasets/doc/MASS/mcycle.html
"""
# y is real
# recommend LinearGAM
motor = pd.read_csv(PATH + '/mcycle.csv', index_col=0)
if return_X_y:
X = motor.times.values
y = motor.accel
return _clean_X_y(X, y)
return motor | [
"def",
"mcycle",
"(",
"return_X_y",
"=",
"True",
")",
":",
"# y is real",
"# recommend LinearGAM",
"motor",
"=",
"pd",
".",
"read_csv",
"(",
"PATH",
"+",
"'/mcycle.csv'",
",",
"index_col",
"=",
"0",
")",
"if",
"return_X_y",
":",
"X",
"=",
"motor",
".",
"... | motorcyle acceleration dataset
Parameters
----------
return_X_y : bool,
if True, returns a model-ready tuple of data (X, y)
otherwise, returns a Pandas DataFrame
Returns
-------
model-ready tuple of data (X, y)
OR
Pandas DataFrame
Notes
-----
X contains the times after the impact.
y contains the acceleration.
Source:
https://vincentarelbundock.github.io/Rdatasets/doc/MASS/mcycle.html | [
"motorcyle",
"acceleration",
"dataset"
] | b3e5c3cd580f0a3ad69f9372861624f67760c325 | https://github.com/dswah/pyGAM/blob/b3e5c3cd580f0a3ad69f9372861624f67760c325/pygam/datasets/load_datasets.py#L22-L52 |
225,571 | dswah/pyGAM | pygam/datasets/load_datasets.py | coal | def coal(return_X_y=True):
"""coal-mining accidents dataset
Parameters
----------
return_X_y : bool,
if True, returns a model-ready tuple of data (X, y)
otherwise, returns a Pandas DataFrame
Returns
-------
model-ready tuple of data (X, y)
OR
Pandas DataFrame
Notes
-----
The (X, y) tuple is a processed version of the otherwise raw DataFrame.
A histogram of 150 bins has been computed describing the number accidents per year.
X contains the midpoints of histogram bins.
y contains the count in each histogram bin.
Source:
https://vincentarelbundock.github.io/Rdatasets/doc/boot/coal.html
"""
# y is counts
# recommend PoissonGAM
coal = pd.read_csv(PATH + '/coal.csv', index_col=0)
if return_X_y:
y, x = np.histogram(coal.values, bins=150)
X = x[:-1] + np.diff(x)/2 # get midpoints of bins
return _clean_X_y(X, y)
return coal | python | def coal(return_X_y=True):
"""coal-mining accidents dataset
Parameters
----------
return_X_y : bool,
if True, returns a model-ready tuple of data (X, y)
otherwise, returns a Pandas DataFrame
Returns
-------
model-ready tuple of data (X, y)
OR
Pandas DataFrame
Notes
-----
The (X, y) tuple is a processed version of the otherwise raw DataFrame.
A histogram of 150 bins has been computed describing the number accidents per year.
X contains the midpoints of histogram bins.
y contains the count in each histogram bin.
Source:
https://vincentarelbundock.github.io/Rdatasets/doc/boot/coal.html
"""
# y is counts
# recommend PoissonGAM
coal = pd.read_csv(PATH + '/coal.csv', index_col=0)
if return_X_y:
y, x = np.histogram(coal.values, bins=150)
X = x[:-1] + np.diff(x)/2 # get midpoints of bins
return _clean_X_y(X, y)
return coal | [
"def",
"coal",
"(",
"return_X_y",
"=",
"True",
")",
":",
"# y is counts",
"# recommend PoissonGAM",
"coal",
"=",
"pd",
".",
"read_csv",
"(",
"PATH",
"+",
"'/coal.csv'",
",",
"index_col",
"=",
"0",
")",
"if",
"return_X_y",
":",
"y",
",",
"x",
"=",
"np",
... | coal-mining accidents dataset
Parameters
----------
return_X_y : bool,
if True, returns a model-ready tuple of data (X, y)
otherwise, returns a Pandas DataFrame
Returns
-------
model-ready tuple of data (X, y)
OR
Pandas DataFrame
Notes
-----
The (X, y) tuple is a processed version of the otherwise raw DataFrame.
A histogram of 150 bins has been computed describing the number accidents per year.
X contains the midpoints of histogram bins.
y contains the count in each histogram bin.
Source:
https://vincentarelbundock.github.io/Rdatasets/doc/boot/coal.html | [
"coal",
"-",
"mining",
"accidents",
"dataset"
] | b3e5c3cd580f0a3ad69f9372861624f67760c325 | https://github.com/dswah/pyGAM/blob/b3e5c3cd580f0a3ad69f9372861624f67760c325/pygam/datasets/load_datasets.py#L54-L88 |
225,572 | dswah/pyGAM | pygam/datasets/load_datasets.py | faithful | def faithful(return_X_y=True):
"""old-faithful dataset
Parameters
----------
return_X_y : bool,
if True, returns a model-ready tuple of data (X, y)
otherwise, returns a Pandas DataFrame
Returns
-------
model-ready tuple of data (X, y)
OR
Pandas DataFrame
Notes
-----
The (X, y) tuple is a processed version of the otherwise raw DataFrame.
A histogram of 200 bins has been computed describing the wating time between eruptions.
X contains the midpoints of histogram bins.
y contains the count in each histogram bin.
Source:
https://vincentarelbundock.github.io/Rdatasets/doc/datasets/faithful.html
"""
# y is counts
# recommend PoissonGAM
faithful = pd.read_csv(PATH + '/faithful.csv', index_col=0)
if return_X_y:
y, x = np.histogram(faithful['eruptions'], bins=200)
X = x[:-1] + np.diff(x)/2 # get midpoints of bins
return _clean_X_y(X, y)
return faithful | python | def faithful(return_X_y=True):
"""old-faithful dataset
Parameters
----------
return_X_y : bool,
if True, returns a model-ready tuple of data (X, y)
otherwise, returns a Pandas DataFrame
Returns
-------
model-ready tuple of data (X, y)
OR
Pandas DataFrame
Notes
-----
The (X, y) tuple is a processed version of the otherwise raw DataFrame.
A histogram of 200 bins has been computed describing the wating time between eruptions.
X contains the midpoints of histogram bins.
y contains the count in each histogram bin.
Source:
https://vincentarelbundock.github.io/Rdatasets/doc/datasets/faithful.html
"""
# y is counts
# recommend PoissonGAM
faithful = pd.read_csv(PATH + '/faithful.csv', index_col=0)
if return_X_y:
y, x = np.histogram(faithful['eruptions'], bins=200)
X = x[:-1] + np.diff(x)/2 # get midpoints of bins
return _clean_X_y(X, y)
return faithful | [
"def",
"faithful",
"(",
"return_X_y",
"=",
"True",
")",
":",
"# y is counts",
"# recommend PoissonGAM",
"faithful",
"=",
"pd",
".",
"read_csv",
"(",
"PATH",
"+",
"'/faithful.csv'",
",",
"index_col",
"=",
"0",
")",
"if",
"return_X_y",
":",
"y",
",",
"x",
"=... | old-faithful dataset
Parameters
----------
return_X_y : bool,
if True, returns a model-ready tuple of data (X, y)
otherwise, returns a Pandas DataFrame
Returns
-------
model-ready tuple of data (X, y)
OR
Pandas DataFrame
Notes
-----
The (X, y) tuple is a processed version of the otherwise raw DataFrame.
A histogram of 200 bins has been computed describing the wating time between eruptions.
X contains the midpoints of histogram bins.
y contains the count in each histogram bin.
Source:
https://vincentarelbundock.github.io/Rdatasets/doc/datasets/faithful.html | [
"old",
"-",
"faithful",
"dataset"
] | b3e5c3cd580f0a3ad69f9372861624f67760c325 | https://github.com/dswah/pyGAM/blob/b3e5c3cd580f0a3ad69f9372861624f67760c325/pygam/datasets/load_datasets.py#L90-L124 |
225,573 | dswah/pyGAM | pygam/datasets/load_datasets.py | trees | def trees(return_X_y=True):
"""cherry trees dataset
Parameters
----------
return_X_y : bool,
if True, returns a model-ready tuple of data (X, y)
otherwise, returns a Pandas DataFrame
Returns
-------
model-ready tuple of data (X, y)
OR
Pandas DataFrame
Notes
-----
X contains the girth and the height of each tree.
y contains the volume.
Source:
https://vincentarelbundock.github.io/Rdatasets/doc/datasets/trees.html
"""
# y is real.
# recommend InvGaussGAM, or GAM(distribution='gamma', link='log')
trees = pd.read_csv(PATH + '/trees.csv', index_col=0)
if return_X_y:
y = trees.Volume.values
X = trees[['Girth', 'Height']].values
return _clean_X_y(X, y)
return trees | python | def trees(return_X_y=True):
"""cherry trees dataset
Parameters
----------
return_X_y : bool,
if True, returns a model-ready tuple of data (X, y)
otherwise, returns a Pandas DataFrame
Returns
-------
model-ready tuple of data (X, y)
OR
Pandas DataFrame
Notes
-----
X contains the girth and the height of each tree.
y contains the volume.
Source:
https://vincentarelbundock.github.io/Rdatasets/doc/datasets/trees.html
"""
# y is real.
# recommend InvGaussGAM, or GAM(distribution='gamma', link='log')
trees = pd.read_csv(PATH + '/trees.csv', index_col=0)
if return_X_y:
y = trees.Volume.values
X = trees[['Girth', 'Height']].values
return _clean_X_y(X, y)
return trees | [
"def",
"trees",
"(",
"return_X_y",
"=",
"True",
")",
":",
"# y is real.",
"# recommend InvGaussGAM, or GAM(distribution='gamma', link='log')",
"trees",
"=",
"pd",
".",
"read_csv",
"(",
"PATH",
"+",
"'/trees.csv'",
",",
"index_col",
"=",
"0",
")",
"if",
"return_X_y",... | cherry trees dataset
Parameters
----------
return_X_y : bool,
if True, returns a model-ready tuple of data (X, y)
otherwise, returns a Pandas DataFrame
Returns
-------
model-ready tuple of data (X, y)
OR
Pandas DataFrame
Notes
-----
X contains the girth and the height of each tree.
y contains the volume.
Source:
https://vincentarelbundock.github.io/Rdatasets/doc/datasets/trees.html | [
"cherry",
"trees",
"dataset"
] | b3e5c3cd580f0a3ad69f9372861624f67760c325 | https://github.com/dswah/pyGAM/blob/b3e5c3cd580f0a3ad69f9372861624f67760c325/pygam/datasets/load_datasets.py#L161-L191 |
225,574 | dswah/pyGAM | pygam/datasets/load_datasets.py | default | def default(return_X_y=True):
"""credit default dataset
Parameters
----------
return_X_y : bool,
if True, returns a model-ready tuple of data (X, y)
otherwise, returns a Pandas DataFrame
Returns
-------
model-ready tuple of data (X, y)
OR
Pandas DataFrame
Notes
-----
X contains the category of student or not, credit card balance,
and income.
y contains the outcome of default (0) or not (1).
Source:
https://vincentarelbundock.github.io/Rdatasets/doc/ISLR/Default.html
"""
# y is binary
# recommend LogisticGAM
default = pd.read_csv(PATH + '/default.csv', index_col=0)
if return_X_y:
default = default.values
default[:,0] = np.unique(default[:,0], return_inverse=True)[1]
default[:,1] = np.unique(default[:,1], return_inverse=True)[1]
X = default[:,1:]
y = default[:,0]
return _clean_X_y(X, y)
return default | python | def default(return_X_y=True):
"""credit default dataset
Parameters
----------
return_X_y : bool,
if True, returns a model-ready tuple of data (X, y)
otherwise, returns a Pandas DataFrame
Returns
-------
model-ready tuple of data (X, y)
OR
Pandas DataFrame
Notes
-----
X contains the category of student or not, credit card balance,
and income.
y contains the outcome of default (0) or not (1).
Source:
https://vincentarelbundock.github.io/Rdatasets/doc/ISLR/Default.html
"""
# y is binary
# recommend LogisticGAM
default = pd.read_csv(PATH + '/default.csv', index_col=0)
if return_X_y:
default = default.values
default[:,0] = np.unique(default[:,0], return_inverse=True)[1]
default[:,1] = np.unique(default[:,1], return_inverse=True)[1]
X = default[:,1:]
y = default[:,0]
return _clean_X_y(X, y)
return default | [
"def",
"default",
"(",
"return_X_y",
"=",
"True",
")",
":",
"# y is binary",
"# recommend LogisticGAM",
"default",
"=",
"pd",
".",
"read_csv",
"(",
"PATH",
"+",
"'/default.csv'",
",",
"index_col",
"=",
"0",
")",
"if",
"return_X_y",
":",
"default",
"=",
"defa... | credit default dataset
Parameters
----------
return_X_y : bool,
if True, returns a model-ready tuple of data (X, y)
otherwise, returns a Pandas DataFrame
Returns
-------
model-ready tuple of data (X, y)
OR
Pandas DataFrame
Notes
-----
X contains the category of student or not, credit card balance,
and income.
y contains the outcome of default (0) or not (1).
Source:
https://vincentarelbundock.github.io/Rdatasets/doc/ISLR/Default.html | [
"credit",
"default",
"dataset"
] | b3e5c3cd580f0a3ad69f9372861624f67760c325 | https://github.com/dswah/pyGAM/blob/b3e5c3cd580f0a3ad69f9372861624f67760c325/pygam/datasets/load_datasets.py#L193-L228 |
225,575 | dswah/pyGAM | pygam/datasets/load_datasets.py | hepatitis | def hepatitis(return_X_y=True):
"""hepatitis in Bulgaria dataset
Parameters
----------
return_X_y : bool,
if True, returns a model-ready tuple of data (X, y)
otherwise, returns a Pandas DataFrame
Returns
-------
model-ready tuple of data (X, y)
OR
Pandas DataFrame
Notes
-----
X contains the age of each patient group.
y contains the ratio of HAV positive patients to the total number for each
age group.
Groups with 0 total patients are excluded.
Source:
Keiding, N. (1991) Age-specific incidence and prevalence: a statistical perspective
"""
# y is real
# recommend LinearGAM
hep = pd.read_csv(PATH + '/hepatitis_A_bulgaria.csv').astype(float)
if return_X_y:
# eliminate 0/0
mask = (hep.total > 0).values
hep = hep[mask]
X = hep.age.values
y = hep.hepatitis_A_positive.values / hep.total.values
return _clean_X_y(X, y)
return hep | python | def hepatitis(return_X_y=True):
"""hepatitis in Bulgaria dataset
Parameters
----------
return_X_y : bool,
if True, returns a model-ready tuple of data (X, y)
otherwise, returns a Pandas DataFrame
Returns
-------
model-ready tuple of data (X, y)
OR
Pandas DataFrame
Notes
-----
X contains the age of each patient group.
y contains the ratio of HAV positive patients to the total number for each
age group.
Groups with 0 total patients are excluded.
Source:
Keiding, N. (1991) Age-specific incidence and prevalence: a statistical perspective
"""
# y is real
# recommend LinearGAM
hep = pd.read_csv(PATH + '/hepatitis_A_bulgaria.csv').astype(float)
if return_X_y:
# eliminate 0/0
mask = (hep.total > 0).values
hep = hep[mask]
X = hep.age.values
y = hep.hepatitis_A_positive.values / hep.total.values
return _clean_X_y(X, y)
return hep | [
"def",
"hepatitis",
"(",
"return_X_y",
"=",
"True",
")",
":",
"# y is real",
"# recommend LinearGAM",
"hep",
"=",
"pd",
".",
"read_csv",
"(",
"PATH",
"+",
"'/hepatitis_A_bulgaria.csv'",
")",
".",
"astype",
"(",
"float",
")",
"if",
"return_X_y",
":",
"# elimina... | hepatitis in Bulgaria dataset
Parameters
----------
return_X_y : bool,
if True, returns a model-ready tuple of data (X, y)
otherwise, returns a Pandas DataFrame
Returns
-------
model-ready tuple of data (X, y)
OR
Pandas DataFrame
Notes
-----
X contains the age of each patient group.
y contains the ratio of HAV positive patients to the total number for each
age group.
Groups with 0 total patients are excluded.
Source:
Keiding, N. (1991) Age-specific incidence and prevalence: a statistical perspective | [
"hepatitis",
"in",
"Bulgaria",
"dataset"
] | b3e5c3cd580f0a3ad69f9372861624f67760c325 | https://github.com/dswah/pyGAM/blob/b3e5c3cd580f0a3ad69f9372861624f67760c325/pygam/datasets/load_datasets.py#L266-L304 |
225,576 | dswah/pyGAM | pygam/datasets/load_datasets.py | toy_classification | def toy_classification(return_X_y=True, n=5000):
"""toy classification dataset with irrelevant features
fitting a logistic model on this data and performing a model summary
should reveal that features 2,3,4 are not significant.
Parameters
----------
return_X_y : bool,
if True, returns a model-ready tuple of data (X, y)
otherwise, returns a Pandas DataFrame
n : int, default: 5000
number of samples to generate
Returns
-------
model-ready tuple of data (X, y)
OR
Pandas DataFrame
Notes
-----
X contains 5 variables:
continuous feature 0
continuous feature 1
irrelevant feature 0
irrelevant feature 1
irrelevant feature 2
categorical feature 0
y contains binary labels
Also, this dataset is randomly generated and will vary each time.
"""
# make features
X = np.random.rand(n,5) * 10 - 5
cat = np.random.randint(0,4, n)
X = np.c_[X, cat]
# make observations
log_odds = (-0.5*X[:,0]**2) + 5 +(-0.5*X[:,1]**2) + np.mod(X[:,-1], 2)*-30
p = 1/(1+np.exp(-log_odds)).squeeze()
y = (np.random.rand(n) < p).astype(np.int)
if return_X_y:
return X, y
else:
return pd.DataFrame(np.c_[X, y], columns=[['continuous0',
'continuous1',
'irrelevant0',
'irrelevant1',
'irrelevant2',
'categorical0',
'observations'
]]) | python | def toy_classification(return_X_y=True, n=5000):
"""toy classification dataset with irrelevant features
fitting a logistic model on this data and performing a model summary
should reveal that features 2,3,4 are not significant.
Parameters
----------
return_X_y : bool,
if True, returns a model-ready tuple of data (X, y)
otherwise, returns a Pandas DataFrame
n : int, default: 5000
number of samples to generate
Returns
-------
model-ready tuple of data (X, y)
OR
Pandas DataFrame
Notes
-----
X contains 5 variables:
continuous feature 0
continuous feature 1
irrelevant feature 0
irrelevant feature 1
irrelevant feature 2
categorical feature 0
y contains binary labels
Also, this dataset is randomly generated and will vary each time.
"""
# make features
X = np.random.rand(n,5) * 10 - 5
cat = np.random.randint(0,4, n)
X = np.c_[X, cat]
# make observations
log_odds = (-0.5*X[:,0]**2) + 5 +(-0.5*X[:,1]**2) + np.mod(X[:,-1], 2)*-30
p = 1/(1+np.exp(-log_odds)).squeeze()
y = (np.random.rand(n) < p).astype(np.int)
if return_X_y:
return X, y
else:
return pd.DataFrame(np.c_[X, y], columns=[['continuous0',
'continuous1',
'irrelevant0',
'irrelevant1',
'irrelevant2',
'categorical0',
'observations'
]]) | [
"def",
"toy_classification",
"(",
"return_X_y",
"=",
"True",
",",
"n",
"=",
"5000",
")",
":",
"# make features",
"X",
"=",
"np",
".",
"random",
".",
"rand",
"(",
"n",
",",
"5",
")",
"*",
"10",
"-",
"5",
"cat",
"=",
"np",
".",
"random",
".",
"rand... | toy classification dataset with irrelevant features
fitting a logistic model on this data and performing a model summary
should reveal that features 2,3,4 are not significant.
Parameters
----------
return_X_y : bool,
if True, returns a model-ready tuple of data (X, y)
otherwise, returns a Pandas DataFrame
n : int, default: 5000
number of samples to generate
Returns
-------
model-ready tuple of data (X, y)
OR
Pandas DataFrame
Notes
-----
X contains 5 variables:
continuous feature 0
continuous feature 1
irrelevant feature 0
irrelevant feature 1
irrelevant feature 2
categorical feature 0
y contains binary labels
Also, this dataset is randomly generated and will vary each time. | [
"toy",
"classification",
"dataset",
"with",
"irrelevant",
"features"
] | b3e5c3cd580f0a3ad69f9372861624f67760c325 | https://github.com/dswah/pyGAM/blob/b3e5c3cd580f0a3ad69f9372861624f67760c325/pygam/datasets/load_datasets.py#L306-L361 |
225,577 | dswah/pyGAM | pygam/datasets/load_datasets.py | head_circumference | def head_circumference(return_X_y=True):
"""head circumference for dutch boys
Parameters
----------
return_X_y : bool,
if True, returns a model-ready tuple of data (X, y)
otherwise, returns a Pandas DataFrame
Returns
-------
model-ready tuple of data (X, y)
OR
Pandas DataFrame
Notes
-----
X contains the age in years of each patient.
y contains the head circumference in centimeters
"""
# y is real
# recommend ExpectileGAM
head = pd.read_csv(PATH + '/head_circumference.csv', index_col=0).astype(float)
if return_X_y:
y = head['head'].values
X = head[['age']].values
return _clean_X_y(X, y)
return head | python | def head_circumference(return_X_y=True):
"""head circumference for dutch boys
Parameters
----------
return_X_y : bool,
if True, returns a model-ready tuple of data (X, y)
otherwise, returns a Pandas DataFrame
Returns
-------
model-ready tuple of data (X, y)
OR
Pandas DataFrame
Notes
-----
X contains the age in years of each patient.
y contains the head circumference in centimeters
"""
# y is real
# recommend ExpectileGAM
head = pd.read_csv(PATH + '/head_circumference.csv', index_col=0).astype(float)
if return_X_y:
y = head['head'].values
X = head[['age']].values
return _clean_X_y(X, y)
return head | [
"def",
"head_circumference",
"(",
"return_X_y",
"=",
"True",
")",
":",
"# y is real",
"# recommend ExpectileGAM",
"head",
"=",
"pd",
".",
"read_csv",
"(",
"PATH",
"+",
"'/head_circumference.csv'",
",",
"index_col",
"=",
"0",
")",
".",
"astype",
"(",
"float",
"... | head circumference for dutch boys
Parameters
----------
return_X_y : bool,
if True, returns a model-ready tuple of data (X, y)
otherwise, returns a Pandas DataFrame
Returns
-------
model-ready tuple of data (X, y)
OR
Pandas DataFrame
Notes
-----
X contains the age in years of each patient.
y contains the head circumference in centimeters | [
"head",
"circumference",
"for",
"dutch",
"boys"
] | b3e5c3cd580f0a3ad69f9372861624f67760c325 | https://github.com/dswah/pyGAM/blob/b3e5c3cd580f0a3ad69f9372861624f67760c325/pygam/datasets/load_datasets.py#L363-L391 |
225,578 | dswah/pyGAM | pygam/datasets/load_datasets.py | chicago | def chicago(return_X_y=True):
"""Chicago air pollution and death rate data
Parameters
----------
return_X_y : bool,
if True, returns a model-ready tuple of data (X, y)
otherwise, returns a Pandas DataFrame
Returns
-------
model-ready tuple of data (X, y)
OR
Pandas DataFrame
Notes
-----
X contains [['time', 'tmpd', 'pm10median', 'o3median']], with no NaNs
y contains 'death', the deaths per day, with no NaNs
Source:
R gamair package
`data(chicago)`
Notes
-----
https://cran.r-project.org/web/packages/gamair/gamair.pdf
https://rdrr.io/cran/gamair/man/chicago.html
Columns:
death : total deaths (per day).
pm10median : median particles in 2.5-10 per cubic m
pm25median : median particles < 2.5 mg per cubic m (more dangerous).
o3median : Ozone in parts per billion
so2median : Median Sulpher dioxide measurement
time : time in days
tmpd : temperature in fahrenheit
"""
# recommend PoissonGAM
chi = pd.read_csv(PATH + '/chicago.csv', index_col=0).astype(float)
if return_X_y:
chi = chi[['time', 'tmpd', 'pm10median', 'o3median', 'death']].dropna()
X = chi[['time', 'tmpd', 'pm10median', 'o3median']].values
y = chi['death'].values
return X, y
else:
return chi | python | def chicago(return_X_y=True):
"""Chicago air pollution and death rate data
Parameters
----------
return_X_y : bool,
if True, returns a model-ready tuple of data (X, y)
otherwise, returns a Pandas DataFrame
Returns
-------
model-ready tuple of data (X, y)
OR
Pandas DataFrame
Notes
-----
X contains [['time', 'tmpd', 'pm10median', 'o3median']], with no NaNs
y contains 'death', the deaths per day, with no NaNs
Source:
R gamair package
`data(chicago)`
Notes
-----
https://cran.r-project.org/web/packages/gamair/gamair.pdf
https://rdrr.io/cran/gamair/man/chicago.html
Columns:
death : total deaths (per day).
pm10median : median particles in 2.5-10 per cubic m
pm25median : median particles < 2.5 mg per cubic m (more dangerous).
o3median : Ozone in parts per billion
so2median : Median Sulpher dioxide measurement
time : time in days
tmpd : temperature in fahrenheit
"""
# recommend PoissonGAM
chi = pd.read_csv(PATH + '/chicago.csv', index_col=0).astype(float)
if return_X_y:
chi = chi[['time', 'tmpd', 'pm10median', 'o3median', 'death']].dropna()
X = chi[['time', 'tmpd', 'pm10median', 'o3median']].values
y = chi['death'].values
return X, y
else:
return chi | [
"def",
"chicago",
"(",
"return_X_y",
"=",
"True",
")",
":",
"# recommend PoissonGAM",
"chi",
"=",
"pd",
".",
"read_csv",
"(",
"PATH",
"+",
"'/chicago.csv'",
",",
"index_col",
"=",
"0",
")",
".",
"astype",
"(",
"float",
")",
"if",
"return_X_y",
":",
"chi"... | Chicago air pollution and death rate data
Parameters
----------
return_X_y : bool,
if True, returns a model-ready tuple of data (X, y)
otherwise, returns a Pandas DataFrame
Returns
-------
model-ready tuple of data (X, y)
OR
Pandas DataFrame
Notes
-----
X contains [['time', 'tmpd', 'pm10median', 'o3median']], with no NaNs
y contains 'death', the deaths per day, with no NaNs
Source:
R gamair package
`data(chicago)`
Notes
-----
https://cran.r-project.org/web/packages/gamair/gamair.pdf
https://rdrr.io/cran/gamair/man/chicago.html
Columns:
death : total deaths (per day).
pm10median : median particles in 2.5-10 per cubic m
pm25median : median particles < 2.5 mg per cubic m (more dangerous).
o3median : Ozone in parts per billion
so2median : Median Sulpher dioxide measurement
time : time in days
tmpd : temperature in fahrenheit | [
"Chicago",
"air",
"pollution",
"and",
"death",
"rate",
"data"
] | b3e5c3cd580f0a3ad69f9372861624f67760c325 | https://github.com/dswah/pyGAM/blob/b3e5c3cd580f0a3ad69f9372861624f67760c325/pygam/datasets/load_datasets.py#L393-L442 |
225,579 | dswah/pyGAM | pygam/datasets/load_datasets.py | toy_interaction | def toy_interaction(return_X_y=True, n=50000, stddev=0.1):
"""a sinusoid modulated by a linear function
this is a simple dataset to test a model's capacity to fit interactions
between features.
a GAM with no interaction terms will have an R-squared close to 0,
while a GAM with a tensor product will have R-squared close to 1.
the data is random, and will vary on each invocation.
Parameters
----------
return_X_y : bool,
if True, returns a model-ready tuple of data (X, y)
otherwise, returns a Pandas DataFrame
n : int, optional
number of points to generate
stddev : positive float, optional,
standard deviation of irreducible error
Returns
-------
model-ready tuple of data (X, y)
OR
Pandas DataFrame
Notes
-----
X contains [['sinusoid', 'linear']]
y is formed by multiplying the sinusoid by the linear function.
Source:
"""
X = np.random.uniform(-1,1, size=(n, 2))
X[:, 1] *= 5
y = np.sin(X[:,0] * 2 * np.pi * 1.5) * X[:,1]
y += np.random.randn(len(X)) * stddev
if return_X_y:
return X, y
else:
data = pd.DataFrame(np.c_[X, y])
data.columns = [['sinusoid', 'linear', 'y']]
return data | python | def toy_interaction(return_X_y=True, n=50000, stddev=0.1):
"""a sinusoid modulated by a linear function
this is a simple dataset to test a model's capacity to fit interactions
between features.
a GAM with no interaction terms will have an R-squared close to 0,
while a GAM with a tensor product will have R-squared close to 1.
the data is random, and will vary on each invocation.
Parameters
----------
return_X_y : bool,
if True, returns a model-ready tuple of data (X, y)
otherwise, returns a Pandas DataFrame
n : int, optional
number of points to generate
stddev : positive float, optional,
standard deviation of irreducible error
Returns
-------
model-ready tuple of data (X, y)
OR
Pandas DataFrame
Notes
-----
X contains [['sinusoid', 'linear']]
y is formed by multiplying the sinusoid by the linear function.
Source:
"""
X = np.random.uniform(-1,1, size=(n, 2))
X[:, 1] *= 5
y = np.sin(X[:,0] * 2 * np.pi * 1.5) * X[:,1]
y += np.random.randn(len(X)) * stddev
if return_X_y:
return X, y
else:
data = pd.DataFrame(np.c_[X, y])
data.columns = [['sinusoid', 'linear', 'y']]
return data | [
"def",
"toy_interaction",
"(",
"return_X_y",
"=",
"True",
",",
"n",
"=",
"50000",
",",
"stddev",
"=",
"0.1",
")",
":",
"X",
"=",
"np",
".",
"random",
".",
"uniform",
"(",
"-",
"1",
",",
"1",
",",
"size",
"=",
"(",
"n",
",",
"2",
")",
")",
"X"... | a sinusoid modulated by a linear function
this is a simple dataset to test a model's capacity to fit interactions
between features.
a GAM with no interaction terms will have an R-squared close to 0,
while a GAM with a tensor product will have R-squared close to 1.
the data is random, and will vary on each invocation.
Parameters
----------
return_X_y : bool,
if True, returns a model-ready tuple of data (X, y)
otherwise, returns a Pandas DataFrame
n : int, optional
number of points to generate
stddev : positive float, optional,
standard deviation of irreducible error
Returns
-------
model-ready tuple of data (X, y)
OR
Pandas DataFrame
Notes
-----
X contains [['sinusoid', 'linear']]
y is formed by multiplying the sinusoid by the linear function.
Source: | [
"a",
"sinusoid",
"modulated",
"by",
"a",
"linear",
"function"
] | b3e5c3cd580f0a3ad69f9372861624f67760c325 | https://github.com/dswah/pyGAM/blob/b3e5c3cd580f0a3ad69f9372861624f67760c325/pygam/datasets/load_datasets.py#L444-L493 |
225,580 | dswah/pyGAM | gen_imgs.py | gen_multi_data | def gen_multi_data(n=5000):
"""
multivariate Logistic problem
"""
X, y = toy_classification(return_X_y=True, n=10000)
lgam = LogisticGAM(s(0) + s(1) + s(2) + s(3) + s(4) + f(5))
lgam.fit(X, y)
plt.figure()
for i, term in enumerate(lgam.terms):
if term.isintercept:
continue
plt.plot(lgam.partial_dependence(term=i))
plt.savefig('imgs/pygam_multi_pdep.png', dpi=300)
plt.figure()
plt.plot(lgam.logs_['deviance'])
plt.savefig('imgs/pygam_multi_deviance.png', dpi=300) | python | def gen_multi_data(n=5000):
"""
multivariate Logistic problem
"""
X, y = toy_classification(return_X_y=True, n=10000)
lgam = LogisticGAM(s(0) + s(1) + s(2) + s(3) + s(4) + f(5))
lgam.fit(X, y)
plt.figure()
for i, term in enumerate(lgam.terms):
if term.isintercept:
continue
plt.plot(lgam.partial_dependence(term=i))
plt.savefig('imgs/pygam_multi_pdep.png', dpi=300)
plt.figure()
plt.plot(lgam.logs_['deviance'])
plt.savefig('imgs/pygam_multi_deviance.png', dpi=300) | [
"def",
"gen_multi_data",
"(",
"n",
"=",
"5000",
")",
":",
"X",
",",
"y",
"=",
"toy_classification",
"(",
"return_X_y",
"=",
"True",
",",
"n",
"=",
"10000",
")",
"lgam",
"=",
"LogisticGAM",
"(",
"s",
"(",
"0",
")",
"+",
"s",
"(",
"1",
")",
"+",
... | multivariate Logistic problem | [
"multivariate",
"Logistic",
"problem"
] | b3e5c3cd580f0a3ad69f9372861624f67760c325 | https://github.com/dswah/pyGAM/blob/b3e5c3cd580f0a3ad69f9372861624f67760c325/gen_imgs.py#L229-L248 |
225,581 | dswah/pyGAM | gen_imgs.py | gen_tensor_data | def gen_tensor_data():
"""
toy interaction data
"""
X, y = toy_interaction(return_X_y=True, n=10000)
gam = LinearGAM(te(0, 1,lam=0.1)).fit(X, y)
XX = gam.generate_X_grid(term=0, meshgrid=True)
Z = gam.partial_dependence(term=0, meshgrid=True)
fig = plt.figure(figsize=(9,6))
ax = plt.axes(projection='3d')
ax.dist = 7.5
ax.plot_surface(XX[0], XX[1], Z, cmap='viridis')
ax.set_axis_off()
fig.tight_layout()
plt.savefig('imgs/pygam_tensor.png', transparent=True, dpi=300) | python | def gen_tensor_data():
"""
toy interaction data
"""
X, y = toy_interaction(return_X_y=True, n=10000)
gam = LinearGAM(te(0, 1,lam=0.1)).fit(X, y)
XX = gam.generate_X_grid(term=0, meshgrid=True)
Z = gam.partial_dependence(term=0, meshgrid=True)
fig = plt.figure(figsize=(9,6))
ax = plt.axes(projection='3d')
ax.dist = 7.5
ax.plot_surface(XX[0], XX[1], Z, cmap='viridis')
ax.set_axis_off()
fig.tight_layout()
plt.savefig('imgs/pygam_tensor.png', transparent=True, dpi=300) | [
"def",
"gen_tensor_data",
"(",
")",
":",
"X",
",",
"y",
"=",
"toy_interaction",
"(",
"return_X_y",
"=",
"True",
",",
"n",
"=",
"10000",
")",
"gam",
"=",
"LinearGAM",
"(",
"te",
"(",
"0",
",",
"1",
",",
"lam",
"=",
"0.1",
")",
")",
".",
"fit",
"... | toy interaction data | [
"toy",
"interaction",
"data"
] | b3e5c3cd580f0a3ad69f9372861624f67760c325 | https://github.com/dswah/pyGAM/blob/b3e5c3cd580f0a3ad69f9372861624f67760c325/gen_imgs.py#L250-L267 |
225,582 | dswah/pyGAM | gen_imgs.py | expectiles | def expectiles():
"""
a bunch of expectiles
"""
X, y = mcycle(return_X_y=True)
# lets fit the mean model first by CV
gam50 = ExpectileGAM(expectile=0.5).gridsearch(X, y)
# and copy the smoothing to the other models
lam = gam50.lam
# now fit a few more models
gam95 = ExpectileGAM(expectile=0.95, lam=lam).fit(X, y)
gam75 = ExpectileGAM(expectile=0.75, lam=lam).fit(X, y)
gam25 = ExpectileGAM(expectile=0.25, lam=lam).fit(X, y)
gam05 = ExpectileGAM(expectile=0.05, lam=lam).fit(X, y)
XX = gam50.generate_X_grid(term=0, n=500)
fig = plt.figure()
plt.scatter(X, y, c='k', alpha=0.2)
plt.plot(XX, gam95.predict(XX), label='0.95')
plt.plot(XX, gam75.predict(XX), label='0.75')
plt.plot(XX, gam50.predict(XX), label='0.50')
plt.plot(XX, gam25.predict(XX), label='0.25')
plt.plot(XX, gam05.predict(XX), label='0.05')
plt.legend()
fig.tight_layout()
plt.savefig('imgs/pygam_expectiles.png', dpi=300) | python | def expectiles():
"""
a bunch of expectiles
"""
X, y = mcycle(return_X_y=True)
# lets fit the mean model first by CV
gam50 = ExpectileGAM(expectile=0.5).gridsearch(X, y)
# and copy the smoothing to the other models
lam = gam50.lam
# now fit a few more models
gam95 = ExpectileGAM(expectile=0.95, lam=lam).fit(X, y)
gam75 = ExpectileGAM(expectile=0.75, lam=lam).fit(X, y)
gam25 = ExpectileGAM(expectile=0.25, lam=lam).fit(X, y)
gam05 = ExpectileGAM(expectile=0.05, lam=lam).fit(X, y)
XX = gam50.generate_X_grid(term=0, n=500)
fig = plt.figure()
plt.scatter(X, y, c='k', alpha=0.2)
plt.plot(XX, gam95.predict(XX), label='0.95')
plt.plot(XX, gam75.predict(XX), label='0.75')
plt.plot(XX, gam50.predict(XX), label='0.50')
plt.plot(XX, gam25.predict(XX), label='0.25')
plt.plot(XX, gam05.predict(XX), label='0.05')
plt.legend()
fig.tight_layout()
plt.savefig('imgs/pygam_expectiles.png', dpi=300) | [
"def",
"expectiles",
"(",
")",
":",
"X",
",",
"y",
"=",
"mcycle",
"(",
"return_X_y",
"=",
"True",
")",
"# lets fit the mean model first by CV",
"gam50",
"=",
"ExpectileGAM",
"(",
"expectile",
"=",
"0.5",
")",
".",
"gridsearch",
"(",
"X",
",",
"y",
")",
"... | a bunch of expectiles | [
"a",
"bunch",
"of",
"expectiles"
] | b3e5c3cd580f0a3ad69f9372861624f67760c325 | https://github.com/dswah/pyGAM/blob/b3e5c3cd580f0a3ad69f9372861624f67760c325/gen_imgs.py#L287-L318 |
225,583 | dswah/pyGAM | pygam/utils.py | cholesky | def cholesky(A, sparse=True, verbose=True):
"""
Choose the best possible cholesky factorizor.
if possible, import the Scikit-Sparse sparse Cholesky method.
Permutes the output L to ensure A = L.H . L
otherwise defaults to numpy's non-sparse version
Parameters
----------
A : array-like
array to decompose
sparse : boolean, default: True
whether to return a sparse array
verbose : bool, default: True
whether to print warnings
"""
if SKSPIMPORT:
A = sp.sparse.csc_matrix(A)
try:
F = spcholesky(A)
# permutation matrix P
P = sp.sparse.lil_matrix(A.shape)
p = F.P()
P[np.arange(len(p)), p] = 1
# permute
L = F.L()
L = P.T.dot(L)
except CholmodNotPositiveDefiniteError as e:
raise NotPositiveDefiniteError('Matrix is not positive definite')
if sparse:
return L.T # upper triangular factorization
return L.T.A # upper triangular factorization
else:
msg = 'Could not import Scikit-Sparse or Suite-Sparse.\n'\
'This will slow down optimization for models with '\
'monotonicity/convexity penalties and many splines.\n'\
'See installation instructions for installing '\
'Scikit-Sparse and Suite-Sparse via Conda.'
if verbose:
warnings.warn(msg)
if sp.sparse.issparse(A):
A = A.A
try:
L = sp.linalg.cholesky(A, lower=False)
except LinAlgError as e:
raise NotPositiveDefiniteError('Matrix is not positive definite')
if sparse:
return sp.sparse.csc_matrix(L)
return L | python | def cholesky(A, sparse=True, verbose=True):
"""
Choose the best possible cholesky factorizor.
if possible, import the Scikit-Sparse sparse Cholesky method.
Permutes the output L to ensure A = L.H . L
otherwise defaults to numpy's non-sparse version
Parameters
----------
A : array-like
array to decompose
sparse : boolean, default: True
whether to return a sparse array
verbose : bool, default: True
whether to print warnings
"""
if SKSPIMPORT:
A = sp.sparse.csc_matrix(A)
try:
F = spcholesky(A)
# permutation matrix P
P = sp.sparse.lil_matrix(A.shape)
p = F.P()
P[np.arange(len(p)), p] = 1
# permute
L = F.L()
L = P.T.dot(L)
except CholmodNotPositiveDefiniteError as e:
raise NotPositiveDefiniteError('Matrix is not positive definite')
if sparse:
return L.T # upper triangular factorization
return L.T.A # upper triangular factorization
else:
msg = 'Could not import Scikit-Sparse or Suite-Sparse.\n'\
'This will slow down optimization for models with '\
'monotonicity/convexity penalties and many splines.\n'\
'See installation instructions for installing '\
'Scikit-Sparse and Suite-Sparse via Conda.'
if verbose:
warnings.warn(msg)
if sp.sparse.issparse(A):
A = A.A
try:
L = sp.linalg.cholesky(A, lower=False)
except LinAlgError as e:
raise NotPositiveDefiniteError('Matrix is not positive definite')
if sparse:
return sp.sparse.csc_matrix(L)
return L | [
"def",
"cholesky",
"(",
"A",
",",
"sparse",
"=",
"True",
",",
"verbose",
"=",
"True",
")",
":",
"if",
"SKSPIMPORT",
":",
"A",
"=",
"sp",
".",
"sparse",
".",
"csc_matrix",
"(",
"A",
")",
"try",
":",
"F",
"=",
"spcholesky",
"(",
"A",
")",
"# permut... | Choose the best possible cholesky factorizor.
if possible, import the Scikit-Sparse sparse Cholesky method.
Permutes the output L to ensure A = L.H . L
otherwise defaults to numpy's non-sparse version
Parameters
----------
A : array-like
array to decompose
sparse : boolean, default: True
whether to return a sparse array
verbose : bool, default: True
whether to print warnings | [
"Choose",
"the",
"best",
"possible",
"cholesky",
"factorizor",
"."
] | b3e5c3cd580f0a3ad69f9372861624f67760c325 | https://github.com/dswah/pyGAM/blob/b3e5c3cd580f0a3ad69f9372861624f67760c325/pygam/utils.py#L33-L90 |
225,584 | dswah/pyGAM | pygam/utils.py | make_2d | def make_2d(array, verbose=True):
"""
tiny tool to expand 1D arrays the way i want
Parameters
----------
array : array-like
verbose : bool, default: True
whether to print warnings
Returns
-------
np.array of with ndim = 2
"""
array = np.asarray(array)
if array.ndim < 2:
msg = 'Expected 2D input data array, but found {}D. '\
'Expanding to 2D.'.format(array.ndim)
if verbose:
warnings.warn(msg)
array = np.atleast_1d(array)[:,None]
return array | python | def make_2d(array, verbose=True):
"""
tiny tool to expand 1D arrays the way i want
Parameters
----------
array : array-like
verbose : bool, default: True
whether to print warnings
Returns
-------
np.array of with ndim = 2
"""
array = np.asarray(array)
if array.ndim < 2:
msg = 'Expected 2D input data array, but found {}D. '\
'Expanding to 2D.'.format(array.ndim)
if verbose:
warnings.warn(msg)
array = np.atleast_1d(array)[:,None]
return array | [
"def",
"make_2d",
"(",
"array",
",",
"verbose",
"=",
"True",
")",
":",
"array",
"=",
"np",
".",
"asarray",
"(",
"array",
")",
"if",
"array",
".",
"ndim",
"<",
"2",
":",
"msg",
"=",
"'Expected 2D input data array, but found {}D. '",
"'Expanding to 2D.'",
".",... | tiny tool to expand 1D arrays the way i want
Parameters
----------
array : array-like
verbose : bool, default: True
whether to print warnings
Returns
-------
np.array of with ndim = 2 | [
"tiny",
"tool",
"to",
"expand",
"1D",
"arrays",
"the",
"way",
"i",
"want"
] | b3e5c3cd580f0a3ad69f9372861624f67760c325 | https://github.com/dswah/pyGAM/blob/b3e5c3cd580f0a3ad69f9372861624f67760c325/pygam/utils.py#L93-L115 |
225,585 | dswah/pyGAM | pygam/utils.py | check_array | def check_array(array, force_2d=False, n_feats=None, ndim=None,
min_samples=1, name='Input data', verbose=True):
"""
tool to perform basic data validation.
called by check_X and check_y.
ensures that data:
- is ndim dimensional
- contains float-compatible data-types
- has at least min_samples
- has n_feats
- is finite
Parameters
----------
array : array-like
force_2d : boolean, default: False
whether to force a 2d array. Setting to True forces ndim = 2
n_feats : int, default: None
represents number of features that the array should have.
not enforced if n_feats is None.
ndim : int default: None
number of dimensions expected in the array
min_samples : int, default: 1
name : str, default: 'Input data'
name to use when referring to the array
verbose : bool, default: True
whether to print warnings
Returns
-------
array : validated array
"""
# make array
if force_2d:
array = make_2d(array, verbose=verbose)
ndim = 2
else:
array = np.array(array)
# cast to float
dtype = array.dtype
if dtype.kind not in ['i', 'f']:
try:
array = array.astype('float')
except ValueError as e:
raise ValueError('{} must be type int or float, '\
'but found type: {}\n'\
'Try transforming data with a LabelEncoder first.'\
.format(name, dtype.type))
# check finite
if not(np.isfinite(array).all()):
raise ValueError('{} must not contain Inf nor NaN'.format(name))
# check ndim
if ndim is not None:
if array.ndim != ndim:
raise ValueError('{} must have {} dimensions. '\
'found shape {}'.format(name, ndim, array.shape))
# check n_feats
if n_feats is not None:
m = array.shape[1]
if m != n_feats:
raise ValueError('{} must have {} features, '\
'but found {}'.format(name, n_feats, m))
# minimum samples
n = array.shape[0]
if n < min_samples:
raise ValueError('{} should have at least {} samples, '\
'but found {}'.format(name, min_samples, n))
return array | python | def check_array(array, force_2d=False, n_feats=None, ndim=None,
min_samples=1, name='Input data', verbose=True):
"""
tool to perform basic data validation.
called by check_X and check_y.
ensures that data:
- is ndim dimensional
- contains float-compatible data-types
- has at least min_samples
- has n_feats
- is finite
Parameters
----------
array : array-like
force_2d : boolean, default: False
whether to force a 2d array. Setting to True forces ndim = 2
n_feats : int, default: None
represents number of features that the array should have.
not enforced if n_feats is None.
ndim : int default: None
number of dimensions expected in the array
min_samples : int, default: 1
name : str, default: 'Input data'
name to use when referring to the array
verbose : bool, default: True
whether to print warnings
Returns
-------
array : validated array
"""
# make array
if force_2d:
array = make_2d(array, verbose=verbose)
ndim = 2
else:
array = np.array(array)
# cast to float
dtype = array.dtype
if dtype.kind not in ['i', 'f']:
try:
array = array.astype('float')
except ValueError as e:
raise ValueError('{} must be type int or float, '\
'but found type: {}\n'\
'Try transforming data with a LabelEncoder first.'\
.format(name, dtype.type))
# check finite
if not(np.isfinite(array).all()):
raise ValueError('{} must not contain Inf nor NaN'.format(name))
# check ndim
if ndim is not None:
if array.ndim != ndim:
raise ValueError('{} must have {} dimensions. '\
'found shape {}'.format(name, ndim, array.shape))
# check n_feats
if n_feats is not None:
m = array.shape[1]
if m != n_feats:
raise ValueError('{} must have {} features, '\
'but found {}'.format(name, n_feats, m))
# minimum samples
n = array.shape[0]
if n < min_samples:
raise ValueError('{} should have at least {} samples, '\
'but found {}'.format(name, min_samples, n))
return array | [
"def",
"check_array",
"(",
"array",
",",
"force_2d",
"=",
"False",
",",
"n_feats",
"=",
"None",
",",
"ndim",
"=",
"None",
",",
"min_samples",
"=",
"1",
",",
"name",
"=",
"'Input data'",
",",
"verbose",
"=",
"True",
")",
":",
"# make array",
"if",
"forc... | tool to perform basic data validation.
called by check_X and check_y.
ensures that data:
- is ndim dimensional
- contains float-compatible data-types
- has at least min_samples
- has n_feats
- is finite
Parameters
----------
array : array-like
force_2d : boolean, default: False
whether to force a 2d array. Setting to True forces ndim = 2
n_feats : int, default: None
represents number of features that the array should have.
not enforced if n_feats is None.
ndim : int default: None
number of dimensions expected in the array
min_samples : int, default: 1
name : str, default: 'Input data'
name to use when referring to the array
verbose : bool, default: True
whether to print warnings
Returns
-------
array : validated array | [
"tool",
"to",
"perform",
"basic",
"data",
"validation",
".",
"called",
"by",
"check_X",
"and",
"check_y",
"."
] | b3e5c3cd580f0a3ad69f9372861624f67760c325 | https://github.com/dswah/pyGAM/blob/b3e5c3cd580f0a3ad69f9372861624f67760c325/pygam/utils.py#L118-L192 |
225,586 | dswah/pyGAM | pygam/utils.py | check_param | def check_param(param, param_name, dtype, constraint=None, iterable=True,
max_depth=2):
"""
checks the dtype of a parameter,
and whether it satisfies a numerical contraint
Parameters
---------
param : object
param_name : str, name of the parameter
dtype : str, desired dtype of the parameter
contraint : str, default: None
numerical constraint of the parameter.
if None, no constraint is enforced
iterable : bool, default: True
whether to allow iterable param
max_depth : int, default: 2
maximum nesting of the iterable.
only used if iterable == True
Returns
-------
list of validated and converted parameter(s)
"""
msg = []
msg.append(param_name + " must be "+ dtype)
if iterable:
msg.append(" or nested iterable of depth " + str(max_depth) +
" containing " + dtype + "s")
msg.append(", but found " + param_name + " = {}".format(repr(param)))
if constraint is not None:
msg = (" " + constraint).join(msg)
else:
msg = ''.join(msg)
# check param is numerical
try:
param_dt = np.array(flatten(param))# + np.zeros_like(flatten(param), dtype='int')
# param_dt = np.array(param).astype(dtype)
except (ValueError, TypeError):
raise TypeError(msg)
# check iterable
if iterable:
if check_iterable_depth(param) > max_depth:
raise TypeError(msg)
if (not iterable) and isiterable(param):
raise TypeError(msg)
# check param is correct dtype
if not (param_dt == np.array(flatten(param)).astype(float)).all():
raise TypeError(msg)
# check constraint
if constraint is not None:
if not (eval('np.' + repr(param_dt) + constraint)).all():
raise ValueError(msg)
return param | python | def check_param(param, param_name, dtype, constraint=None, iterable=True,
max_depth=2):
"""
checks the dtype of a parameter,
and whether it satisfies a numerical contraint
Parameters
---------
param : object
param_name : str, name of the parameter
dtype : str, desired dtype of the parameter
contraint : str, default: None
numerical constraint of the parameter.
if None, no constraint is enforced
iterable : bool, default: True
whether to allow iterable param
max_depth : int, default: 2
maximum nesting of the iterable.
only used if iterable == True
Returns
-------
list of validated and converted parameter(s)
"""
msg = []
msg.append(param_name + " must be "+ dtype)
if iterable:
msg.append(" or nested iterable of depth " + str(max_depth) +
" containing " + dtype + "s")
msg.append(", but found " + param_name + " = {}".format(repr(param)))
if constraint is not None:
msg = (" " + constraint).join(msg)
else:
msg = ''.join(msg)
# check param is numerical
try:
param_dt = np.array(flatten(param))# + np.zeros_like(flatten(param), dtype='int')
# param_dt = np.array(param).astype(dtype)
except (ValueError, TypeError):
raise TypeError(msg)
# check iterable
if iterable:
if check_iterable_depth(param) > max_depth:
raise TypeError(msg)
if (not iterable) and isiterable(param):
raise TypeError(msg)
# check param is correct dtype
if not (param_dt == np.array(flatten(param)).astype(float)).all():
raise TypeError(msg)
# check constraint
if constraint is not None:
if not (eval('np.' + repr(param_dt) + constraint)).all():
raise ValueError(msg)
return param | [
"def",
"check_param",
"(",
"param",
",",
"param_name",
",",
"dtype",
",",
"constraint",
"=",
"None",
",",
"iterable",
"=",
"True",
",",
"max_depth",
"=",
"2",
")",
":",
"msg",
"=",
"[",
"]",
"msg",
".",
"append",
"(",
"param_name",
"+",
"\" must be \""... | checks the dtype of a parameter,
and whether it satisfies a numerical contraint
Parameters
---------
param : object
param_name : str, name of the parameter
dtype : str, desired dtype of the parameter
contraint : str, default: None
numerical constraint of the parameter.
if None, no constraint is enforced
iterable : bool, default: True
whether to allow iterable param
max_depth : int, default: 2
maximum nesting of the iterable.
only used if iterable == True
Returns
-------
list of validated and converted parameter(s) | [
"checks",
"the",
"dtype",
"of",
"a",
"parameter",
"and",
"whether",
"it",
"satisfies",
"a",
"numerical",
"contraint"
] | b3e5c3cd580f0a3ad69f9372861624f67760c325 | https://github.com/dswah/pyGAM/blob/b3e5c3cd580f0a3ad69f9372861624f67760c325/pygam/utils.py#L341-L400 |
225,587 | dswah/pyGAM | pygam/utils.py | get_link_domain | def get_link_domain(link, dist):
"""
tool to identify the domain of a given monotonic link function
Parameters
----------
link : Link object
dist : Distribution object
Returns
-------
domain : list of length 2, representing the interval of the domain.
"""
domain = np.array([-np.inf, -1, 0, 1, np.inf])
domain = domain[~np.isnan(link.link(domain, dist))]
return [domain[0], domain[-1]] | python | def get_link_domain(link, dist):
"""
tool to identify the domain of a given monotonic link function
Parameters
----------
link : Link object
dist : Distribution object
Returns
-------
domain : list of length 2, representing the interval of the domain.
"""
domain = np.array([-np.inf, -1, 0, 1, np.inf])
domain = domain[~np.isnan(link.link(domain, dist))]
return [domain[0], domain[-1]] | [
"def",
"get_link_domain",
"(",
"link",
",",
"dist",
")",
":",
"domain",
"=",
"np",
".",
"array",
"(",
"[",
"-",
"np",
".",
"inf",
",",
"-",
"1",
",",
"0",
",",
"1",
",",
"np",
".",
"inf",
"]",
")",
"domain",
"=",
"domain",
"[",
"~",
"np",
"... | tool to identify the domain of a given monotonic link function
Parameters
----------
link : Link object
dist : Distribution object
Returns
-------
domain : list of length 2, representing the interval of the domain. | [
"tool",
"to",
"identify",
"the",
"domain",
"of",
"a",
"given",
"monotonic",
"link",
"function"
] | b3e5c3cd580f0a3ad69f9372861624f67760c325 | https://github.com/dswah/pyGAM/blob/b3e5c3cd580f0a3ad69f9372861624f67760c325/pygam/utils.py#L402-L417 |
225,588 | dswah/pyGAM | pygam/utils.py | load_diagonal | def load_diagonal(cov, load=None):
"""Return the given square matrix with a small amount added to the diagonal
to make it positive semi-definite.
"""
n, m = cov.shape
assert n == m, "matrix must be square, but found shape {}".format((n, m))
if load is None:
load = np.sqrt(np.finfo(np.float64).eps) # machine epsilon
return cov + np.eye(n) * load | python | def load_diagonal(cov, load=None):
"""Return the given square matrix with a small amount added to the diagonal
to make it positive semi-definite.
"""
n, m = cov.shape
assert n == m, "matrix must be square, but found shape {}".format((n, m))
if load is None:
load = np.sqrt(np.finfo(np.float64).eps) # machine epsilon
return cov + np.eye(n) * load | [
"def",
"load_diagonal",
"(",
"cov",
",",
"load",
"=",
"None",
")",
":",
"n",
",",
"m",
"=",
"cov",
".",
"shape",
"assert",
"n",
"==",
"m",
",",
"\"matrix must be square, but found shape {}\"",
".",
"format",
"(",
"(",
"n",
",",
"m",
")",
")",
"if",
"... | Return the given square matrix with a small amount added to the diagonal
to make it positive semi-definite. | [
"Return",
"the",
"given",
"square",
"matrix",
"with",
"a",
"small",
"amount",
"added",
"to",
"the",
"diagonal",
"to",
"make",
"it",
"positive",
"semi",
"-",
"definite",
"."
] | b3e5c3cd580f0a3ad69f9372861624f67760c325 | https://github.com/dswah/pyGAM/blob/b3e5c3cd580f0a3ad69f9372861624f67760c325/pygam/utils.py#L420-L429 |
225,589 | dswah/pyGAM | pygam/utils.py | round_to_n_decimal_places | def round_to_n_decimal_places(array, n=3):
"""
tool to keep round a float to n decimal places.
n=3 by default
Parameters
----------
array : np.array
n : int. number of decimal places to keep
Returns
-------
array : rounded np.array
"""
# check if in scientific notation
if issubclass(array.__class__, float) and '%.e'%array == str(array):
return array # do nothing
shape = np.shape(array)
out = ((np.atleast_1d(array) * 10**n).round().astype('int') / (10.**n))
return out.reshape(shape) | python | def round_to_n_decimal_places(array, n=3):
"""
tool to keep round a float to n decimal places.
n=3 by default
Parameters
----------
array : np.array
n : int. number of decimal places to keep
Returns
-------
array : rounded np.array
"""
# check if in scientific notation
if issubclass(array.__class__, float) and '%.e'%array == str(array):
return array # do nothing
shape = np.shape(array)
out = ((np.atleast_1d(array) * 10**n).round().astype('int') / (10.**n))
return out.reshape(shape) | [
"def",
"round_to_n_decimal_places",
"(",
"array",
",",
"n",
"=",
"3",
")",
":",
"# check if in scientific notation",
"if",
"issubclass",
"(",
"array",
".",
"__class__",
",",
"float",
")",
"and",
"'%.e'",
"%",
"array",
"==",
"str",
"(",
"array",
")",
":",
"... | tool to keep round a float to n decimal places.
n=3 by default
Parameters
----------
array : np.array
n : int. number of decimal places to keep
Returns
-------
array : rounded np.array | [
"tool",
"to",
"keep",
"round",
"a",
"float",
"to",
"n",
"decimal",
"places",
"."
] | b3e5c3cd580f0a3ad69f9372861624f67760c325 | https://github.com/dswah/pyGAM/blob/b3e5c3cd580f0a3ad69f9372861624f67760c325/pygam/utils.py#L432-L453 |
225,590 | dswah/pyGAM | pygam/utils.py | space_row | def space_row(left, right, filler=' ', total_width=-1):
"""space the data in a row with optional filling
Arguments
---------
left : str, to be aligned left
right : str, to be aligned right
filler : str, default ' '.
must be of length 1
total_width : int, width of line.
if negative number is specified,
then that number of spaces is used between the left and right text
Returns
-------
str
"""
left = str(left)
right = str(right)
filler = str(filler)[:1]
if total_width < 0:
spacing = - total_width
else:
spacing = total_width - len(left) - len(right)
return left + filler * spacing + right | python | def space_row(left, right, filler=' ', total_width=-1):
"""space the data in a row with optional filling
Arguments
---------
left : str, to be aligned left
right : str, to be aligned right
filler : str, default ' '.
must be of length 1
total_width : int, width of line.
if negative number is specified,
then that number of spaces is used between the left and right text
Returns
-------
str
"""
left = str(left)
right = str(right)
filler = str(filler)[:1]
if total_width < 0:
spacing = - total_width
else:
spacing = total_width - len(left) - len(right)
return left + filler * spacing + right | [
"def",
"space_row",
"(",
"left",
",",
"right",
",",
"filler",
"=",
"' '",
",",
"total_width",
"=",
"-",
"1",
")",
":",
"left",
"=",
"str",
"(",
"left",
")",
"right",
"=",
"str",
"(",
"right",
")",
"filler",
"=",
"str",
"(",
"filler",
")",
"[",
... | space the data in a row with optional filling
Arguments
---------
left : str, to be aligned left
right : str, to be aligned right
filler : str, default ' '.
must be of length 1
total_width : int, width of line.
if negative number is specified,
then that number of spaces is used between the left and right text
Returns
-------
str | [
"space",
"the",
"data",
"in",
"a",
"row",
"with",
"optional",
"filling"
] | b3e5c3cd580f0a3ad69f9372861624f67760c325 | https://github.com/dswah/pyGAM/blob/b3e5c3cd580f0a3ad69f9372861624f67760c325/pygam/utils.py#L489-L515 |
225,591 | dswah/pyGAM | pygam/utils.py | gen_edge_knots | def gen_edge_knots(data, dtype, verbose=True):
"""
generate uniform knots from data including the edges of the data
for discrete data, assumes k categories in [0, k-1] interval
Parameters
----------
data : array-like with one dimension
dtype : str in {'categorical', 'numerical'}
verbose : bool, default: True
whether to print warnings
Returns
-------
np.array containing ordered knots
"""
if dtype not in ['categorical', 'numerical']:
raise ValueError('unsupported dtype: {}'.format(dtype))
if dtype == 'categorical':
return np.r_[np.min(data) - 0.5, np.max(data) + 0.5]
else:
knots = np.r_[np.min(data), np.max(data)]
if knots[0] == knots[1] and verbose:
warnings.warn('Data contains constant feature. '\
'Consider removing and setting fit_intercept=True',
stacklevel=2)
return knots | python | def gen_edge_knots(data, dtype, verbose=True):
"""
generate uniform knots from data including the edges of the data
for discrete data, assumes k categories in [0, k-1] interval
Parameters
----------
data : array-like with one dimension
dtype : str in {'categorical', 'numerical'}
verbose : bool, default: True
whether to print warnings
Returns
-------
np.array containing ordered knots
"""
if dtype not in ['categorical', 'numerical']:
raise ValueError('unsupported dtype: {}'.format(dtype))
if dtype == 'categorical':
return np.r_[np.min(data) - 0.5, np.max(data) + 0.5]
else:
knots = np.r_[np.min(data), np.max(data)]
if knots[0] == knots[1] and verbose:
warnings.warn('Data contains constant feature. '\
'Consider removing and setting fit_intercept=True',
stacklevel=2)
return knots | [
"def",
"gen_edge_knots",
"(",
"data",
",",
"dtype",
",",
"verbose",
"=",
"True",
")",
":",
"if",
"dtype",
"not",
"in",
"[",
"'categorical'",
",",
"'numerical'",
"]",
":",
"raise",
"ValueError",
"(",
"'unsupported dtype: {}'",
".",
"format",
"(",
"dtype",
"... | generate uniform knots from data including the edges of the data
for discrete data, assumes k categories in [0, k-1] interval
Parameters
----------
data : array-like with one dimension
dtype : str in {'categorical', 'numerical'}
verbose : bool, default: True
whether to print warnings
Returns
-------
np.array containing ordered knots | [
"generate",
"uniform",
"knots",
"from",
"data",
"including",
"the",
"edges",
"of",
"the",
"data"
] | b3e5c3cd580f0a3ad69f9372861624f67760c325 | https://github.com/dswah/pyGAM/blob/b3e5c3cd580f0a3ad69f9372861624f67760c325/pygam/utils.py#L539-L566 |
225,592 | dswah/pyGAM | pygam/utils.py | ylogydu | def ylogydu(y, u):
"""
tool to give desired output for the limit as y -> 0, which is 0
Parameters
----------
y : array-like of len(n)
u : array-like of len(n)
Returns
-------
np.array len(n)
"""
mask = (np.atleast_1d(y)!=0.)
out = np.zeros_like(u)
out[mask] = y[mask] * np.log(y[mask] / u[mask])
return out | python | def ylogydu(y, u):
"""
tool to give desired output for the limit as y -> 0, which is 0
Parameters
----------
y : array-like of len(n)
u : array-like of len(n)
Returns
-------
np.array len(n)
"""
mask = (np.atleast_1d(y)!=0.)
out = np.zeros_like(u)
out[mask] = y[mask] * np.log(y[mask] / u[mask])
return out | [
"def",
"ylogydu",
"(",
"y",
",",
"u",
")",
":",
"mask",
"=",
"(",
"np",
".",
"atleast_1d",
"(",
"y",
")",
"!=",
"0.",
")",
"out",
"=",
"np",
".",
"zeros_like",
"(",
"u",
")",
"out",
"[",
"mask",
"]",
"=",
"y",
"[",
"mask",
"]",
"*",
"np",
... | tool to give desired output for the limit as y -> 0, which is 0
Parameters
----------
y : array-like of len(n)
u : array-like of len(n)
Returns
-------
np.array len(n) | [
"tool",
"to",
"give",
"desired",
"output",
"for",
"the",
"limit",
"as",
"y",
"-",
">",
"0",
"which",
"is",
"0"
] | b3e5c3cd580f0a3ad69f9372861624f67760c325 | https://github.com/dswah/pyGAM/blob/b3e5c3cd580f0a3ad69f9372861624f67760c325/pygam/utils.py#L710-L726 |
225,593 | dswah/pyGAM | pygam/utils.py | combine | def combine(*args):
"""
tool to perform tree search via recursion
useful for developing the grid in a grid search
Parameters
----------
args : list of lists
Returns
-------
list of all the combinations of the elements in the input lists
"""
if hasattr(args, '__iter__') and (len(args) > 1):
subtree = combine(*args[:-1])
tree = []
for leaf in subtree:
for node in args[-1]:
if hasattr(leaf, '__iter__'):
tree.append(leaf + [node])
else:
tree.append([leaf] + [node])
return tree
else:
return [[arg] for arg in args[0]] | python | def combine(*args):
"""
tool to perform tree search via recursion
useful for developing the grid in a grid search
Parameters
----------
args : list of lists
Returns
-------
list of all the combinations of the elements in the input lists
"""
if hasattr(args, '__iter__') and (len(args) > 1):
subtree = combine(*args[:-1])
tree = []
for leaf in subtree:
for node in args[-1]:
if hasattr(leaf, '__iter__'):
tree.append(leaf + [node])
else:
tree.append([leaf] + [node])
return tree
else:
return [[arg] for arg in args[0]] | [
"def",
"combine",
"(",
"*",
"args",
")",
":",
"if",
"hasattr",
"(",
"args",
",",
"'__iter__'",
")",
"and",
"(",
"len",
"(",
"args",
")",
">",
"1",
")",
":",
"subtree",
"=",
"combine",
"(",
"*",
"args",
"[",
":",
"-",
"1",
"]",
")",
"tree",
"=... | tool to perform tree search via recursion
useful for developing the grid in a grid search
Parameters
----------
args : list of lists
Returns
-------
list of all the combinations of the elements in the input lists | [
"tool",
"to",
"perform",
"tree",
"search",
"via",
"recursion",
"useful",
"for",
"developing",
"the",
"grid",
"in",
"a",
"grid",
"search"
] | b3e5c3cd580f0a3ad69f9372861624f67760c325 | https://github.com/dswah/pyGAM/blob/b3e5c3cd580f0a3ad69f9372861624f67760c325/pygam/utils.py#L729-L753 |
225,594 | dswah/pyGAM | pygam/utils.py | isiterable | def isiterable(obj, reject_string=True):
"""convenience tool to detect if something is iterable.
in python3, strings count as iterables to we have the option to exclude them
Parameters:
-----------
obj : object to analyse
reject_string : bool, whether to ignore strings
Returns:
--------
bool, if the object is itereable.
"""
iterable = hasattr(obj, '__len__')
if reject_string:
iterable = iterable and not isinstance(obj, str)
return iterable | python | def isiterable(obj, reject_string=True):
"""convenience tool to detect if something is iterable.
in python3, strings count as iterables to we have the option to exclude them
Parameters:
-----------
obj : object to analyse
reject_string : bool, whether to ignore strings
Returns:
--------
bool, if the object is itereable.
"""
iterable = hasattr(obj, '__len__')
if reject_string:
iterable = iterable and not isinstance(obj, str)
return iterable | [
"def",
"isiterable",
"(",
"obj",
",",
"reject_string",
"=",
"True",
")",
":",
"iterable",
"=",
"hasattr",
"(",
"obj",
",",
"'__len__'",
")",
"if",
"reject_string",
":",
"iterable",
"=",
"iterable",
"and",
"not",
"isinstance",
"(",
"obj",
",",
"str",
")",... | convenience tool to detect if something is iterable.
in python3, strings count as iterables to we have the option to exclude them
Parameters:
-----------
obj : object to analyse
reject_string : bool, whether to ignore strings
Returns:
--------
bool, if the object is itereable. | [
"convenience",
"tool",
"to",
"detect",
"if",
"something",
"is",
"iterable",
".",
"in",
"python3",
"strings",
"count",
"as",
"iterables",
"to",
"we",
"have",
"the",
"option",
"to",
"exclude",
"them"
] | b3e5c3cd580f0a3ad69f9372861624f67760c325 | https://github.com/dswah/pyGAM/blob/b3e5c3cd580f0a3ad69f9372861624f67760c325/pygam/utils.py#L755-L774 |
225,595 | dswah/pyGAM | pygam/utils.py | check_iterable_depth | def check_iterable_depth(obj, max_depth=100):
"""find the maximum depth of nesting of the iterable
Parameters
----------
obj : iterable
max_depth : int, default: 100
maximum depth beyond which we stop counting
Returns
-------
int
"""
def find_iterables(obj):
iterables = []
for item in obj:
if isiterable(item):
iterables += list(item)
return iterables
depth = 0
while (depth < max_depth) and isiterable(obj) and len(obj) > 0:
depth += 1
obj = find_iterables(obj)
return depth | python | def check_iterable_depth(obj, max_depth=100):
"""find the maximum depth of nesting of the iterable
Parameters
----------
obj : iterable
max_depth : int, default: 100
maximum depth beyond which we stop counting
Returns
-------
int
"""
def find_iterables(obj):
iterables = []
for item in obj:
if isiterable(item):
iterables += list(item)
return iterables
depth = 0
while (depth < max_depth) and isiterable(obj) and len(obj) > 0:
depth += 1
obj = find_iterables(obj)
return depth | [
"def",
"check_iterable_depth",
"(",
"obj",
",",
"max_depth",
"=",
"100",
")",
":",
"def",
"find_iterables",
"(",
"obj",
")",
":",
"iterables",
"=",
"[",
"]",
"for",
"item",
"in",
"obj",
":",
"if",
"isiterable",
"(",
"item",
")",
":",
"iterables",
"+=",... | find the maximum depth of nesting of the iterable
Parameters
----------
obj : iterable
max_depth : int, default: 100
maximum depth beyond which we stop counting
Returns
-------
int | [
"find",
"the",
"maximum",
"depth",
"of",
"nesting",
"of",
"the",
"iterable"
] | b3e5c3cd580f0a3ad69f9372861624f67760c325 | https://github.com/dswah/pyGAM/blob/b3e5c3cd580f0a3ad69f9372861624f67760c325/pygam/utils.py#L776-L800 |
225,596 | dswah/pyGAM | pygam/utils.py | flatten | def flatten(iterable):
"""convenience tool to flatten any nested iterable
example:
flatten([[[],[4]],[[[5,[6,7, []]]]]])
>>> [4, 5, 6, 7]
flatten('hello')
>>> 'hello'
Parameters
----------
iterable
Returns
-------
flattened object
"""
if isiterable(iterable):
flat = []
for item in list(iterable):
item = flatten(item)
if not isiterable(item):
item = [item]
flat += item
return flat
else:
return iterable | python | def flatten(iterable):
"""convenience tool to flatten any nested iterable
example:
flatten([[[],[4]],[[[5,[6,7, []]]]]])
>>> [4, 5, 6, 7]
flatten('hello')
>>> 'hello'
Parameters
----------
iterable
Returns
-------
flattened object
"""
if isiterable(iterable):
flat = []
for item in list(iterable):
item = flatten(item)
if not isiterable(item):
item = [item]
flat += item
return flat
else:
return iterable | [
"def",
"flatten",
"(",
"iterable",
")",
":",
"if",
"isiterable",
"(",
"iterable",
")",
":",
"flat",
"=",
"[",
"]",
"for",
"item",
"in",
"list",
"(",
"iterable",
")",
":",
"item",
"=",
"flatten",
"(",
"item",
")",
"if",
"not",
"isiterable",
"(",
"it... | convenience tool to flatten any nested iterable
example:
flatten([[[],[4]],[[[5,[6,7, []]]]]])
>>> [4, 5, 6, 7]
flatten('hello')
>>> 'hello'
Parameters
----------
iterable
Returns
-------
flattened object | [
"convenience",
"tool",
"to",
"flatten",
"any",
"nested",
"iterable"
] | b3e5c3cd580f0a3ad69f9372861624f67760c325 | https://github.com/dswah/pyGAM/blob/b3e5c3cd580f0a3ad69f9372861624f67760c325/pygam/utils.py#L802-L830 |
225,597 | dswah/pyGAM | pygam/utils.py | tensor_product | def tensor_product(a, b, reshape=True):
"""
compute the tensor protuct of two matrices a and b
if a is (n, m_a), b is (n, m_b),
then the result is
(n, m_a * m_b) if reshape = True.
or
(n, m_a, m_b) otherwise
Parameters
---------
a : array-like of shape (n, m_a)
b : array-like of shape (n, m_b)
reshape : bool, default True
whether to reshape the result to be 2-dimensional ie
(n, m_a * m_b)
or return a 3-dimensional tensor ie
(n, m_a, m_b)
Returns
-------
dense np.ndarray of shape
(n, m_a * m_b) if reshape = True.
or
(n, m_a, m_b) otherwise
"""
assert a.ndim == 2, 'matrix a must be 2-dimensional, but found {} dimensions'.format(a.ndim)
assert b.ndim == 2, 'matrix b must be 2-dimensional, but found {} dimensions'.format(b.ndim)
na, ma = a.shape
nb, mb = b.shape
if na != nb:
raise ValueError('both arguments must have the same number of samples')
if sp.sparse.issparse(a):
a = a.A
if sp.sparse.issparse(b):
b = b.A
tensor = a[..., :, None] * b[..., None, :]
if reshape:
return tensor.reshape(na, ma * mb)
return tensor | python | def tensor_product(a, b, reshape=True):
"""
compute the tensor protuct of two matrices a and b
if a is (n, m_a), b is (n, m_b),
then the result is
(n, m_a * m_b) if reshape = True.
or
(n, m_a, m_b) otherwise
Parameters
---------
a : array-like of shape (n, m_a)
b : array-like of shape (n, m_b)
reshape : bool, default True
whether to reshape the result to be 2-dimensional ie
(n, m_a * m_b)
or return a 3-dimensional tensor ie
(n, m_a, m_b)
Returns
-------
dense np.ndarray of shape
(n, m_a * m_b) if reshape = True.
or
(n, m_a, m_b) otherwise
"""
assert a.ndim == 2, 'matrix a must be 2-dimensional, but found {} dimensions'.format(a.ndim)
assert b.ndim == 2, 'matrix b must be 2-dimensional, but found {} dimensions'.format(b.ndim)
na, ma = a.shape
nb, mb = b.shape
if na != nb:
raise ValueError('both arguments must have the same number of samples')
if sp.sparse.issparse(a):
a = a.A
if sp.sparse.issparse(b):
b = b.A
tensor = a[..., :, None] * b[..., None, :]
if reshape:
return tensor.reshape(na, ma * mb)
return tensor | [
"def",
"tensor_product",
"(",
"a",
",",
"b",
",",
"reshape",
"=",
"True",
")",
":",
"assert",
"a",
".",
"ndim",
"==",
"2",
",",
"'matrix a must be 2-dimensional, but found {} dimensions'",
".",
"format",
"(",
"a",
".",
"ndim",
")",
"assert",
"b",
".",
"ndi... | compute the tensor protuct of two matrices a and b
if a is (n, m_a), b is (n, m_b),
then the result is
(n, m_a * m_b) if reshape = True.
or
(n, m_a, m_b) otherwise
Parameters
---------
a : array-like of shape (n, m_a)
b : array-like of shape (n, m_b)
reshape : bool, default True
whether to reshape the result to be 2-dimensional ie
(n, m_a * m_b)
or return a 3-dimensional tensor ie
(n, m_a, m_b)
Returns
-------
dense np.ndarray of shape
(n, m_a * m_b) if reshape = True.
or
(n, m_a, m_b) otherwise | [
"compute",
"the",
"tensor",
"protuct",
"of",
"two",
"matrices",
"a",
"and",
"b"
] | b3e5c3cd580f0a3ad69f9372861624f67760c325 | https://github.com/dswah/pyGAM/blob/b3e5c3cd580f0a3ad69f9372861624f67760c325/pygam/utils.py#L833-L882 |
225,598 | dswah/pyGAM | pygam/links.py | LogitLink.link | def link(self, mu, dist):
"""
glm link function
this is useful for going from mu to the linear prediction
Parameters
----------
mu : array-like of legth n
dist : Distribution instance
Returns
-------
lp : np.array of length n
"""
return np.log(mu) - np.log(dist.levels - mu) | python | def link(self, mu, dist):
"""
glm link function
this is useful for going from mu to the linear prediction
Parameters
----------
mu : array-like of legth n
dist : Distribution instance
Returns
-------
lp : np.array of length n
"""
return np.log(mu) - np.log(dist.levels - mu) | [
"def",
"link",
"(",
"self",
",",
"mu",
",",
"dist",
")",
":",
"return",
"np",
".",
"log",
"(",
"mu",
")",
"-",
"np",
".",
"log",
"(",
"dist",
".",
"levels",
"-",
"mu",
")"
] | glm link function
this is useful for going from mu to the linear prediction
Parameters
----------
mu : array-like of legth n
dist : Distribution instance
Returns
-------
lp : np.array of length n | [
"glm",
"link",
"function",
"this",
"is",
"useful",
"for",
"going",
"from",
"mu",
"to",
"the",
"linear",
"prediction"
] | b3e5c3cd580f0a3ad69f9372861624f67760c325 | https://github.com/dswah/pyGAM/blob/b3e5c3cd580f0a3ad69f9372861624f67760c325/pygam/links.py#L103-L117 |
225,599 | dswah/pyGAM | pygam/links.py | LogitLink.mu | def mu(self, lp, dist):
"""
glm mean function, ie inverse of link function
this is useful for going from the linear prediction to mu
Parameters
----------
lp : array-like of legth n
dist : Distribution instance
Returns
-------
mu : np.array of length n
"""
elp = np.exp(lp)
return dist.levels * elp / (elp + 1) | python | def mu(self, lp, dist):
"""
glm mean function, ie inverse of link function
this is useful for going from the linear prediction to mu
Parameters
----------
lp : array-like of legth n
dist : Distribution instance
Returns
-------
mu : np.array of length n
"""
elp = np.exp(lp)
return dist.levels * elp / (elp + 1) | [
"def",
"mu",
"(",
"self",
",",
"lp",
",",
"dist",
")",
":",
"elp",
"=",
"np",
".",
"exp",
"(",
"lp",
")",
"return",
"dist",
".",
"levels",
"*",
"elp",
"/",
"(",
"elp",
"+",
"1",
")"
] | glm mean function, ie inverse of link function
this is useful for going from the linear prediction to mu
Parameters
----------
lp : array-like of legth n
dist : Distribution instance
Returns
-------
mu : np.array of length n | [
"glm",
"mean",
"function",
"ie",
"inverse",
"of",
"link",
"function",
"this",
"is",
"useful",
"for",
"going",
"from",
"the",
"linear",
"prediction",
"to",
"mu"
] | b3e5c3cd580f0a3ad69f9372861624f67760c325 | https://github.com/dswah/pyGAM/blob/b3e5c3cd580f0a3ad69f9372861624f67760c325/pygam/links.py#L119-L134 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.