_id stringlengths 2 7 | title stringlengths 1 88 | partition stringclasses 3
values | text stringlengths 75 19.8k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q31100 | infer_slice | train | def infer_slice(node, context=None):
"""Understand `slice` calls."""
args = node.args
if not 0 < len(args) <= 3:
raise UseInferenceDefault
infer_func = partial(helpers.safe_infer, context=context)
args = [infer_func(arg) for arg in args]
for arg in args:
if not arg or arg is uti... | python | {
"resource": ""
} |
q31101 | infer_isinstance | train | def infer_isinstance(callnode, context=None):
"""Infer isinstance calls
:param nodes.Call callnode: an isinstance call
:param InferenceContext: context for call
(currently unused but is a common interface for inference)
:rtype nodes.Const: Boolean Const value of isinstance call
:raises Use... | python | {
"resource": ""
} |
q31102 | infer_len | train | def infer_len(node, context=None):
"""Infer length calls
:param nodes.Call node: len call to infer
:param context.InferenceContext: node context
:rtype nodes.Const: a Const node with the inferred length, if possible
"""
call = arguments.CallSite.from_call(node)
if call.keyword_arguments:
... | python | {
"resource": ""
} |
q31103 | infer_dict_fromkeys | train | def infer_dict_fromkeys(node, context=None):
"""Infer dict.fromkeys
:param nodes.Call node: dict.fromkeys() call to infer
:param context.InferenceContext: node context
:rtype nodes.Dict:
a Dictionary containing the values that astroid was able to infer.
In case the inference failed for ... | python | {
"resource": ""
} |
q31104 | AsStringVisitor._stmt_list | train | def _stmt_list(self, stmts, indent=True):
"""return a list of nodes to string"""
stmts = "\n".join(nstr for nstr in [n.accept(self) for n in stmts] if nstr)
if indent:
return self.indent + stmts.replace("\n", "\n" + self.indent)
return stmts | python | {
"resource": ""
} |
q31105 | AsStringVisitor._precedence_parens | train | def _precedence_parens(self, node, child, is_left=True):
"""Wrap child in parens only if required to keep same semantics"""
if self._should_wrap(node, child, is_left):
return "(%s)" % child.accept(self)
return child.accept(self) | python | {
"resource": ""
} |
q31106 | AsStringVisitor.visit_assert | train | def visit_assert(self, node):
"""return an astroid.Assert node as string"""
if node.fail:
return "assert %s, %s" % (node.test.accept(self), node.fail.accept(self))
return "assert %s" % node.test.accept(self) | python | {
"resource": ""
} |
q31107 | AsStringVisitor.visit_assign | train | def visit_assign(self, node):
"""return an astroid.Assign node as string"""
lhs = " = ".join(n.accept(self) for n in node.targets)
return "%s = %s" % (lhs, node.value.accept(self)) | python | {
"resource": ""
} |
q31108 | AsStringVisitor.visit_augassign | train | def visit_augassign(self, node):
"""return an astroid.AugAssign node as string"""
return "%s %s %s" % (node.target.accept(self), node.op, node.value.accept(self)) | python | {
"resource": ""
} |
q31109 | AsStringVisitor.visit_annassign | train | def visit_annassign(self, node):
"""Return an astroid.AugAssign node as string"""
target = node.target.accept(self)
annotation = node.annotation.accept(self)
if node.value is None:
return "%s: %s" % (target, annotation)
return "%s: %s = %s" % (target, annotation, nod... | python | {
"resource": ""
} |
q31110 | AsStringVisitor.visit_binop | train | def visit_binop(self, node):
"""return an astroid.BinOp node as string"""
left = self._precedence_parens(node, node.left)
right = self._precedence_parens(node, node.right, is_left=False)
if node.op == "**":
return "%s%s%s" % (left, node.op, right)
return "%s %s %s" %... | python | {
"resource": ""
} |
q31111 | AsStringVisitor.visit_boolop | train | def visit_boolop(self, node):
"""return an astroid.BoolOp node as string"""
values = ["%s" % self._precedence_parens(node, n) for n in node.values]
return (" %s " % node.op).join(values) | python | {
"resource": ""
} |
q31112 | AsStringVisitor.visit_call | train | def visit_call(self, node):
"""return an astroid.Call node as string"""
expr_str = self._precedence_parens(node, node.func)
args = [arg.accept(self) for arg in node.args]
if node.keywords:
keywords = [kwarg.accept(self) for kwarg in node.keywords]
else:
ke... | python | {
"resource": ""
} |
q31113 | AsStringVisitor.visit_classdef | train | def visit_classdef(self, node):
"""return an astroid.ClassDef node as string"""
decorate = node.decorators.accept(self) if node.decorators else ""
bases = ", ".join(n.accept(self) for n in node.bases)
metaclass = node.metaclass()
if metaclass and not node.has_metaclass_hack():
... | python | {
"resource": ""
} |
q31114 | AsStringVisitor.visit_compare | train | def visit_compare(self, node):
"""return an astroid.Compare node as string"""
rhs_str = " ".join(
[
"%s %s" % (op, self._precedence_parens(node, expr, is_left=False))
for op, expr in node.ops
]
)
return "%s %s" % (self._precedence_p... | python | {
"resource": ""
} |
q31115 | AsStringVisitor.visit_delete | train | def visit_delete(self, node): # XXX check if correct
"""return an astroid.Delete node as string"""
return "del %s" % ", ".join(child.accept(self) for child in node.targets) | python | {
"resource": ""
} |
q31116 | AsStringVisitor.visit_decorators | train | def visit_decorators(self, node):
"""return an astroid.Decorators node as string"""
return "@%s\n" % "\n@".join(item.accept(self) for item in node.nodes) | python | {
"resource": ""
} |
q31117 | AsStringVisitor.visit_dictcomp | train | def visit_dictcomp(self, node):
"""return an astroid.DictComp node as string"""
return "{%s: %s %s}" % (
node.key.accept(self),
node.value.accept(self),
" ".join(n.accept(self) for n in node.generators),
) | python | {
"resource": ""
} |
q31118 | AsStringVisitor.visit_exec | train | def visit_exec(self, node):
"""return an astroid.Exec node as string"""
if node.locals:
return "exec %s in %s, %s" % (
node.expr.accept(self),
node.locals.accept(self),
node.globals.accept(self),
)
if node.globals:
... | python | {
"resource": ""
} |
q31119 | AsStringVisitor.visit_extslice | train | def visit_extslice(self, node):
"""return an astroid.ExtSlice node as string"""
return ", ".join(dim.accept(self) for dim in node.dims) | python | {
"resource": ""
} |
q31120 | AsStringVisitor.visit_for | train | def visit_for(self, node):
"""return an astroid.For node as string"""
fors = "for %s in %s:\n%s" % (
node.target.accept(self),
node.iter.accept(self),
self._stmt_list(node.body),
)
if node.orelse:
fors = "%s\nelse:\n%s" % (fors, self._stmt_... | python | {
"resource": ""
} |
q31121 | AsStringVisitor.visit_importfrom | train | def visit_importfrom(self, node):
"""return an astroid.ImportFrom node as string"""
return "from %s import %s" % (
"." * (node.level or 0) + node.modname,
_import_string(node.names),
) | python | {
"resource": ""
} |
q31122 | AsStringVisitor.visit_functiondef | train | def visit_functiondef(self, node):
"""return an astroid.Function node as string"""
decorate = node.decorators.accept(self) if node.decorators else ""
docs = self._docs_dedent(node.doc) if node.doc else ""
trailer = ":"
if node.returns:
return_annotation = "->" + node.... | python | {
"resource": ""
} |
q31123 | AsStringVisitor.visit_generatorexp | train | def visit_generatorexp(self, node):
"""return an astroid.GeneratorExp node as string"""
return "(%s %s)" % (
node.elt.accept(self),
" ".join(n.accept(self) for n in node.generators),
) | python | {
"resource": ""
} |
q31124 | AsStringVisitor.visit_attribute | train | def visit_attribute(self, node):
"""return an astroid.Getattr node as string"""
return "%s.%s" % (self._precedence_parens(node, node.expr), node.attrname) | python | {
"resource": ""
} |
q31125 | AsStringVisitor.visit_if | train | def visit_if(self, node):
"""return an astroid.If node as string"""
ifs = ["if %s:\n%s" % (node.test.accept(self), self._stmt_list(node.body))]
if node.has_elif_block():
ifs.append("el%s" % self._stmt_list(node.orelse, indent=False))
elif node.orelse:
ifs.append("... | python | {
"resource": ""
} |
q31126 | AsStringVisitor.visit_ifexp | train | def visit_ifexp(self, node):
"""return an astroid.IfExp node as string"""
return "%s if %s else %s" % (
self._precedence_parens(node, node.body, is_left=True),
self._precedence_parens(node, node.test, is_left=True),
self._precedence_parens(node, node.orelse, is_left=F... | python | {
"resource": ""
} |
q31127 | AsStringVisitor.visit_keyword | train | def visit_keyword(self, node):
"""return an astroid.Keyword node as string"""
if node.arg is None:
return "**%s" % node.value.accept(self)
return "%s=%s" % (node.arg, node.value.accept(self)) | python | {
"resource": ""
} |
q31128 | AsStringVisitor.visit_lambda | train | def visit_lambda(self, node):
"""return an astroid.Lambda node as string"""
args = node.args.accept(self)
body = node.body.accept(self)
if args:
return "lambda %s: %s" % (args, body)
return "lambda: %s" % body | python | {
"resource": ""
} |
q31129 | AsStringVisitor.visit_list | train | def visit_list(self, node):
"""return an astroid.List node as string"""
return "[%s]" % ", ".join(child.accept(self) for child in node.elts) | python | {
"resource": ""
} |
q31130 | AsStringVisitor.visit_listcomp | train | def visit_listcomp(self, node):
"""return an astroid.ListComp node as string"""
return "[%s %s]" % (
node.elt.accept(self),
" ".join(n.accept(self) for n in node.generators),
) | python | {
"resource": ""
} |
q31131 | AsStringVisitor.visit_module | train | def visit_module(self, node):
"""return an astroid.Module node as string"""
docs = '"""%s"""\n\n' % node.doc if node.doc else ""
return docs + "\n".join(n.accept(self) for n in node.body) + "\n\n" | python | {
"resource": ""
} |
q31132 | AsStringVisitor.visit_print | train | def visit_print(self, node):
"""return an astroid.Print node as string"""
nodes = ", ".join(n.accept(self) for n in node.values)
if not node.nl:
nodes = "%s," % nodes
if node.dest:
return "print >> %s, %s" % (node.dest.accept(self), nodes)
return "print %s... | python | {
"resource": ""
} |
q31133 | AsStringVisitor.visit_return | train | def visit_return(self, node):
"""return an astroid.Return node as string"""
if node.is_tuple_return() and len(node.value.elts) > 1:
elts = [child.accept(self) for child in node.value.elts]
return "return %s" % ", ".join(elts)
if node.value:
return "return %s"... | python | {
"resource": ""
} |
q31134 | AsStringVisitor.visit_set | train | def visit_set(self, node):
"""return an astroid.Set node as string"""
return "{%s}" % ", ".join(child.accept(self) for child in node.elts) | python | {
"resource": ""
} |
q31135 | AsStringVisitor.visit_setcomp | train | def visit_setcomp(self, node):
"""return an astroid.SetComp node as string"""
return "{%s %s}" % (
node.elt.accept(self),
" ".join(n.accept(self) for n in node.generators),
) | python | {
"resource": ""
} |
q31136 | AsStringVisitor.visit_slice | train | def visit_slice(self, node):
"""return an astroid.Slice node as string"""
lower = node.lower.accept(self) if node.lower else ""
upper = node.upper.accept(self) if node.upper else ""
step = node.step.accept(self) if node.step else ""
if step:
return "%s:%s:%s" % (lower... | python | {
"resource": ""
} |
q31137 | AsStringVisitor.visit_subscript | train | def visit_subscript(self, node):
"""return an astroid.Subscript node as string"""
idx = node.slice
if idx.__class__.__name__.lower() == "index":
idx = idx.value
idxstr = idx.accept(self)
if idx.__class__.__name__.lower() == "tuple" and idx.elts:
# Remove p... | python | {
"resource": ""
} |
q31138 | AsStringVisitor.visit_tryexcept | train | def visit_tryexcept(self, node):
"""return an astroid.TryExcept node as string"""
trys = ["try:\n%s" % self._stmt_list(node.body)]
for handler in node.handlers:
trys.append(handler.accept(self))
if node.orelse:
trys.append("else:\n%s" % self._stmt_list(node.orelse... | python | {
"resource": ""
} |
q31139 | AsStringVisitor.visit_tryfinally | train | def visit_tryfinally(self, node):
"""return an astroid.TryFinally node as string"""
return "try:\n%s\nfinally:\n%s" % (
self._stmt_list(node.body),
self._stmt_list(node.finalbody),
) | python | {
"resource": ""
} |
q31140 | AsStringVisitor.visit_tuple | train | def visit_tuple(self, node):
"""return an astroid.Tuple node as string"""
if len(node.elts) == 1:
return "(%s, )" % node.elts[0].accept(self)
return "(%s)" % ", ".join(child.accept(self) for child in node.elts) | python | {
"resource": ""
} |
q31141 | AsStringVisitor.visit_unaryop | train | def visit_unaryop(self, node):
"""return an astroid.UnaryOp node as string"""
if node.op == "not":
operator = "not "
else:
operator = node.op
return "%s%s" % (operator, self._precedence_parens(node, node.operand)) | python | {
"resource": ""
} |
q31142 | AsStringVisitor.visit_while | train | def visit_while(self, node):
"""return an astroid.While node as string"""
whiles = "while %s:\n%s" % (node.test.accept(self), self._stmt_list(node.body))
if node.orelse:
whiles = "%s\nelse:\n%s" % (whiles, self._stmt_list(node.orelse))
return whiles | python | {
"resource": ""
} |
q31143 | AsStringVisitor.visit_with | train | def visit_with(self, node): # 'with' without 'as' is possible
"""return an astroid.With node as string"""
items = ", ".join(
("%s" % expr.accept(self)) + (vars and " as %s" % (vars.accept(self)) or "")
for expr, vars in node.items
)
return "with %s:\n%s" % (items... | python | {
"resource": ""
} |
q31144 | AsStringVisitor3.visit_yieldfrom | train | def visit_yieldfrom(self, node):
""" Return an astroid.YieldFrom node as string. """
yi_val = (" " + node.value.accept(self)) if node.value else ""
expr = "yield from" + yi_val
if node.parent.is_statement:
return expr
return "(%s)" % (expr,) | python | {
"resource": ""
} |
q31145 | bind_context_to_node | train | def bind_context_to_node(context, node):
"""Give a context a boundnode
to retrieve the correct function name or attribute value
with from further inference.
Do not use an existing context since the boundnode could then
be incorrectly propagated higher up in the call stack.
:param context: Cont... | python | {
"resource": ""
} |
q31146 | InferenceContext.push | train | def push(self, node):
"""Push node into inference path
:return: True if node is already in context path else False
:rtype: bool
Allows one to see if the given node has already
been looked at for this inference context"""
name = self.lookupname
if (node, name) in... | python | {
"resource": ""
} |
q31147 | InferenceContext.clone | train | def clone(self):
"""Clone inference path
For example, each side of a binary operation (BinOp)
starts with the same context but diverge as each side is inferred
so the InferenceContext will need be cloned"""
# XXX copy lookupname/callcontext ?
clone = InferenceContext(sel... | python | {
"resource": ""
} |
q31148 | InferenceContext.cache_generator | train | def cache_generator(self, key, generator):
"""Cache result of generator into dictionary
Used to cache inference results"""
results = []
for result in generator:
results.append(result)
yield result
self.inferred[key] = tuple(results) | python | {
"resource": ""
} |
q31149 | NestedViewSetMixin.get_queryset | train | def get_queryset(self):
"""
Filter the `QuerySet` based on its parents as defined in the
`serializer_class.parent_lookup_kwargs`.
"""
queryset = super(NestedViewSetMixin, self).get_queryset()
if hasattr(self.serializer_class, 'parent_lookup_kwargs'):
orm_filte... | python | {
"resource": ""
} |
q31150 | ReteMatcher.changes | train | def changes(self, adding=None, deleting=None):
"""Pass the given changes to the root_node."""
if deleting is not None:
for deleted in deleting:
self.root_node.remove(deleted)
if adding is not None:
for added in adding:
self.root_node.add(a... | python | {
"resource": ""
} |
q31151 | ReteMatcher.build_alpha_part | train | def build_alpha_part(ruleset, root_node):
"""
Given a set of already adapted rules, build the alpha part of
the RETE network starting at `root_node`.
"""
# Adds a dummy rule with InitialFact as LHS for always generate
# the alpha part matching InitialFact(). This is need... | python | {
"resource": ""
} |
q31152 | ReteMatcher.build_beta_part | train | def build_beta_part(ruleset, alpha_terminals):
"""
Given a set of already adapted rules, and a dictionary of
patterns and alpha_nodes, wire up the beta part of the RETE
network.
"""
for rule in ruleset:
if isinstance(rule[0], OR):
for subrule ... | python | {
"resource": ""
} |
q31153 | ReteMatcher.print_network | train | def print_network(self): # pragma: no cover
"""
Generate a graphviz compatible graph.
"""
edges = set()
def gen_edges(node):
nonlocal edges
name = str(id(node))
yield '{name} [label="{cls_name}"];'.format(
name=name,
... | python | {
"resource": ""
} |
q31154 | Node.reset | train | def reset(self):
"""Reset itself and recursively all its children."""
watchers.MATCHER.debug("Node <%s> reset", self)
self._reset()
for child in self.children:
child.node.reset() | python | {
"resource": ""
} |
q31155 | OneInputNode.activate | train | def activate(self, token):
"""Make a copy of the received token and call `self._activate`."""
if watchers.worth('MATCHER', 'DEBUG'): # pragma: no cover
watchers.MATCHER.debug(
"Node <%s> activated with token %r", self, token)
return self._activate(token.copy()) | python | {
"resource": ""
} |
q31156 | TwoInputNode.activate_left | train | def activate_left(self, token):
"""Make a copy of the received token and call `_activate_left`."""
watchers.MATCHER.debug(
"Node <%s> activated left with token %r", self, token)
return self._activate_left(token.copy()) | python | {
"resource": ""
} |
q31157 | TwoInputNode.activate_right | train | def activate_right(self, token):
"""Make a copy of the received token and call `_activate_right`."""
watchers.MATCHER.debug(
"Node <%s> activated right with token %r", self, token)
return self._activate_right(token.copy()) | python | {
"resource": ""
} |
q31158 | KnowledgeEngine.duplicate | train | def duplicate(self, template_fact, **modifiers):
"""Create a new fact from an existing one."""
newfact = template_fact.copy()
newfact.update(dict(self._get_real_modifiers(**modifiers)))
return self.declare(newfact) | python | {
"resource": ""
} |
q31159 | KnowledgeEngine.get_deffacts | train | def get_deffacts(self):
"""Return the existing deffacts sorted by the internal order"""
return sorted(self._get_by_type(DefFacts), key=lambda d: d.order) | python | {
"resource": ""
} |
q31160 | KnowledgeEngine.retract | train | def retract(self, idx_or_declared_fact):
"""
Retracts a specific fact, using its index
.. note::
This updates the agenda
"""
self.facts.retract(idx_or_declared_fact)
if not self.running:
added, removed = self.get_activations()
self.st... | python | {
"resource": ""
} |
q31161 | KnowledgeEngine.run | train | def run(self, steps=float('inf')):
"""
Execute agenda activations
"""
self.running = True
activation = None
execution = 0
while steps > 0 and self.running:
added, removed = self.get_activations()
self.strategy.update_agenda(self.agenda, a... | python | {
"resource": ""
} |
q31162 | KnowledgeEngine.__declare | train | def __declare(self, *facts):
"""
Internal declaration method. Used for ``declare`` and ``deffacts``
"""
if any(f.has_field_constraints() for f in facts):
raise TypeError(
"Declared facts cannot contain conditional elements")
elif any(f.has_nested_acces... | python | {
"resource": ""
} |
q31163 | KnowledgeEngine.declare | train | def declare(self, *facts):
"""
Declare from inside a fact, equivalent to ``assert`` in clips.
.. note::
This updates the agenda.
"""
if not self.facts:
watchers.ENGINE.warning("Declaring fact before reset()")
return self.__declare(*facts) | python | {
"resource": ""
} |
q31164 | REGEX | train | def REGEX(pattern, flags=0):
"""Regular expression matching."""
return P(lambda x: re.match(pattern, x, flags=flags)) | python | {
"resource": ""
} |
q31165 | ILIKE | train | def ILIKE(pattern):
"""Unix shell-style wildcards. Case-insensitive"""
return P(lambda x: fnmatch.fnmatch(x.lower(), pattern.lower())) | python | {
"resource": ""
} |
q31166 | worth | train | def worth(what, level_name):
"""Returns `True` if the watcher `what` would log under `level_name`."""
return (logging.NOTSET
< globals()[what].level
<= getattr(logging, level_name)) | python | {
"resource": ""
} |
q31167 | watch | train | def watch(*what, level=logging.DEBUG):
"""
Enable watchers.
Defaults to enable all watchers, accepts a list names of watchers to
enable.
"""
if not what:
what = ALL
for watcher_name in what:
watcher = globals()[watcher_name]
watcher.setLevel(level) | python | {
"resource": ""
} |
q31168 | extract_facts | train | def extract_facts(rule):
"""Given a rule, return a set containing all rule LHS facts."""
def _extract_facts(ce):
if isinstance(ce, Fact):
yield ce
elif isinstance(ce, TEST):
pass
else:
for e in ce:
yield from _extract_facts(e)
retu... | python | {
"resource": ""
} |
q31169 | generate_checks | train | def generate_checks(fact):
"""Given a fact, generate a list of Check objects for checking it."""
yield TypeCheck(type(fact))
fact_captured = False
for key, value in fact.items():
if (isinstance(key, str)
and key.startswith('__')
and key.endswith('__')):
... | python | {
"resource": ""
} |
q31170 | BusNode.add | train | def add(self, fact):
"""Create a VALID token and send it to all children."""
token = Token.valid(fact)
MATCHER.debug("<BusNode> added %r", token)
for child in self.children:
child.callback(token) | python | {
"resource": ""
} |
q31171 | BusNode.remove | train | def remove(self, fact):
"""Create an INVALID token and send it to all children."""
token = Token.invalid(fact)
MATCHER.debug("<BusNode> added %r", token)
for child in self.children:
child.callback(token) | python | {
"resource": ""
} |
q31172 | OrdinaryMatchNode.__activation | train | def __activation(self, token, branch_memory, matching_memory,
is_left=True):
"""
Node activation internal function.
This is a generalization of both activation functions.
The given token is added or removed from `branch_memory`
depending of its tag.
... | python | {
"resource": ""
} |
q31173 | OrdinaryMatchNode._activate_left | train | def _activate_left(self, token):
"""Node left activation."""
self.__activation(token,
self.left_memory,
self.right_memory,
is_left=True) | python | {
"resource": ""
} |
q31174 | OrdinaryMatchNode._activate_right | train | def _activate_right(self, token):
"""Node right activation."""
self.__activation(token,
self.right_memory,
self.left_memory,
is_left=False) | python | {
"resource": ""
} |
q31175 | ConflictSetNode._activate | train | def _activate(self, token):
"""Activate this node for the given token."""
info = token.to_info()
activation = Activation(
self.rule,
frozenset(info.data),
{k: v for k, v in info.context if isinstance(k, str)})
if token.is_valid():
if inf... | python | {
"resource": ""
} |
q31176 | ConflictSetNode.get_activations | train | def get_activations(self):
"""Return a list of activations."""
res = (self.added, self.removed)
self.added = set()
self.removed = set()
return res | python | {
"resource": ""
} |
q31177 | NotNode._activate_left | train | def _activate_left(self, token):
"""
Activate from the left.
In case of a valid token this activations test the right memory
with the given token and looks for the number of matches. The
token and the number of occurences are stored in the left
memory.
If the nu... | python | {
"resource": ""
} |
q31178 | NotNode._activate_right | train | def _activate_right(self, token):
"""
Activate from the right.
Go over the left memory and find matching data, when found
update the counter (substracting if the given token is invalid
and adding otherwise). Depending on the result of this operation
a new token is genera... | python | {
"resource": ""
} |
q31179 | FactList.retract | train | def retract(self, idx_or_fact):
"""
Retract a previously asserted fact.
See `"Retract that fact" in Clips User Guide
<http://clipsrules.sourceforge.net/doc\
umentation/v624/ug.htm#_Toc412126077>`_.
:param idx: The index of the fact to retract in the factlist
... | python | {
"resource": ""
} |
q31180 | FactList.changes | train | def changes(self):
"""
Return a tuple with the removed and added facts since last run.
"""
try:
return self.added, self.removed
finally:
self.added = list()
self.removed = list() | python | {
"resource": ""
} |
q31181 | Rule.new_conditions | train | def new_conditions(self, *args):
"""
Generate a new rule with the same attributes but with the given
conditions.
"""
obj = self.__class__(*args, salience=self.salience)
if self._wrapped:
obj = obj(self._wrapped)
return obj | python | {
"resource": ""
} |
q31182 | Fact.as_dict | train | def as_dict(self):
"""Return a dictionary containing this `Fact` data."""
return {k: unfreeze(v)
for k, v in self.items()
if not self.is_special(k)} | python | {
"resource": ""
} |
q31183 | Fact.copy | train | def copy(self):
"""Return a copy of this `Fact`."""
content = [(k, v) for k, v in self.items()]
intidx = [(k, v) for k, v in content if isinstance(k, int)]
args = [v for k, v in sorted(intidx)]
kwargs = {k: v
for k, v in content
if not isinst... | python | {
"resource": ""
} |
q31184 | AnyChild.add_child | train | def add_child(self, node, callback):
"""Add node and callback to the children set."""
if node not in self.children:
self.children.append(ChildNode(node, callback)) | python | {
"resource": ""
} |
q31185 | Token.valid | train | def valid(cls, data, context=None):
"""Shortcut to create a VALID Token."""
return cls(cls.TagType.VALID, data, context) | python | {
"resource": ""
} |
q31186 | Token.invalid | train | def invalid(cls, data, context=None):
"""Shortcut to create an INVALID Token."""
return cls(cls.TagType.INVALID, data, context) | python | {
"resource": ""
} |
q31187 | Token.copy | train | def copy(self):
"""
Make a new instance of this Token.
This method makes a copy of the mutable part of the token before
making the instance.
"""
return self.__class__(self.tag, self.data.copy(), self.context.copy()) | python | {
"resource": ""
} |
q31188 | parse | train | def parse(datetime_str, timezone=None, isofirst=True, dayfirst=True, yearfirst=True):
"""
Parses a datetime string and returns a `Delorean` object.
:param datetime_str: The string to be interpreted into a `Delorean` object.
:param timezone: Pass this parameter and the returned Delorean object will be n... | python | {
"resource": ""
} |
q31189 | range_daily | train | def range_daily(start=None, stop=None, timezone='UTC', count=None):
"""
This an alternative way to generating sets of Delorean objects with
DAILY stops
"""
return stops(start=start, stop=stop, freq=DAILY, timezone=timezone, count=count) | python | {
"resource": ""
} |
q31190 | range_hourly | train | def range_hourly(start=None, stop=None, timezone='UTC', count=None):
"""
This an alternative way to generating sets of Delorean objects with
HOURLY stops
"""
return stops(start=start, stop=stop, freq=HOURLY, timezone=timezone, count=count) | python | {
"resource": ""
} |
q31191 | range_monthly | train | def range_monthly(start=None, stop=None, timezone='UTC', count=None):
"""
This an alternative way to generating sets of Delorean objects with
MONTHLY stops
"""
return stops(start=start, stop=stop, freq=MONTHLY, timezone=timezone, count=count) | python | {
"resource": ""
} |
q31192 | range_yearly | train | def range_yearly(start=None, stop=None, timezone='UTC', count=None):
"""
This an alternative way to generating sets of Delorean objects with
YEARLY stops
"""
return stops(start=start, stop=stop, freq=YEARLY, timezone=timezone, count=count) | python | {
"resource": ""
} |
q31193 | stops | train | def stops(freq, interval=1, count=None, wkst=None, bysetpos=None,
bymonth=None, bymonthday=None, byyearday=None, byeaster=None,
byweekno=None, byweekday=None, byhour=None, byminute=None,
bysecond=None, timezone='UTC', start=None, stop=None):
"""
This will create a list of delorean ... | python | {
"resource": ""
} |
q31194 | _move_datetime | train | def _move_datetime(dt, direction, delta):
"""
Move datetime given delta by given direction
"""
if direction == 'next':
dt = dt + delta
elif direction == 'last':
dt = dt - delta
else:
pass
# raise some delorean error here
return dt | python | {
"resource": ""
} |
q31195 | move_datetime_month | train | def move_datetime_month(dt, direction, num_shifts):
"""
Move datetime 1 month in the chosen direction.
unit is a no-op, to keep the API the same as the day case
"""
delta = relativedelta(months=+num_shifts)
return _move_datetime(dt, direction, delta) | python | {
"resource": ""
} |
q31196 | move_datetime_week | train | def move_datetime_week(dt, direction, num_shifts):
"""
Move datetime 1 week in the chosen direction.
unit is a no-op, to keep the API the same as the day case
"""
delta = relativedelta(weeks=+num_shifts)
return _move_datetime(dt, direction, delta) | python | {
"resource": ""
} |
q31197 | move_datetime_year | train | def move_datetime_year(dt, direction, num_shifts):
"""
Move datetime 1 year in the chosen direction.
unit is a no-op, to keep the API the same as the day case
"""
delta = relativedelta(years=+num_shifts)
return _move_datetime(dt, direction, delta) | python | {
"resource": ""
} |
q31198 | datetime_timezone | train | def datetime_timezone(tz):
"""
This method given a timezone returns a localized datetime object.
"""
utc_datetime_naive = datetime.utcnow()
# return a localized datetime to UTC
utc_localized_datetime = localize(utc_datetime_naive, 'UTC')
# normalize the datetime to given timezone
normali... | python | {
"resource": ""
} |
q31199 | localize | train | def localize(dt, tz):
"""
Given a naive datetime object this method will return a localized
datetime object
"""
if not isinstance(tz, tzinfo):
tz = pytz.timezone(tz)
return tz.localize(dt) | python | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.