function stringlengths 11 56k | repo_name stringlengths 5 60 | features list |
|---|---|---|
def fix_number(target_type):
return lambda value: None if isinstance(value, (str, six.text_type)) and len(value) == 0 else target_type(value) | anjianshi/flask-restful-extend | [
43,
14,
43,
5,
1381660417
] |
def test_lengths_top_k_op(self, N, K, gc, dc):
lens = np.random.randint(low=1, high=2 * K + 1, size=N).astype(np.int32)
X = []
for i in lens:
X.extend(map(lambda x: x / 100.0, range(0, 6 * i, 6)))
X = np.array(X, dtype=np.float32)
op = core.CreateOperator("LengthsTopK... | ryfeus/lambda-packs | [
1086,
234,
1086,
13,
1476901359
] |
def setUp(self) -> None:
mock_client = mock.Mock(paper_trade=False)
self.mock_trade = mock.Mock(
client=mock_client, market_id="1.1", selection_id=123, info={}
)
self.mock_order_type = mock.Mock(info={})
self.order = BaseOrder(
self.mock_trade, "BACK", sel... | liampauling/flumine | [
110,
46,
110,
30,
1479407630
] |
def test__update_status(self, mock_info, mock__is_complete):
self.mock_trade.complete = True
self.order._update_status(OrderStatus.EXECUTION_COMPLETE)
self.assertEqual(self.order.status_log, [OrderStatus.EXECUTION_COMPLETE])
self.assertEqual(self.order.status, OrderStatus.EXECUTION_COMPL... | liampauling/flumine | [
110,
46,
110,
30,
1479407630
] |
def test_placing(self, mock__update_status):
self.order.placing()
mock__update_status.assert_called_with(OrderStatus.PENDING) | liampauling/flumine | [
110,
46,
110,
30,
1479407630
] |
def test_executable(self, mock__update_status):
self.order.update_data = {123: 456}
self.order.executable()
mock__update_status.assert_called_with(OrderStatus.EXECUTABLE)
self.assertEqual(self.order.update_data, {}) | liampauling/flumine | [
110,
46,
110,
30,
1479407630
] |
def test_execution_complete(self, mock__update_status):
self.order.update_data = {123: 456}
self.order.execution_complete()
mock__update_status.assert_called_with(OrderStatus.EXECUTION_COMPLETE)
self.assertIsNotNone(self.order.date_time_execution_complete)
self.assertEqual(self.o... | liampauling/flumine | [
110,
46,
110,
30,
1479407630
] |
def test_cancelling(self, mock__update_status):
self.order.cancelling()
mock__update_status.assert_called_with(OrderStatus.CANCELLING) | liampauling/flumine | [
110,
46,
110,
30,
1479407630
] |
def test_updating(self, mock__update_status):
self.order.updating()
mock__update_status.assert_called_with(OrderStatus.UPDATING) | liampauling/flumine | [
110,
46,
110,
30,
1479407630
] |
def test_replacing(self, mock__update_status):
self.order.replacing()
mock__update_status.assert_called_with(OrderStatus.REPLACING) | liampauling/flumine | [
110,
46,
110,
30,
1479407630
] |
def test_violation(self, mock__update_status):
self.order.update_data = {123: 456}
self.order.violation("the murder capital")
mock__update_status.assert_called_with(OrderStatus.VIOLATION)
self.assertEqual(self.order.update_data, {})
self.assertEqual(self.order.violation_msg, "the... | liampauling/flumine | [
110,
46,
110,
30,
1479407630
] |
def test_cancel(self):
with self.assertRaises(NotImplementedError):
self.order.cancel() | liampauling/flumine | [
110,
46,
110,
30,
1479407630
] |
def test_replace(self):
with self.assertRaises(NotImplementedError):
self.order.replace(20.0) | liampauling/flumine | [
110,
46,
110,
30,
1479407630
] |
def test_create_cancel_instruction(self):
with self.assertRaises(NotImplementedError):
self.order.create_cancel_instruction() | liampauling/flumine | [
110,
46,
110,
30,
1479407630
] |
def test_create_replace_instruction(self):
with self.assertRaises(NotImplementedError):
self.order.create_replace_instruction() | liampauling/flumine | [
110,
46,
110,
30,
1479407630
] |
def test_current_order(self):
self.assertIsNone(self.order.current_order)
mock_responses = mock.Mock()
mock_responses.current_order = None
self.order.responses = mock_responses
self.assertEqual(self.order.current_order, mock_responses.place_response)
mock_responses.curren... | liampauling/flumine | [
110,
46,
110,
30,
1479407630
] |
def test_current_order_simulated(self, mock_config):
mock_config.simulated = True
order = BaseOrder(mock.Mock(), "", mock.Mock())
self.assertTrue(order.simulated)
self.assertTrue(order._simulated) | liampauling/flumine | [
110,
46,
110,
30,
1479407630
] |
def test_average_price_matched(self):
with self.assertRaises(NotImplementedError):
assert self.order.average_price_matched | liampauling/flumine | [
110,
46,
110,
30,
1479407630
] |
def test_size_remaining(self):
with self.assertRaises(NotImplementedError):
assert self.order.size_remaining | liampauling/flumine | [
110,
46,
110,
30,
1479407630
] |
def test_size_lapsed(self):
with self.assertRaises(NotImplementedError):
assert self.order.size_lapsed | liampauling/flumine | [
110,
46,
110,
30,
1479407630
] |
def test_elapsed_seconds(self):
self.assertIsNone(self.order.elapsed_seconds)
mock_responses = mock.Mock()
mock_responses.date_time_placed = datetime.datetime.utcnow()
self.order.responses = mock_responses
self.assertGreaterEqual(self.order.elapsed_seconds, 0) | liampauling/flumine | [
110,
46,
110,
30,
1479407630
] |
def test_elapsed_seconds_executable(self):
self.assertIsNone(self.order.elapsed_seconds_executable)
mock_responses = mock.Mock()
mock_responses.date_time_placed = datetime.datetime.utcnow()
self.order.responses = mock_responses
self.order.date_time_execution_complete = datetime.d... | liampauling/flumine | [
110,
46,
110,
30,
1479407630
] |
def test_lookup(self):
self.assertEqual(
self.order.lookup,
(self.mock_trade.market_id, self.mock_trade.selection_id, 1),
) | liampauling/flumine | [
110,
46,
110,
30,
1479407630
] |
def test_set_and_get_sep(self):
self.order.sep = "a"
self.assertEqual("a", self.order.sep) | liampauling/flumine | [
110,
46,
110,
30,
1479407630
] |
def test_notes_str(self):
self.order.notes = collections.OrderedDict({"1": 1, 2: "2", 3: 3, 4: "four"})
self.assertEqual(self.order.notes_str, "1,2,3,four")
self.order.notes = collections.OrderedDict()
self.assertEqual(self.order.notes_str, "") | liampauling/flumine | [
110,
46,
110,
30,
1479407630
] |
def setUp(self) -> None:
mock_client = mock.Mock(paper_trade=False)
self.mock_trade = mock.Mock(
client=mock_client, market_id="1.1", selection_id=123, info={}
)
self.mock_status = mock.Mock()
self.mock_order_type = mock.Mock(info={}, size=2.0, liability=2.0)
... | liampauling/flumine | [
110,
46,
110,
30,
1479407630
] |
def test_place(self, mock_placing):
self.order.place(123, 456, False)
mock_placing.assert_called_with()
self.assertEqual(self.order.publish_time, 123)
self.assertEqual(self.order.market_version, 456)
self.assertFalse(self.order.async_) | liampauling/flumine | [
110,
46,
110,
30,
1479407630
] |
def test_cancel(self, mock_cancelling, mock_size_remaining):
mock_size_remaining.return_value = 20
self.order.bet_id = 123
self.order.status = OrderStatus.EXECUTABLE
with self.assertRaises(OrderUpdateError):
self.order.cancel(12)
self.mock_order_type.ORDER_TYPE = Ord... | liampauling/flumine | [
110,
46,
110,
30,
1479407630
] |
def test_cancel_error_size(self, mock_cancelling, mock_size_remaining):
mock_size_remaining.return_value = 20
self.order.status = OrderStatus.EXECUTABLE
with self.assertRaises(OrderUpdateError):
self.order.cancel(12)
self.mock_order_type.ORDER_TYPE = OrderTypes.LIMIT
... | liampauling/flumine | [
110,
46,
110,
30,
1479407630
] |
def test_cancel_error(self, mock_size_remaining):
mock_size_remaining.return_value = 20
self.mock_order_type.ORDER_TYPE = OrderTypes.LIMIT
self.order.status = OrderStatus.PENDING
with self.assertRaises(OrderUpdateError):
self.order.cancel(12) | liampauling/flumine | [
110,
46,
110,
30,
1479407630
] |
def test_update(self, mock_updating):
self.order.bet_id = 123
self.order.status = OrderStatus.EXECUTABLE
with self.assertRaises(OrderUpdateError):
self.order.update("PERSIST")
self.mock_order_type.ORDER_TYPE = OrderTypes.LIMIT
self.mock_order_type.persistence_type = ... | liampauling/flumine | [
110,
46,
110,
30,
1479407630
] |
def test_update_error(self):
self.mock_order_type.ORDER_TYPE = OrderTypes.LIMIT
self.mock_order_type.persistence_type = "LAPSE"
self.order.status = OrderStatus.PENDING
with self.assertRaises(OrderUpdateError):
self.order.update("PERSIST") | liampauling/flumine | [
110,
46,
110,
30,
1479407630
] |
def test_replace(self, mock_replacing):
self.order.bet_id = 123
self.order.status = OrderStatus.EXECUTABLE
with self.assertRaises(OrderUpdateError):
self.order.replace(1.01)
self.mock_order_type.ORDER_TYPE = OrderTypes.LIMIT
self.mock_order_type.price = 2.02
... | liampauling/flumine | [
110,
46,
110,
30,
1479407630
] |
def test_replace_error(self):
self.mock_order_type.ORDER_TYPE = OrderTypes.LIMIT
self.order.status = OrderStatus.PENDING
with self.assertRaises(OrderUpdateError):
self.order.replace(1.52) | liampauling/flumine | [
110,
46,
110,
30,
1479407630
] |
def test_create_cancel_instruction(self):
self.order.update_data = {"size_reduction": 0.02}
self.assertEqual(
self.order.create_cancel_instruction(), {"sizeReduction": 0.02}
) | liampauling/flumine | [
110,
46,
110,
30,
1479407630
] |
def test_create_replace_instruction(self):
self.order.update_data = {"new_price": 2.02}
self.assertEqual(self.order.create_replace_instruction(), {"newPrice": 2.02}) | liampauling/flumine | [
110,
46,
110,
30,
1479407630
] |
def test_size_matched(self):
self.assertEqual(self.order.size_matched, 0)
mock_current_order = mock.Mock(size_matched=10)
self.order.responses.current_order = mock_current_order
self.assertEqual(self.order.size_matched, mock_current_order.size_matched) | liampauling/flumine | [
110,
46,
110,
30,
1479407630
] |
def test_size_remaining_missing(self):
self.mock_order_type.ORDER_TYPE = OrderTypes.LIMIT
self.mock_order_type.size = 2.51
self.assertEqual(self.order.size_remaining, 2.51) | liampauling/flumine | [
110,
46,
110,
30,
1479407630
] |
def test_size_remaining_missing_partial_match(self, mock_size_matched):
self.mock_order_type.ORDER_TYPE = OrderTypes.LIMIT
mock_size_matched.return_value = 2
self.mock_order_type.size = 10
self.assertEqual(self.order.size_remaining, 8) | liampauling/flumine | [
110,
46,
110,
30,
1479407630
] |
def test_size_cancelled(self):
self.assertEqual(self.order.size_cancelled, 0)
mock_current_order = mock.Mock(size_cancelled=10)
self.order.responses.current_order = mock_current_order
self.assertEqual(self.order.size_cancelled, mock_current_order.size_cancelled) | liampauling/flumine | [
110,
46,
110,
30,
1479407630
] |
def test_size_voided(self):
self.assertEqual(self.order.size_voided, 0)
mock_current_order = mock.Mock(size_voided=10)
self.order.responses.current_order = mock_current_order
self.assertEqual(self.order.size_voided, mock_current_order.size_voided) | liampauling/flumine | [
110,
46,
110,
30,
1479407630
] |
def test_json(self):
self.assertTrue(isinstance(self.order.json(), str)) | liampauling/flumine | [
110,
46,
110,
30,
1479407630
] |
def test_letters_True(self):
# ascii_letters contains a-z and A-Z
for c in string.ascii_letters:
self.assertTrue(BetfairOrder.is_valid_customer_order_ref_character(c)) | liampauling/flumine | [
110,
46,
110,
30,
1479407630
] |
def test_digits_True(self):
# string.digits contains digits 0-9
for c in string.digits:
self.assertTrue(BetfairOrder.is_valid_customer_order_ref_character(c)) | liampauling/flumine | [
110,
46,
110,
30,
1479407630
] |
def __init__(
self,
indent=DEFAULT_INDENT,
preserve=[],
blanks=DEFAULT_BLANKS,
compress=DEFAULT_COMPRESS,
selfclose=DEFAULT_SELFCLOSE,
indent_char=DEFAULT_INDENT_CHAR,
encoding_input=DEFAULT_ENCODING_INPUT,
encoding_output=DEFAULT_ENCODING_OUTPUT,
... | pamoller/xmlformatter | [
16,
6,
16,
3,
1390927940
] |
def encoding_effective(self, enc=None):
if self.encoding_output:
return self.encoding_output
elif self.encoding_internal:
return self.encoding_internal
elif self.encoding_input:
return self.encoding_input
else:
return "UTF-8" | pamoller/xmlformatter | [
16,
6,
16,
3,
1390927940
] |
def enc_encode(self, strg):
""" Encode a formatted XML document in target"""
if sys.version_info > (3, 0):
return strg.encode(self.encoding_effective) # v3
return strg.decode("utf-8").encode(self.encoding_effective) # v2 | pamoller/xmlformatter | [
16,
6,
16,
3,
1390927940
] |
def format_string(self, xmldoc=""):
""" Format a XML document given by xmldoc """
token_list = Formatter.TokenList(self)
token_list.parser.Parse(xmldoc)
return self.enc_encode(str(token_list)) | pamoller/xmlformatter | [
16,
6,
16,
3,
1390927940
] |
def __init__(self, formatter):
# Keep tokens in a list:
self._list = []
self.formatter = formatter
self.parser = xml.parsers.expat.ParserCreate(
encoding=self.formatter.encoding_input
)
self.parser.specified_attributes = 1
... | pamoller/xmlformatter | [
16,
6,
16,
3,
1390927940
] |
def __len__(self):
return len(self._list) | pamoller/xmlformatter | [
16,
6,
16,
3,
1390927940
] |
def __setitem__(self, pos, value):
if 0 <= pos < len(self._list):
self._list[pos] = value
else:
raise IndexError | pamoller/xmlformatter | [
16,
6,
16,
3,
1390927940
] |
def append(self, tk):
""" Add token to tokenlist. """
tk.pos = len(self._list)
self._list.append(tk) | pamoller/xmlformatter | [
16,
6,
16,
3,
1390927940
] |
def level_decrement(self):
""" Decrement level counter. """
self.level_counter -= 1 | pamoller/xmlformatter | [
16,
6,
16,
3,
1390927940
] |
def sequence(self, tk, scheme=None):
"""Returns sublist of token list.
None: next to last
EndElement: first to previous"""
if scheme == "EndElement" or (scheme is None and tk.end):
return reversed(self._list[: tk.pos])
return self._list[(tk.pos... | pamoller/xmlformatter | [
16,
6,
16,
3,
1390927940
] |
def token_indent_inline(self, tk):
""" Indent every element content - no matter enclosed by text or mixed content. """
for itk in iter(self.sequence(tk, "EndElement")):
if itk.level < tk.level and itk.name == "StartElement":
if itk.content_model == 1:
... | pamoller/xmlformatter | [
16,
6,
16,
3,
1390927940
] |
def token_preserve(self, tk):
"""Preseve eyery descendant of an preserved element.
0: not locked
1: just (un)locked
2: locked"""
# Lock perserving for StartElements:
if tk.name == "StartElement":
if self.preserve_level is not None:
... | pamoller/xmlformatter | [
16,
6,
16,
3,
1390927940
] |
def whitespace_append_leading(self, tk):
""" Add a leading whitespace to previous character data. """
if self.formatter.correct and tk.trailing and tk.not_empty:
self.whitespace_append(tk) | pamoller/xmlformatter | [
16,
6,
16,
3,
1390927940
] |
def whitespace_delete_leading(self, tk):
""" Returns True, if no next token or all empty (up to next end element)"""
if (
self.formatter.correct
and tk.leading
and not tk.preserve
and not tk.cdata_section
):
... | pamoller/xmlformatter | [
16,
6,
16,
3,
1390927940
] |
def insert_empty(self, tk, before=True):
""" Insert an Empty Token into token list - before or after tk. """
if not (0 < tk.pos < (len(self) - 1)):
return False
ptk = self[tk.pos - 1]
ntk = self.formatter.CharacterData(self, [" "])
ntk.level = ... | pamoller/xmlformatter | [
16,
6,
16,
3,
1390927940
] |
def __init__(self, tklist, arg):
# Reference Token List:
self.list = tklist
# Token datas:
self.arg = list(arg)
# Token is placed in an CDATA section:
self.cdata_section = False
# Token has content model:
self.content_model ... | pamoller/xmlformatter | [
16,
6,
16,
3,
1390927940
] |
def __unicode__(self):
return "" | pamoller/xmlformatter | [
16,
6,
16,
3,
1390927940
] |
def end(self):
return self.name == "EndElement" | pamoller/xmlformatter | [
16,
6,
16,
3,
1390927940
] |
def empty(self):
return self.name == "CharacterData" and re.match(
r"^[\t\s\n]*$", self.arg[0]
) | pamoller/xmlformatter | [
16,
6,
16,
3,
1390927940
] |
def leading(self):
return self.name == "CharacterData" and re.search(
r"^[\t\s\n]+", self.arg[0]
) | pamoller/xmlformatter | [
16,
6,
16,
3,
1390927940
] |
def not_empty(self):
return (
self.name == "CharacterData"
and not self.cdata_section
and not re.match(r"^[\t\s\n]+$", self.arg[0])
) | pamoller/xmlformatter | [
16,
6,
16,
3,
1390927940
] |
def trailing(self):
return self.name == "CharacterData" and re.search(
r"[\t\s\n]+$", self.arg[0]
) | pamoller/xmlformatter | [
16,
6,
16,
3,
1390927940
] |
def start(self):
return self.name == "StartElement" | pamoller/xmlformatter | [
16,
6,
16,
3,
1390927940
] |
def correct(self):
return self.formatter.correct | pamoller/xmlformatter | [
16,
6,
16,
3,
1390927940
] |
def indent_insert(self):
""" Indent token. """
# Child of root and no empty node
if (
self.level > 0 and not (self.end and self.list[self.pos - 1].start)
) or ( # not empty node:
self.end and not self.list[self.pos - 1].start
)... | pamoller/xmlformatter | [
16,
6,
16,
3,
1390927940
] |
def identifier(self, systemid, publicid):
# TODO add base parameter:
if publicid and systemid:
return ' PUBLIC "%s" "%s"' % (publicid, systemid)
elif publicid:
return ' PUBLIC "%s"' % publicid
elif systemid:
return ' SYSTEM ... | pamoller/xmlformatter | [
16,
6,
16,
3,
1390927940
] |
def pre_operate(self):
pass | pamoller/xmlformatter | [
16,
6,
16,
3,
1390927940
] |
def __unicode__(self):
str = self.indent_create()
str += "<!ATTLIST %s %s" % (self.arg[0], self.arg[1])
if self.arg[2] is not None:
str += " %s" % self.arg[2]
if self.arg[4] and not self.arg[3]:
str += " #REQUIRED"
elif self.arg... | pamoller/xmlformatter | [
16,
6,
16,
3,
1390927940
] |
def __unicode__(self):
str = self.arg[0]
if not self.preserve and not self.cdata_section:
# remove empty tokens always in element content!
if self.empty and not self.descendant_mixed:
if self.formatter.blanks and not self.formatter.compress and... | pamoller/xmlformatter | [
16,
6,
16,
3,
1390927940
] |
def post_operate(self):
self.delete_leading = self.list.whitespace_delete_leading(self)
self.delete_trailing = self.list.whitespace_delete_trailing(self) | pamoller/xmlformatter | [
16,
6,
16,
3,
1390927940
] |
def __unicode__(self):
str = ""
if self.preserve in [0, 1] and self.indent:
str += self.indent_insert()
str += "<!--%s-->" % re.sub(
r"^[\r\n]+$", "\n", re.sub(r"^[\r\n]+", "\n", self.arg[0])
)
return str | pamoller/xmlformatter | [
16,
6,
16,
3,
1390927940
] |
def __unicode__(self):
return "]]>" | pamoller/xmlformatter | [
16,
6,
16,
3,
1390927940
] |
def __unicode__(self):
str = self.indent_create()
str += "<!ELEMENT %s%s>" % (self.arg[0], self.evaluate_model(self.arg[1]))
return str | pamoller/xmlformatter | [
16,
6,
16,
3,
1390927940
] |
def __unicode__(self):
str = ""
if self.list[self.pos - 1].name != "StartDoctypeDecl":
str += self.indent_create(0)
str += "]"
str += ">"
str += self.indent_create(0)
return str | pamoller/xmlformatter | [
16,
6,
16,
3,
1390927940
] |
def __init__(self, list, arg):
list.level_decrement()
super(Formatter.EndElement, self).__init__(list, arg) | pamoller/xmlformatter | [
16,
6,
16,
3,
1390927940
] |
def configure(self):
self.descendant_mixed = self.list.token_descendant_mixed(self)
self.preserve = self.list.token_preserve(self)
self.indent = self.list.token_indent(self) | pamoller/xmlformatter | [
16,
6,
16,
3,
1390927940
] |
def __unicode__(self):
str = self.indent_create()
str += "<!ENTITY "
if self.arg[1]:
str += "% "
str += "%s " % self.arg[0]
if self.arg[2]:
str += '"%s"' % self.arg[2]
else:
str += "%s " % self.identi... | pamoller/xmlformatter | [
16,
6,
16,
3,
1390927940
] |
def __unicode__(self):
str = self.indent_create()
str += "<!NOTATION %s%s>" % (
self.arg[0],
self.identifier(self.arg[2], self.arg[3]),
)
return str | pamoller/xmlformatter | [
16,
6,
16,
3,
1390927940
] |
def __unicode__(self):
str = ""
if self.preserve in [0, 1] and self.indent:
str += self.indent_insert()
str += "<?%s %s?>" % (self.arg[0], self.arg[1])
return str | pamoller/xmlformatter | [
16,
6,
16,
3,
1390927940
] |
def __unicode__(self):
return "<![CDATA[" | pamoller/xmlformatter | [
16,
6,
16,
3,
1390927940
] |
def __unicode__(self):
str = "<!DOCTYPE %s" % (self.arg[0])
if self.arg[1]:
str += self.identifier(self.arg[1], self.arg[2])
if self.arg[3]:
str += " ["
return str | pamoller/xmlformatter | [
16,
6,
16,
3,
1390927940
] |
def __init__(self, list, arg):
super(Formatter.StartElement, self).__init__(list, arg)
self.list.level_increment() | pamoller/xmlformatter | [
16,
6,
16,
3,
1390927940
] |
def configure(self):
self.content_model = self.list.token_model(self)
self.descendant_mixed = self.list.token_descendant_mixed(self)
self.preserve = self.list.token_preserve(self)
self.indent = self.list.token_indent(self) | pamoller/xmlformatter | [
16,
6,
16,
3,
1390927940
] |
def __init__(self, list, arg):
super(Formatter.XmlDecl, self).__init__(list, arg)
if len(self.arg) > 1:
self.formatter.encoding_internal = self.arg[1] | pamoller/xmlformatter | [
16,
6,
16,
3,
1390927940
] |
def cli_usage(msg=""):
""" Output usage for command line tool. """
sys.stderr.write(msg + "\n")
sys.stderr.write(
'Usage: xmlformat [--preserve "pre,literal"] [--blanks]\
[--compress] [--selfclose] [--indent num] [--indent-char char]\
[--outfile file] [--encoding enc] [--outencoding enc]\
[--disa... | pamoller/xmlformatter | [
16,
6,
16,
3,
1390927940
] |
def main():
"""
Standalone django model test with a 'memory-only-django-installation'.
You can play with a django model without a complete django app installation.
http://www.djangosnippets.org/snippets/1044/
"""
sys.path.append(os.path.abspath(os.path.dirname(__file__)))
os.environ["DJANGO_... | hirokiky/django-websettings | [
7,
2,
7,
1,
1373117552
] |
def get_long_description():
readme_md = os.path.join(base_path, "README.md")
with open(readme_md) as f:
return f.read() | Anorov/cloudflare-scrape | [
3023,
444,
3023,
123,
1362095093
] |
def rand7():
return 0 | algorhythms/LeetCode | [
823,
267,
823,
3,
1403872362
] |
def createController():
"""Initialize controller."""
config = ctrlr.Config("deltaelektronika", "SM-700")
if not config.nodes:
config.nodes, config.names = ([1], ["SM700"])
if config.virtual:
driver = virtual.VirtualInstrument()
iface = ctrlr.virtualInstrumentController(config, dr... | Synss/pyhard2 | [
1,
2,
1,
4,
1379162937
] |
def __init__(self, network_interface: str):
self._your: Dict[str, Union[None, str]] = \
self._base.get_interface_settings(interface_name=network_interface,
required_parameters=['mac-address', 'ipv4-address',
... | Vladimir-Ivanov-Git/raw-packet | [
201,
44,
201,
10,
1495112728
] |
def scan(self,
exit_on_failure: bool = True,
quiet: bool = False) -> Union[None, List[NamedTuple]]:
try:
# region Variables
network_devices: List[NamedTuple] = list()
ipv4_address: str = ''
mac_address: str = ''
vendor: str =... | Vladimir-Ivanov-Git/raw-packet | [
201,
44,
201,
10,
1495112728
] |
def __init__(self, _object):
# the object
self._object = auxiliary.get_valid_dag_node(_object)
assert isinstance(self._object, pm.nodetypes.Transform)
# the data
self._futurePivot = pm.nodetypes.Transform
self._isSetup = False
# read the settings
self.... | eoyilmaz/anima | [
119,
27,
119,
3,
1392807749
] |
def _save_settings(self):
"""save settings inside objects pivotData attribute"""
# data to be save :
# -----------------
# futurePivot node
# create attributes
self._create_data_attribute()
# connect futurePivot node
pm.connectAttr(
"%s%s" % ... | eoyilmaz/anima | [
119,
27,
119,
3,
1392807749
] |
def _create_future_pivot(self):
"""creates the futurePivot locator"""
if self._isSetup:
return
# create a locator and move it to the current pivot
# parent the locator under the object
locator_name = self._object.name() + "_futurePivotLocator#"
self._future... | eoyilmaz/anima | [
119,
27,
119,
3,
1392807749
] |
def toggle(self):
"""toggles pivot visibility"""
if not self._isSetup:
return
# toggle the pivot visibility
current_vis = self._futurePivot.getAttr("v")
current_vis = (current_vis + 1) % 2
self._futurePivot.setAttr("v", current_vis) | eoyilmaz/anima | [
119,
27,
119,
3,
1392807749
] |
def _set_dg_dirty(self):
"""sets the DG to dirty for _object, currentPivot and futurePivot"""
pm.dgdirty(self._object, self._futurePivot) | eoyilmaz/anima | [
119,
27,
119,
3,
1392807749
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.