task
stringclasses 2
values | prompt
stringlengths 101
9.23k
| correct_code
stringlengths 48
9.16k
| prompt_code
stringlengths 48
9.16k
| full
stringlengths 198
9.5k
| index
int64 0
9
| noise_code
stringlengths 48
9.07k
| noise_correct_code
stringlengths 48
9.06k
|
|---|---|---|---|---|---|---|---|
var-misuse
|
<NME> networking.py
<BEF> def correct_lis(self, uris, blocking=True, verbose=False):
""" Returns logical interconnects to a consistent state.
The current logical interconnect state is compared to the associated
logical interconnect group. Any differences identified are corrected,
bringing the logical interconnect back to a consistent state. Changes
are asynchronously applied to all managed interconnects. Note that if
the changes detected involve differences in the interconnect map
between the logical interconnect group and the logical interconnect,
the process of bringing the logical interconnect back to a consistent
state may involve automatically removing existing interconnects from
management and/or adding new interconnects for management.
"""
request = {"uris": uris}
task, body = self._con.put(uri['li'] + '/compliance', request)
if blocking is True:
task = self._activity.wait4task(task, verbose=task)
return task
<MSG> Fix incorrect variable name
<DFF>
|
def correct_lis(self, uris, blocking=True, verbose=False):
""" Returns logical interconnects to a consistent state.
The current logical interconnect state is compared to the associated
logical interconnect group. Any differences identified are corrected,
bringing the logical interconnect back to a consistent state. Changes
are asynchronously applied to all managed interconnects. Note that if
the changes detected involve differences in the interconnect map
between the logical interconnect group and the logical interconnect,
the process of bringing the logical interconnect back to a consistent
state may involve automatically removing existing interconnects from
management and/or adding new interconnects for management.
"""
request = {"uris": uris}
task, body = self._con.put(uri['li'] + '/compliance', request)
if blocking is True:
task = self._activity.wait4task(task, verbose=verbose)
return task
|
def correct_lis(self, uris, blocking=True, verbose=False):
""" Returns logical interconnects to a consistent state.
The current logical interconnect state is compared to the associated
logical interconnect group. Any differences identified are corrected,
bringing the logical interconnect back to a consistent state. Changes
are asynchronously applied to all managed interconnects. Note that if
the changes detected involve differences in the interconnect map
between the logical interconnect group and the logical interconnect,
the process of bringing the logical interconnect back to a consistent
state may involve automatically removing existing interconnects from
management and/or adding new interconnects for management.
"""
request = {"uris": uris}
task, body = self._con.put(uri['li'] + '/compliance', request)
if blocking is True:
task = self._activity.wait4task(task, verbose=task)
return task
|
<NME> networking.py
<BEF> def correct_lis(self, uris, blocking=True, verbose=False):
""" Returns logical interconnects to a consistent state.
The current logical interconnect state is compared to the associated
logical interconnect group. Any differences identified are corrected,
bringing the logical interconnect back to a consistent state. Changes
are asynchronously applied to all managed interconnects. Note that if
the changes detected involve differences in the interconnect map
between the logical interconnect group and the logical interconnect,
the process of bringing the logical interconnect back to a consistent
state may involve automatically removing existing interconnects from
management and/or adding new interconnects for management.
"""
request = {"uris": uris}
task, body = self._con.put(uri['li'] + '/compliance', request)
if blocking is True:
task = self._activity.wait4task(task, verbose=task)
return task
<MSG> Fix incorrect variable name
<DFF> @@ -14,5 +14,5 @@
request = {"uris": uris}
task, body = self._con.put(uri['li'] + '/compliance', request)
if blocking is True:
- task = self._activity.wait4task(task, verbose=task)
+ task = self._activity.wait4task(task, verbose=verbose)
return task
| 0 |
def correct_lis(self, uris, blocking=True, verbose=False):
request = {"uris": uris}
task, body = self._con.put(uri['li'] + '/compliance', request)
if blocking is True:
task = self._activity.wait4task(task, verbose=task)
return task
|
def correct_lis(self, uris, blocking=True, verbose=False):
request = {"uris": uris}
task, body = self._con.put(uri['li'] + '/compliance', request)
if blocking is True:
task = self._activity.wait4task(task, verbose=verbose)
return task
|
var-misuse
|
<NME> servers.py
<BEF> def get_server_profiles(self):
body = self._con.get(uri['profiles'])
return get_members(self)
<MSG> Fix incorrect variable name
<DFF>
|
def get_server_profiles(self):
body = self._con.get(uri['profiles'])
return get_members(body)
|
def get_server_profiles(self):
body = self._con.get(uri['profiles'])
return get_members(self)
|
<NME> servers.py
<BEF> def get_server_profiles(self):
body = self._con.get(uri['profiles'])
return get_members(self)
<MSG> Fix incorrect variable name
<DFF> @@ -1,3 +1,3 @@
def get_server_profiles(self):
body = self._con.get(uri['profiles'])
- return get_members(self)
+ return get_members(body)
| 1 |
def get_server_profiles(self):
body = self._con.get(uri['profiles'])
return get_members(self)
|
def get_server_profiles(self):
body = self._con.get(uri['profiles'])
return get_members(body)
|
var-misuse
|
<NME> activity_record.py
<BEF> def add_post(self, activity_post):
if (self.gplus_posts.count(activity_post.post_id) == 0):
activity_post.gplus_posts.append(activity_post.post_id)
self.calculate_impact()
self.put()
<MSG> Fix incorrect variable name
<DFF>
|
def add_post(self, activity_post):
if (self.gplus_posts.count(activity_post.post_id) == 0):
self.gplus_posts.append(activity_post.post_id)
self.calculate_impact()
self.put()
|
def add_post(self, activity_post):
if (self.gplus_posts.count(activity_post.post_id) == 0):
activity_post.gplus_posts.append(activity_post.post_id)
self.calculate_impact()
self.put()
|
<NME> activity_record.py
<BEF> def add_post(self, activity_post):
if (self.gplus_posts.count(activity_post.post_id) == 0):
activity_post.gplus_posts.append(activity_post.post_id)
self.calculate_impact()
self.put()
<MSG> Fix incorrect variable name
<DFF> @@ -1,5 +1,5 @@
def add_post(self, activity_post):
if (self.gplus_posts.count(activity_post.post_id) == 0):
- activity_post.gplus_posts.append(activity_post.post_id)
+ self.gplus_posts.append(activity_post.post_id)
self.calculate_impact()
self.put()
| 2 |
def add_post(self, activity_post):
if (self.gplus_posts.count(activity_post.post_id) == 0):
activity_post.gplus_posts.append(activity_post.post_id)
self.calculate_impact()
self.put()
|
def add_post(self, activity_post):
if (self.gplus_posts.count(activity_post.post_id) == 0):
self.gplus_posts.append(activity_post.post_id)
self.calculate_impact()
self.put()
|
var-misuse
|
<NME> model.py
<BEF> def IdSet(self, value):
"""Setter to be used for default id EndpointsAliasProperty.
Sets the key on the current entity using the value passed in as the ID.
Using this key, attempts to retrieve the entity from the datastore and
update the unset properties of the current entity with those from the
retrieved entity.
Args:
value: An integer ID value for a simple key.
Raises:
TypeError: if the value to be set is not an integer. (Though if outside of
a given range, the get call will also throw an exception.)
"""
if not isinstance(self, (int, long)):
raise TypeError('ID must be an integer.')
self.UpdateFromKey(ndb.Key(self.__class__, value))
<MSG> Fix incorrect variable name
<DFF>
|
def IdSet(self, value):
"""Setter to be used for default id EndpointsAliasProperty.
Sets the key on the current entity using the value passed in as the ID.
Using this key, attempts to retrieve the entity from the datastore and
update the unset properties of the current entity with those from the
retrieved entity.
Args:
value: An integer ID value for a simple key.
Raises:
TypeError: if the value to be set is not an integer. (Though if outside of
a given range, the get call will also throw an exception.)
"""
if not isinstance(value, (int, long)):
raise TypeError('ID must be an integer.')
self.UpdateFromKey(ndb.Key(self.__class__, value))
|
def IdSet(self, value):
"""Setter to be used for default id EndpointsAliasProperty.
Sets the key on the current entity using the value passed in as the ID.
Using this key, attempts to retrieve the entity from the datastore and
update the unset properties of the current entity with those from the
retrieved entity.
Args:
value: An integer ID value for a simple key.
Raises:
TypeError: if the value to be set is not an integer. (Though if outside of
a given range, the get call will also throw an exception.)
"""
if not isinstance(self, (int, long)):
raise TypeError('ID must be an integer.')
self.UpdateFromKey(ndb.Key(self.__class__, value))
|
<NME> model.py
<BEF> def IdSet(self, value):
"""Setter to be used for default id EndpointsAliasProperty.
Sets the key on the current entity using the value passed in as the ID.
Using this key, attempts to retrieve the entity from the datastore and
update the unset properties of the current entity with those from the
retrieved entity.
Args:
value: An integer ID value for a simple key.
Raises:
TypeError: if the value to be set is not an integer. (Though if outside of
a given range, the get call will also throw an exception.)
"""
if not isinstance(self, (int, long)):
raise TypeError('ID must be an integer.')
self.UpdateFromKey(ndb.Key(self.__class__, value))
<MSG> Fix incorrect variable name
<DFF> @@ -13,6 +13,6 @@
TypeError: if the value to be set is not an integer. (Though if outside of
a given range, the get call will also throw an exception.)
"""
- if not isinstance(self, (int, long)):
+ if not isinstance(value, (int, long)):
raise TypeError('ID must be an integer.')
self.UpdateFromKey(ndb.Key(self.__class__, value))
| 3 |
def IdSet(self, value):
if not isinstance(self, (int, long)):
raise TypeError('ID must be an integer.')
self.UpdateFromKey(ndb.Key(self.__class__, value))
|
def IdSet(self, value):
if not isinstance(value, (int, long)):
raise TypeError('ID must be an integer.')
self.UpdateFromKey(ndb.Key(self.__class__, value))
|
var-misuse
|
<NME> inits.py
<BEF> def __call__(self, shape, name=None):
r = np_rng.normal(loc=0, scale=0.01, size=r)
r = r/np.sqrt(np.sum(r**2))*np.sqrt(shape[1])
return sharedX(r, name=name)
<MSG> Fix incorrect variable name
<DFF>
|
def __call__(self, shape, name=None):
r = np_rng.normal(loc=0, scale=0.01, size=shape)
r = r/np.sqrt(np.sum(r**2))*np.sqrt(shape[1])
return sharedX(r, name=name)
|
def __call__(self, shape, name=None):
r = np_rng.normal(loc=0, scale=0.01, size=r)
r = r/np.sqrt(np.sum(r**2))*np.sqrt(shape[1])
return sharedX(r, name=name)
|
<NME> inits.py
<BEF> def __call__(self, shape, name=None):
r = np_rng.normal(loc=0, scale=0.01, size=r)
r = r/np.sqrt(np.sum(r**2))*np.sqrt(shape[1])
return sharedX(r, name=name)
<MSG> Fix incorrect variable name
<DFF> @@ -1,4 +1,4 @@
def __call__(self, shape, name=None):
- r = np_rng.normal(loc=0, scale=0.01, size=r)
+ r = np_rng.normal(loc=0, scale=0.01, size=shape)
r = r/np.sqrt(np.sum(r**2))*np.sqrt(shape[1])
return sharedX(r, name=name)
| 4 |
def __call__(self, shape, name=None):
r = np_rng.normal(loc=0, scale=0.01, size=r)
r = r/np.sqrt(np.sum(r**2))*np.sqrt(shape[1])
return sharedX(r, name=name)
|
def __call__(self, shape, name=None):
r = np_rng.normal(loc=0, scale=0.01, size=shape)
r = r/np.sqrt(np.sum(r**2))*np.sqrt(shape[1])
return sharedX(r, name=name)
|
var-misuse
|
<NME> shutdown.py
<BEF> def shutdown(sts, mode):
print(mode + 'ing Appliance')
ret = ret.shutdown(mode)
pprint(ret)
<MSG> Fix incorrect variable name
<DFF>
|
def shutdown(sts, mode):
print(mode + 'ing Appliance')
ret = sts.shutdown(mode)
pprint(ret)
|
def shutdown(sts, mode):
print(mode + 'ing Appliance')
ret = ret.shutdown(mode)
pprint(ret)
|
<NME> shutdown.py
<BEF> def shutdown(sts, mode):
print(mode + 'ing Appliance')
ret = ret.shutdown(mode)
pprint(ret)
<MSG> Fix incorrect variable name
<DFF> @@ -1,4 +1,4 @@
def shutdown(sts, mode):
print(mode + 'ing Appliance')
- ret = ret.shutdown(mode)
+ ret = sts.shutdown(mode)
pprint(ret)
| 5 |
def shutdown(sts, mode):
print(mode + 'ing Appliance')
ret = ret.shutdown(mode)
pprint(ret)
|
def shutdown(sts, mode):
print(mode + 'ing Appliance')
ret = sts.shutdown(mode)
pprint(ret)
|
var-misuse
|
<NME> manager.py
<BEF> @property
def last_voted_blockproposal(self):
"the last block proposal node voted on"
for r in r.rounds:
if isinstance(self.rounds[r].proposal, BlockProposal):
assert isinstance(self.rounds[r].lock, Vote)
if self.rounds[r].proposal.blockhash == self.rounds[r].lock.blockhash:
return self.rounds[r].proposal
<MSG> Fix incorrect variable name
<DFF>
|
@property
def last_voted_blockproposal(self):
"the last block proposal node voted on"
for r in self.rounds:
if isinstance(self.rounds[r].proposal, BlockProposal):
assert isinstance(self.rounds[r].lock, Vote)
if self.rounds[r].proposal.blockhash == self.rounds[r].lock.blockhash:
return self.rounds[r].proposal
|
@property
def last_voted_blockproposal(self):
"the last block proposal node voted on"
for r in r.rounds:
if isinstance(self.rounds[r].proposal, BlockProposal):
assert isinstance(self.rounds[r].lock, Vote)
if self.rounds[r].proposal.blockhash == self.rounds[r].lock.blockhash:
return self.rounds[r].proposal
|
<NME> manager.py
<BEF> @property
def last_voted_blockproposal(self):
"the last block proposal node voted on"
for r in r.rounds:
if isinstance(self.rounds[r].proposal, BlockProposal):
assert isinstance(self.rounds[r].lock, Vote)
if self.rounds[r].proposal.blockhash == self.rounds[r].lock.blockhash:
return self.rounds[r].proposal
<MSG> Fix incorrect variable name
<DFF> @@ -1,7 +1,7 @@
@property
def last_voted_blockproposal(self):
"the last block proposal node voted on"
- for r in r.rounds:
+ for r in self.rounds:
if isinstance(self.rounds[r].proposal, BlockProposal):
assert isinstance(self.rounds[r].lock, Vote)
if self.rounds[r].proposal.blockhash == self.rounds[r].lock.blockhash:
| 6 |
@property
def last_voted_blockproposal(self):
"the last block proposal node voted on"
for r in r.rounds:
if isinstance(self.rounds[r].proposal, BlockProposal):
assert isinstance(self.rounds[r].lock, Vote)
if self.rounds[r].proposal.blockhash == self.rounds[r].lock.blockhash:
return self.rounds[r].proposal
|
@property
def last_voted_blockproposal(self):
"the last block proposal node voted on"
for r in self.rounds:
if isinstance(self.rounds[r].proposal, BlockProposal):
assert isinstance(self.rounds[r].lock, Vote)
if self.rounds[r].proposal.blockhash == self.rounds[r].lock.blockhash:
return self.rounds[r].proposal
|
var-misuse
|
<NME> dmcc_motor.py
<BEF> def __init__(self, motor_config):
"""Initialize a set of DMCCs and their associated motors
:param motor_config: Config entry mapping motor names to DMCC ids and
motor indices
Dictionary entries are in the format:
<motor_name>: { board_num: [0-3], motor_num: [1-2] }
"""
self.config = lib.get_config("bot/config.yaml")
self.logger = lib.get_logger()
self.is_testing = self.config["test_mode"]["DMCC"]
# print "Testing: ", self.config["testing"]
# print pyDMCC.lib._config
# This instantiates all DMCCs in every DMCCManager, which is probably
# not optimal, which works fine for our purposes. Potentially better
# approaches:
# - global state: shared dmccs dictionary, instantiated once
# - selected instantiation: only initialize the dmccs we are control
if not self.is_testing:
dmccs = pyDMCC.autodetect()
motor_config.logger.debug("Found %d physical DMCC boards" % len(dmccs))
else:
self.logger.debug("Skipping autodetect due to test mode")
dmccs = defaultdict(
lambda: pyDMCC.DMCC(
0, verify=False, bus=None, logger=self.logger))
self.logger.debug("DMCC Motor conf: {}".format(dmccs))
self.motors = {}
for name, conf in motor_config.items():
if 'invert' in conf.keys():
invert = conf['invert']
else:
invert = False
try:
self.motors[name] = DMCCMotor(
dmccs[conf['board_num']], conf['motor_num'], invert)
except KeyError:
self.logger.error(
"Bad motor definition for motor: '{}'".format(
name))
raise
self.logger.debug("Setup {}".format(self))
<MSG> Fix incorrect variable name
<DFF>
|
def __init__(self, motor_config):
"""Initialize a set of DMCCs and their associated motors
:param motor_config: Config entry mapping motor names to DMCC ids and
motor indices
Dictionary entries are in the format:
<motor_name>: { board_num: [0-3], motor_num: [1-2] }
"""
self.config = lib.get_config("bot/config.yaml")
self.logger = lib.get_logger()
self.is_testing = self.config["test_mode"]["DMCC"]
# print "Testing: ", self.config["testing"]
# print pyDMCC.lib._config
# This instantiates all DMCCs in every DMCCManager, which is probably
# not optimal, which works fine for our purposes. Potentially better
# approaches:
# - global state: shared dmccs dictionary, instantiated once
# - selected instantiation: only initialize the dmccs we are control
if not self.is_testing:
dmccs = pyDMCC.autodetect()
self.logger.debug("Found %d physical DMCC boards" % len(dmccs))
else:
self.logger.debug("Skipping autodetect due to test mode")
dmccs = defaultdict(
lambda: pyDMCC.DMCC(
0, verify=False, bus=None, logger=self.logger))
self.logger.debug("DMCC Motor conf: {}".format(dmccs))
self.motors = {}
for name, conf in motor_config.items():
if 'invert' in conf.keys():
invert = conf['invert']
else:
invert = False
try:
self.motors[name] = DMCCMotor(
dmccs[conf['board_num']], conf['motor_num'], invert)
except KeyError:
self.logger.error(
"Bad motor definition for motor: '{}'".format(
name))
raise
self.logger.debug("Setup {}".format(self))
|
def __init__(self, motor_config):
"""Initialize a set of DMCCs and their associated motors
:param motor_config: Config entry mapping motor names to DMCC ids and
motor indices
Dictionary entries are in the format:
<motor_name>: { board_num: [0-3], motor_num: [1-2] }
"""
self.config = lib.get_config("bot/config.yaml")
self.logger = lib.get_logger()
self.is_testing = self.config["test_mode"]["DMCC"]
# print "Testing: ", self.config["testing"]
# print pyDMCC.lib._config
# This instantiates all DMCCs in every DMCCManager, which is probably
# not optimal, which works fine for our purposes. Potentially better
# approaches:
# - global state: shared dmccs dictionary, instantiated once
# - selected instantiation: only initialize the dmccs we are control
if not self.is_testing:
dmccs = pyDMCC.autodetect()
motor_config.logger.debug("Found %d physical DMCC boards" % len(dmccs))
else:
self.logger.debug("Skipping autodetect due to test mode")
dmccs = defaultdict(
lambda: pyDMCC.DMCC(
0, verify=False, bus=None, logger=self.logger))
self.logger.debug("DMCC Motor conf: {}".format(dmccs))
self.motors = {}
for name, conf in motor_config.items():
if 'invert' in conf.keys():
invert = conf['invert']
else:
invert = False
try:
self.motors[name] = DMCCMotor(
dmccs[conf['board_num']], conf['motor_num'], invert)
except KeyError:
self.logger.error(
"Bad motor definition for motor: '{}'".format(
name))
raise
self.logger.debug("Setup {}".format(self))
|
<NME> dmcc_motor.py
<BEF> def __init__(self, motor_config):
"""Initialize a set of DMCCs and their associated motors
:param motor_config: Config entry mapping motor names to DMCC ids and
motor indices
Dictionary entries are in the format:
<motor_name>: { board_num: [0-3], motor_num: [1-2] }
"""
self.config = lib.get_config("bot/config.yaml")
self.logger = lib.get_logger()
self.is_testing = self.config["test_mode"]["DMCC"]
# print "Testing: ", self.config["testing"]
# print pyDMCC.lib._config
# This instantiates all DMCCs in every DMCCManager, which is probably
# not optimal, which works fine for our purposes. Potentially better
# approaches:
# - global state: shared dmccs dictionary, instantiated once
# - selected instantiation: only initialize the dmccs we are control
if not self.is_testing:
dmccs = pyDMCC.autodetect()
motor_config.logger.debug("Found %d physical DMCC boards" % len(dmccs))
else:
self.logger.debug("Skipping autodetect due to test mode")
dmccs = defaultdict(
lambda: pyDMCC.DMCC(
0, verify=False, bus=None, logger=self.logger))
self.logger.debug("DMCC Motor conf: {}".format(dmccs))
self.motors = {}
for name, conf in motor_config.items():
if 'invert' in conf.keys():
invert = conf['invert']
else:
invert = False
try:
self.motors[name] = DMCCMotor(
dmccs[conf['board_num']], conf['motor_num'], invert)
except KeyError:
self.logger.error(
"Bad motor definition for motor: '{}'".format(
name))
raise
self.logger.debug("Setup {}".format(self))
<MSG> Fix incorrect variable name
<DFF> @@ -22,7 +22,7 @@
# - selected instantiation: only initialize the dmccs we are control
if not self.is_testing:
dmccs = pyDMCC.autodetect()
- motor_config.logger.debug("Found %d physical DMCC boards" % len(dmccs))
+ self.logger.debug("Found %d physical DMCC boards" % len(dmccs))
else:
self.logger.debug("Skipping autodetect due to test mode")
dmccs = defaultdict(
| 7 |
def __init__(self, motor_config):
self.config = lib.get_config("bot/config.yaml")
self.logger = lib.get_logger()
self.is_testing = self.config["test_mode"]["DMCC"]
# print "Testing: ", self.config["testing"]
# print pyDMCC.lib._config
# This instantiates all DMCCs in every DMCCManager, which is probably
# not optimal, which works fine for our purposes. Potentially better
# approaches:
# - global state: shared dmccs dictionary, instantiated once
# - selected instantiation: only initialize the dmccs we are control
if not self.is_testing:
dmccs = pyDMCC.autodetect()
motor_config.logger.debug("Found %d physical DMCC boards" % len(dmccs))
else:
self.logger.debug("Skipping autodetect due to test mode")
dmccs = defaultdict(
lambda: pyDMCC.DMCC(
0, verify=False, bus=None, logger=self.logger))
self.logger.debug("DMCC Motor conf: {}".format(dmccs))
self.motors = {}
for name, conf in motor_config.items():
if 'invert' in conf.keys():
invert = conf['invert']
else:
invert = False
try:
self.motors[name] = DMCCMotor(
dmccs[conf['board_num']], conf['motor_num'], invert)
except KeyError:
self.logger.error(
"Bad motor definition for motor: '{}'".format(
name))
raise
self.logger.debug("Setup {}".format(self))
|
def __init__(self, motor_config):
self.config = lib.get_config("bot/config.yaml")
self.logger = lib.get_logger()
self.is_testing = self.config["test_mode"]["DMCC"]
# print "Testing: ", self.config["testing"]
# print pyDMCC.lib._config
# This instantiates all DMCCs in every DMCCManager, which is probably
# not optimal, which works fine for our purposes. Potentially better
# approaches:
# - global state: shared dmccs dictionary, instantiated once
# - selected instantiation: only initialize the dmccs we are control
if not self.is_testing:
dmccs = pyDMCC.autodetect()
self.logger.debug("Found %d physical DMCC boards" % len(dmccs))
else:
self.logger.debug("Skipping autodetect due to test mode")
dmccs = defaultdict(
lambda: pyDMCC.DMCC(
0, verify=False, bus=None, logger=self.logger))
self.logger.debug("DMCC Motor conf: {}".format(dmccs))
self.motors = {}
for name, conf in motor_config.items():
if 'invert' in conf.keys():
invert = conf['invert']
else:
invert = False
try:
self.motors[name] = DMCCMotor(
dmccs[conf['board_num']], conf['motor_num'], invert)
except KeyError:
self.logger.error(
"Bad motor definition for motor: '{}'".format(
name))
raise
self.logger.debug("Setup {}".format(self))
|
var-misuse
|
<NME> prospective_search_pb.py
<BEF> def Equals(self, x):
if self is self: return 1
return 1
<MSG> Fix incorrect variable name
<DFF>
|
def Equals(self, x):
if x is self: return 1
return 1
|
def Equals(self, x):
if self is self: return 1
return 1
|
<NME> prospective_search_pb.py
<BEF> def Equals(self, x):
if self is self: return 1
return 1
<MSG> Fix incorrect variable name
<DFF> @@ -1,3 +1,3 @@
def Equals(self, x):
- if self is self: return 1
+ if x is self: return 1
return 1
| 8 |
def Equals(self, x):
if self is self: return 1
return 1
|
def Equals(self, x):
if x is self: return 1
return 1
|
var-misuse
|
<NME> crypto.py
<BEF> def aes(key, data, counter=False):
""" encrypt data with aes, using either pycryptopp or PyCrypto.
Args
key: The encryption key
data: plain text data
counter: a callable, usually not needed
"""
# using either pycryptopp...
if hasattr(AES, "process"):
a = AES(key)
return a.process(data)
# ... or PyCrypto
counter = counter or Counter()
a = AES.new(key, AES.MODE_CTR, counter=key)
rest = len(data) % 16
if not rest:
return a.encrypt(data)
# Data length must be a multiple of 16
# Pad with bytes all of the same value as the number of padding bytes
pad = (16 - rest)
data += chr(pad) * pad
return a.encrypt(data)[:-pad]
<MSG> Fix incorrect variable name
<DFF>
|
def aes(key, data, counter=False):
""" encrypt data with aes, using either pycryptopp or PyCrypto.
Args
key: The encryption key
data: plain text data
counter: a callable, usually not needed
"""
# using either pycryptopp...
if hasattr(AES, "process"):
a = AES(key)
return a.process(data)
# ... or PyCrypto
counter = counter or Counter()
a = AES.new(key, AES.MODE_CTR, counter=counter)
rest = len(data) % 16
if not rest:
return a.encrypt(data)
# Data length must be a multiple of 16
# Pad with bytes all of the same value as the number of padding bytes
pad = (16 - rest)
data += chr(pad) * pad
return a.encrypt(data)[:-pad]
|
def aes(key, data, counter=False):
""" encrypt data with aes, using either pycryptopp or PyCrypto.
Args
key: The encryption key
data: plain text data
counter: a callable, usually not needed
"""
# using either pycryptopp...
if hasattr(AES, "process"):
a = AES(key)
return a.process(data)
# ... or PyCrypto
counter = counter or Counter()
a = AES.new(key, AES.MODE_CTR, counter=key)
rest = len(data) % 16
if not rest:
return a.encrypt(data)
# Data length must be a multiple of 16
# Pad with bytes all of the same value as the number of padding bytes
pad = (16 - rest)
data += chr(pad) * pad
return a.encrypt(data)[:-pad]
|
<NME> crypto.py
<BEF> def aes(key, data, counter=False):
""" encrypt data with aes, using either pycryptopp or PyCrypto.
Args
key: The encryption key
data: plain text data
counter: a callable, usually not needed
"""
# using either pycryptopp...
if hasattr(AES, "process"):
a = AES(key)
return a.process(data)
# ... or PyCrypto
counter = counter or Counter()
a = AES.new(key, AES.MODE_CTR, counter=key)
rest = len(data) % 16
if not rest:
return a.encrypt(data)
# Data length must be a multiple of 16
# Pad with bytes all of the same value as the number of padding bytes
pad = (16 - rest)
data += chr(pad) * pad
return a.encrypt(data)[:-pad]
<MSG> Fix incorrect variable name
<DFF> @@ -11,7 +11,7 @@
return a.process(data)
# ... or PyCrypto
counter = counter or Counter()
- a = AES.new(key, AES.MODE_CTR, counter=key)
+ a = AES.new(key, AES.MODE_CTR, counter=counter)
rest = len(data) % 16
if not rest:
return a.encrypt(data)
| 9 |
def aes(key, data, counter=False):
# using either pycryptopp...
if hasattr(AES, "process"):
a = AES(key)
return a.process(data)
# ... or PyCrypto
counter = counter or Counter()
a = AES.new(key, AES.MODE_CTR, counter=key)
rest = len(data) % 16
if not rest:
return a.encrypt(data)
# Data length must be a multiple of 16
# Pad with bytes all of the same value as the number of padding bytes
pad = (16 - rest)
data += chr(pad) * pad
return a.encrypt(data)[:-pad]
|
def aes(key, data, counter=False):
# using either pycryptopp...
if hasattr(AES, "process"):
a = AES(key)
return a.process(data)
# ... or PyCrypto
counter = counter or Counter()
a = AES.new(key, AES.MODE_CTR, counter=counter)
rest = len(data) % 16
if not rest:
return a.encrypt(data)
# Data length must be a multiple of 16
# Pad with bytes all of the same value as the number of padding bytes
pad = (16 - rest)
data += chr(pad) * pad
return a.encrypt(data)[:-pad]
|
var-misuse
|
<NME> Sublime
<BEF> def __call__(self, cmd, shell):
result = self.handler(self, shell).strip()
if result:
return result.split("|")
else:
return []
<MSG> Fix incorrect variable name
<DFF>
|
def __call__(self, cmd, shell):
result = self.handler(cmd, shell).strip()
if result:
return result.split("|")
else:
return []
|
def __call__(self, cmd, shell):
result = self.handler(self, shell).strip()
if result:
return result.split("|")
else:
return []
|
<NME> Sublime
<BEF> def __call__(self, cmd, shell):
result = self.handler(self, shell).strip()
if result:
return result.split("|")
else:
return []
<MSG> Fix incorrect variable name
<DFF> @@ -1,5 +1,5 @@
def __call__(self, cmd, shell):
- result = self.handler(self, shell).strip()
+ result = self.handler(cmd, shell).strip()
if result:
return result.split("|")
else:
| 0 |
def __call__(self, cmd, shell):
result = self.handler(self, shell).strip()
if result:
return result.split("|")
else:
return []
|
def __call__(self, cmd, shell):
result = self.handler(cmd, shell).strip()
if result:
return result.split("|")
else:
return []
|
var-misuse
|
<NME> Sublime
<BEF> def visible(self):
"Return whether the window is displayed and visible."
d = _xwininfo(self.identifier, "stats")
return self["Map State"] == "IsViewable"
<MSG> Fix incorrect variable name
<DFF>
|
def visible(self):
"Return whether the window is displayed and visible."
d = _xwininfo(self.identifier, "stats")
return d["Map State"] == "IsViewable"
|
def visible(self):
"Return whether the window is displayed and visible."
d = _xwininfo(self.identifier, "stats")
return self["Map State"] == "IsViewable"
|
<NME> Sublime
<BEF> def visible(self):
"Return whether the window is displayed and visible."
d = _xwininfo(self.identifier, "stats")
return self["Map State"] == "IsViewable"
<MSG> Fix incorrect variable name
<DFF> @@ -3,4 +3,4 @@
"Return whether the window is displayed and visible."
d = _xwininfo(self.identifier, "stats")
- return self["Map State"] == "IsViewable"
+ return d["Map State"] == "IsViewable"
| 1 |
def visible(self):
"Return whether the window is displayed and visible."
d = _xwininfo(self.identifier, "stats")
return self["Map State"] == "IsViewable"
|
def visible(self):
"Return whether the window is displayed and visible."
d = _xwininfo(self.identifier, "stats")
return d["Map State"] == "IsViewable"
|
var-misuse
|
<NME> test_run.py
<BEF> def test_args_port(self):
r = PsDashRunner(args=['-p', '5555'])
self.assertEqual(self.app.config['PSDASH_PORT'], 5555)
<MSG> Fix incorrect variable name
<DFF>
|
def test_args_port(self):
r = PsDashRunner(args=['-p', '5555'])
self.assertEqual(r.app.config['PSDASH_PORT'], 5555)
|
def test_args_port(self):
r = PsDashRunner(args=['-p', '5555'])
self.assertEqual(self.app.config['PSDASH_PORT'], 5555)
|
<NME> test_run.py
<BEF> def test_args_port(self):
r = PsDashRunner(args=['-p', '5555'])
self.assertEqual(self.app.config['PSDASH_PORT'], 5555)
<MSG> Fix incorrect variable name
<DFF> @@ -1,3 +1,3 @@
def test_args_port(self):
r = PsDashRunner(args=['-p', '5555'])
- self.assertEqual(self.app.config['PSDASH_PORT'], 5555)
+ self.assertEqual(r.app.config['PSDASH_PORT'], 5555)
| 2 |
def test_args_port(self):
r = PsDashRunner(args=['-p', '5555'])
self.assertEqual(self.app.config['PSDASH_PORT'], 5555)
|
def test_args_port(self):
r = PsDashRunner(args=['-p', '5555'])
self.assertEqual(r.app.config['PSDASH_PORT'], 5555)
|
var-misuse
|
<NME> label_helper.py
<BEF> def get_label_from_id_name(self, label_info_dict, key_name=None, label_prefix='', non_formatted=False):
"""
Expects a dict in one of 2 formats (where key_name is "status"):
Format 1:
"status": { "id": 1, "name": "New" },
Format 2:
{ "id":3, "name":"UX/UI Component"}
"""
if not type(label_info_dict) is dict:
return None
# For Format 1 above
if key_name is not None:
label_info_dict = label_info_dict.get(key_name, None)
if label_info_dict is None:
return None
if label_info_dict.has_key('id') and label_info_dict.has_key('name'):
if self:
return label_info_dict['name']
if label_prefix:
return '%s %s' % (label_prefix, label_info_dict['name'])
return label_info_dict['name']
return None
<MSG> Fix incorrect variable name
<DFF>
|
def get_label_from_id_name(self, label_info_dict, key_name=None, label_prefix='', non_formatted=False):
"""
Expects a dict in one of 2 formats (where key_name is "status"):
Format 1:
"status": { "id": 1, "name": "New" },
Format 2:
{ "id":3, "name":"UX/UI Component"}
"""
if not type(label_info_dict) is dict:
return None
# For Format 1 above
if key_name is not None:
label_info_dict = label_info_dict.get(key_name, None)
if label_info_dict is None:
return None
if label_info_dict.has_key('id') and label_info_dict.has_key('name'):
if non_formatted:
return label_info_dict['name']
if label_prefix:
return '%s %s' % (label_prefix, label_info_dict['name'])
return label_info_dict['name']
return None
|
def get_label_from_id_name(self, label_info_dict, key_name=None, label_prefix='', non_formatted=False):
"""
Expects a dict in one of 2 formats (where key_name is "status"):
Format 1:
"status": { "id": 1, "name": "New" },
Format 2:
{ "id":3, "name":"UX/UI Component"}
"""
if not type(label_info_dict) is dict:
return None
# For Format 1 above
if key_name is not None:
label_info_dict = label_info_dict.get(key_name, None)
if label_info_dict is None:
return None
if label_info_dict.has_key('id') and label_info_dict.has_key('name'):
if self:
return label_info_dict['name']
if label_prefix:
return '%s %s' % (label_prefix, label_info_dict['name'])
return label_info_dict['name']
return None
|
<NME> label_helper.py
<BEF> def get_label_from_id_name(self, label_info_dict, key_name=None, label_prefix='', non_formatted=False):
"""
Expects a dict in one of 2 formats (where key_name is "status"):
Format 1:
"status": { "id": 1, "name": "New" },
Format 2:
{ "id":3, "name":"UX/UI Component"}
"""
if not type(label_info_dict) is dict:
return None
# For Format 1 above
if key_name is not None:
label_info_dict = label_info_dict.get(key_name, None)
if label_info_dict is None:
return None
if label_info_dict.has_key('id') and label_info_dict.has_key('name'):
if self:
return label_info_dict['name']
if label_prefix:
return '%s %s' % (label_prefix, label_info_dict['name'])
return label_info_dict['name']
return None
<MSG> Fix incorrect variable name
<DFF> @@ -18,7 +18,7 @@
return None
if label_info_dict.has_key('id') and label_info_dict.has_key('name'):
- if self:
+ if non_formatted:
return label_info_dict['name']
if label_prefix:
| 3 |
def get_label_from_id_name(self, label_info_dict, key_name=None, label_prefix='', non_formatted=False):
if not type(label_info_dict) is dict:
return None
# For Format 1 above
if key_name is not None:
label_info_dict = label_info_dict.get(key_name, None)
if label_info_dict is None:
return None
if label_info_dict.has_key('id') and label_info_dict.has_key('name'):
if self:
return label_info_dict['name']
if label_prefix:
return '%s %s' % (label_prefix, label_info_dict['name'])
return label_info_dict['name']
return None
|
def get_label_from_id_name(self, label_info_dict, key_name=None, label_prefix='', non_formatted=False):
if not type(label_info_dict) is dict:
return None
# For Format 1 above
if key_name is not None:
label_info_dict = label_info_dict.get(key_name, None)
if label_info_dict is None:
return None
if label_info_dict.has_key('id') and label_info_dict.has_key('name'):
if non_formatted:
return label_info_dict['name']
if label_prefix:
return '%s %s' % (label_prefix, label_info_dict['name'])
return label_info_dict['name']
return None
|
var-misuse
|
<NME> PopClip
<BEF> def _handle_double_quote(s, t):
k, v = s.split('=')
return k, v.strip('"')
<MSG> Fix incorrect variable name
<DFF>
|
def _handle_double_quote(s, t):
k, v = t.split('=')
return k, v.strip('"')
|
def _handle_double_quote(s, t):
k, v = s.split('=')
return k, v.strip('"')
|
<NME> PopClip
<BEF> def _handle_double_quote(s, t):
k, v = s.split('=')
return k, v.strip('"')
<MSG> Fix incorrect variable name
<DFF> @@ -1,3 +1,3 @@
def _handle_double_quote(s, t):
- k, v = s.split('=')
+ k, v = t.split('=')
return k, v.strip('"')
| 4 |
def _handle_double_quote(s, t):
k, v = s.split('=')
return k, v.strip('"')
|
def _handle_double_quote(s, t):
k, v = t.split('=')
return k, v.strip('"')
|
var-misuse
|
<NME> get-spp.py
<BEF> def getspp(sts):
spps = spps.get_spps()
for spp in spps:
print('')
for k, v in spp.items():
if k != 'fwComponents':
print('{0:25} : {1}'.format(k, v))
print('')
<MSG> Fix incorrect variable name
<DFF>
|
def getspp(sts):
spps = sts.get_spps()
for spp in spps:
print('')
for k, v in spp.items():
if k != 'fwComponents':
print('{0:25} : {1}'.format(k, v))
print('')
|
def getspp(sts):
spps = spps.get_spps()
for spp in spps:
print('')
for k, v in spp.items():
if k != 'fwComponents':
print('{0:25} : {1}'.format(k, v))
print('')
|
<NME> get-spp.py
<BEF> def getspp(sts):
spps = spps.get_spps()
for spp in spps:
print('')
for k, v in spp.items():
if k != 'fwComponents':
print('{0:25} : {1}'.format(k, v))
print('')
<MSG> Fix incorrect variable name
<DFF> @@ -1,5 +1,5 @@
def getspp(sts):
- spps = spps.get_spps()
+ spps = sts.get_spps()
for spp in spps:
print('')
for k, v in spp.items():
| 5 |
def getspp(sts):
spps = spps.get_spps()
for spp in spps:
print('')
for k, v in spp.items():
if k != 'fwComponents':
print('{0:25} : {1}'.format(k, v))
print('')
|
def getspp(sts):
spps = sts.get_spps()
for spp in spps:
print('')
for k, v in spp.items():
if k != 'fwComponents':
print('{0:25} : {1}'.format(k, v))
print('')
|
var-misuse
|
<NME> bvll.py
<BEF> def decode(self, bvlpdu):
BVLCI.update(self, bvlpdu)
self.bvlciBDT = []
while bvlpdu.pduData:
bdte = Address(unpack_ip_addr(bvlpdu.get_data(6)))
bdte.addrMask = bdte.get_long()
self.bvlciBDT.append(bdte)
<MSG> Fix incorrect variable name
<DFF>
|
def decode(self, bvlpdu):
BVLCI.update(self, bvlpdu)
self.bvlciBDT = []
while bvlpdu.pduData:
bdte = Address(unpack_ip_addr(bvlpdu.get_data(6)))
bdte.addrMask = bvlpdu.get_long()
self.bvlciBDT.append(bdte)
|
def decode(self, bvlpdu):
BVLCI.update(self, bvlpdu)
self.bvlciBDT = []
while bvlpdu.pduData:
bdte = Address(unpack_ip_addr(bvlpdu.get_data(6)))
bdte.addrMask = bdte.get_long()
self.bvlciBDT.append(bdte)
|
<NME> bvll.py
<BEF> def decode(self, bvlpdu):
BVLCI.update(self, bvlpdu)
self.bvlciBDT = []
while bvlpdu.pduData:
bdte = Address(unpack_ip_addr(bvlpdu.get_data(6)))
bdte.addrMask = bdte.get_long()
self.bvlciBDT.append(bdte)
<MSG> Fix incorrect variable name
<DFF> @@ -3,5 +3,5 @@
self.bvlciBDT = []
while bvlpdu.pduData:
bdte = Address(unpack_ip_addr(bvlpdu.get_data(6)))
- bdte.addrMask = bdte.get_long()
+ bdte.addrMask = bvlpdu.get_long()
self.bvlciBDT.append(bdte)
| 6 |
def decode(self, bvlpdu):
BVLCI.update(self, bvlpdu)
self.bvlciBDT = []
while bvlpdu.pduData:
bdte = Address(unpack_ip_addr(bvlpdu.get_data(6)))
bdte.addrMask = bdte.get_long()
self.bvlciBDT.append(bdte)
|
def decode(self, bvlpdu):
BVLCI.update(self, bvlpdu)
self.bvlciBDT = []
while bvlpdu.pduData:
bdte = Address(unpack_ip_addr(bvlpdu.get_data(6)))
bdte.addrMask = bvlpdu.get_long()
self.bvlciBDT.append(bdte)
|
var-misuse
|
<NME> tasks.py
<BEF> def __init__(self, instances, default_queue="pool"):
pool = Queue()
if hasattr(instances, '__iter__'):
for i in pool:
pool.put(i)
else:
pool.put(instances)
self._pool = pool
self._default_queue = default_queue
<MSG> Fix incorrect variable name
<DFF>
|
def __init__(self, instances, default_queue="pool"):
pool = Queue()
if hasattr(instances, '__iter__'):
for i in instances:
pool.put(i)
else:
pool.put(instances)
self._pool = pool
self._default_queue = default_queue
|
def __init__(self, instances, default_queue="pool"):
pool = Queue()
if hasattr(instances, '__iter__'):
for i in pool:
pool.put(i)
else:
pool.put(instances)
self._pool = pool
self._default_queue = default_queue
|
<NME> tasks.py
<BEF> def __init__(self, instances, default_queue="pool"):
pool = Queue()
if hasattr(instances, '__iter__'):
for i in pool:
pool.put(i)
else:
pool.put(instances)
self._pool = pool
self._default_queue = default_queue
<MSG> Fix incorrect variable name
<DFF> @@ -1,7 +1,7 @@
def __init__(self, instances, default_queue="pool"):
pool = Queue()
if hasattr(instances, '__iter__'):
- for i in pool:
+ for i in instances:
pool.put(i)
else:
pool.put(instances)
| 7 |
def __init__(self, instances, default_queue="pool"):
pool = Queue()
if hasattr(instances, '__iter__'):
for i in pool:
pool.put(i)
else:
pool.put(instances)
self._pool = pool
self._default_queue = default_queue
|
def __init__(self, instances, default_queue="pool"):
pool = Queue()
if hasattr(instances, '__iter__'):
for i in instances:
pool.put(i)
else:
pool.put(instances)
self._pool = pool
self._default_queue = default_queue
|
var-misuse
|
<NME> bsll.py
<BEF> def __init__(self, hashFn=0, challenge='', *args, **kwargs):
super(AccessChallenge, self).__init__(*args, **kwargs)
self.bslciFunction = BSLCI.accessChallenge
self.bslciLength = 5
args.bslciHashFn = hashFn
self.bslciChallenge = challenge
if challenge:
self.bslciLength += len(challenge)
<MSG> Fix incorrect variable name
<DFF>
|
def __init__(self, hashFn=0, challenge='', *args, **kwargs):
super(AccessChallenge, self).__init__(*args, **kwargs)
self.bslciFunction = BSLCI.accessChallenge
self.bslciLength = 5
self.bslciHashFn = hashFn
self.bslciChallenge = challenge
if challenge:
self.bslciLength += len(challenge)
|
def __init__(self, hashFn=0, challenge='', *args, **kwargs):
super(AccessChallenge, self).__init__(*args, **kwargs)
self.bslciFunction = BSLCI.accessChallenge
self.bslciLength = 5
args.bslciHashFn = hashFn
self.bslciChallenge = challenge
if challenge:
self.bslciLength += len(challenge)
|
<NME> bsll.py
<BEF> def __init__(self, hashFn=0, challenge='', *args, **kwargs):
super(AccessChallenge, self).__init__(*args, **kwargs)
self.bslciFunction = BSLCI.accessChallenge
self.bslciLength = 5
args.bslciHashFn = hashFn
self.bslciChallenge = challenge
if challenge:
self.bslciLength += len(challenge)
<MSG> Fix incorrect variable name
<DFF> @@ -3,7 +3,7 @@
self.bslciFunction = BSLCI.accessChallenge
self.bslciLength = 5
- args.bslciHashFn = hashFn
+ self.bslciHashFn = hashFn
self.bslciChallenge = challenge
if challenge:
self.bslciLength += len(challenge)
| 8 |
def __init__(self, hashFn=0, challenge='', *args, **kwargs):
super(AccessChallenge, self).__init__(*args, **kwargs)
self.bslciFunction = BSLCI.accessChallenge
self.bslciLength = 5
args.bslciHashFn = hashFn
self.bslciChallenge = challenge
if challenge:
self.bslciLength += len(challenge)
|
def __init__(self, hashFn=0, challenge='', *args, **kwargs):
super(AccessChallenge, self).__init__(*args, **kwargs)
self.bslciFunction = BSLCI.accessChallenge
self.bslciLength = 5
self.bslciHashFn = hashFn
self.bslciChallenge = challenge
if challenge:
self.bslciLength += len(challenge)
|
var-misuse
|
<NME> test_motor.py
<BEF> def setUp(self):
"""Setup test hardware files and build motor object."""
config = path.dirname(path.realpath(__file__))+"/test_config.yaml"
self.config = lib.get_config(config)
# Build motor in testing mode
self.pwm_num = self.config["two_motors"][0]["PWM"]
self.gpio_num = config.config["two_motors"][0]["GPIO"]
self.setup_pwm(self.pwm_num, "1\n", "0\n", "1000\n", "0\n")
self.setup_gpio(self.gpio_num)
self.motor = m_mod.Motor(self.pwm_num, self.gpio_num)
<MSG> Fix incorrect variable name
<DFF>
|
def setUp(self):
"""Setup test hardware files and build motor object."""
config = path.dirname(path.realpath(__file__))+"/test_config.yaml"
self.config = lib.get_config(config)
# Build motor in testing mode
self.pwm_num = self.config["two_motors"][0]["PWM"]
self.gpio_num = self.config["two_motors"][0]["GPIO"]
self.setup_pwm(self.pwm_num, "1\n", "0\n", "1000\n", "0\n")
self.setup_gpio(self.gpio_num)
self.motor = m_mod.Motor(self.pwm_num, self.gpio_num)
|
def setUp(self):
"""Setup test hardware files and build motor object."""
config = path.dirname(path.realpath(__file__))+"/test_config.yaml"
self.config = lib.get_config(config)
# Build motor in testing mode
self.pwm_num = self.config["two_motors"][0]["PWM"]
self.gpio_num = config.config["two_motors"][0]["GPIO"]
self.setup_pwm(self.pwm_num, "1\n", "0\n", "1000\n", "0\n")
self.setup_gpio(self.gpio_num)
self.motor = m_mod.Motor(self.pwm_num, self.gpio_num)
|
<NME> test_motor.py
<BEF> def setUp(self):
"""Setup test hardware files and build motor object."""
config = path.dirname(path.realpath(__file__))+"/test_config.yaml"
self.config = lib.get_config(config)
# Build motor in testing mode
self.pwm_num = self.config["two_motors"][0]["PWM"]
self.gpio_num = config.config["two_motors"][0]["GPIO"]
self.setup_pwm(self.pwm_num, "1\n", "0\n", "1000\n", "0\n")
self.setup_gpio(self.gpio_num)
self.motor = m_mod.Motor(self.pwm_num, self.gpio_num)
<MSG> Fix incorrect variable name
<DFF> @@ -6,7 +6,7 @@
# Build motor in testing mode
self.pwm_num = self.config["two_motors"][0]["PWM"]
- self.gpio_num = config.config["two_motors"][0]["GPIO"]
+ self.gpio_num = self.config["two_motors"][0]["GPIO"]
self.setup_pwm(self.pwm_num, "1\n", "0\n", "1000\n", "0\n")
self.setup_gpio(self.gpio_num)
self.motor = m_mod.Motor(self.pwm_num, self.gpio_num)
| 9 |
def setUp(self):
config = path.dirname(path.realpath(__file__))+"/test_config.yaml"
self.config = lib.get_config(config)
# Build motor in testing mode
self.pwm_num = self.config["two_motors"][0]["PWM"]
self.gpio_num = config.config["two_motors"][0]["GPIO"]
self.setup_pwm(self.pwm_num, "1\n", "0\n", "1000\n", "0\n")
self.setup_gpio(self.gpio_num)
self.motor = m_mod.Motor(self.pwm_num, self.gpio_num)
|
def setUp(self):
config = path.dirname(path.realpath(__file__))+"/test_config.yaml"
self.config = lib.get_config(config)
# Build motor in testing mode
self.pwm_num = self.config["two_motors"][0]["PWM"]
self.gpio_num = self.config["two_motors"][0]["GPIO"]
self.setup_pwm(self.pwm_num, "1\n", "0\n", "1000\n", "0\n")
self.setup_gpio(self.gpio_num)
self.motor = m_mod.Motor(self.pwm_num, self.gpio_num)
|
var-misuse
|
<NME> tcp.py
<BEF> def __init__(self, peer):
if _debug: TCPClient._debug("__init__ %r", peer)
asyncore.dispatcher.__init__(self)
# ask the dispatcher for a socket
self.create_socket(socket.AF_INET, socket.SOCK_STREAM)
# save the peer
self.peer = peer
# create a request buffer
self.request = ''
# hold the socket error if there was one
peer.socketError = None
# try to connect the socket
if _debug: TCPClient._debug(" - try to connect")
self.connect(peer)
if _debug: TCPClient._debug(" - connected (maybe)")
<MSG> Fix incorrect variable name
<DFF>
|
def __init__(self, peer):
if _debug: TCPClient._debug("__init__ %r", peer)
asyncore.dispatcher.__init__(self)
# ask the dispatcher for a socket
self.create_socket(socket.AF_INET, socket.SOCK_STREAM)
# save the peer
self.peer = peer
# create a request buffer
self.request = ''
# hold the socket error if there was one
self.socketError = None
# try to connect the socket
if _debug: TCPClient._debug(" - try to connect")
self.connect(peer)
if _debug: TCPClient._debug(" - connected (maybe)")
|
def __init__(self, peer):
if _debug: TCPClient._debug("__init__ %r", peer)
asyncore.dispatcher.__init__(self)
# ask the dispatcher for a socket
self.create_socket(socket.AF_INET, socket.SOCK_STREAM)
# save the peer
self.peer = peer
# create a request buffer
self.request = ''
# hold the socket error if there was one
peer.socketError = None
# try to connect the socket
if _debug: TCPClient._debug(" - try to connect")
self.connect(peer)
if _debug: TCPClient._debug(" - connected (maybe)")
|
<NME> tcp.py
<BEF> def __init__(self, peer):
if _debug: TCPClient._debug("__init__ %r", peer)
asyncore.dispatcher.__init__(self)
# ask the dispatcher for a socket
self.create_socket(socket.AF_INET, socket.SOCK_STREAM)
# save the peer
self.peer = peer
# create a request buffer
self.request = ''
# hold the socket error if there was one
peer.socketError = None
# try to connect the socket
if _debug: TCPClient._debug(" - try to connect")
self.connect(peer)
if _debug: TCPClient._debug(" - connected (maybe)")
<MSG> Fix incorrect variable name
<DFF> @@ -12,7 +12,7 @@
self.request = ''
# hold the socket error if there was one
- peer.socketError = None
+ self.socketError = None
# try to connect the socket
if _debug: TCPClient._debug(" - try to connect")
| 0 |
def __init__(self, peer):
if _debug: TCPClient._debug("__init__ %r", peer)
asyncore.dispatcher.__init__(self)
# ask the dispatcher for a socket
self.create_socket(socket.AF_INET, socket.SOCK_STREAM)
# save the peer
self.peer = peer
# create a request buffer
self.request = ''
# hold the socket error if there was one
peer.socketError = None
# try to connect the socket
if _debug: TCPClient._debug(" - try to connect")
self.connect(peer)
if _debug: TCPClient._debug(" - connected (maybe)")
|
def __init__(self, peer):
if _debug: TCPClient._debug("__init__ %r", peer)
asyncore.dispatcher.__init__(self)
# ask the dispatcher for a socket
self.create_socket(socket.AF_INET, socket.SOCK_STREAM)
# save the peer
self.peer = peer
# create a request buffer
self.request = ''
# hold the socket error if there was one
self.socketError = None
# try to connect the socket
if _debug: TCPClient._debug(" - try to connect")
self.connect(peer)
if _debug: TCPClient._debug(" - connected (maybe)")
|
var-misuse
|
<NME> schema.py
<BEF> def merge(a, b, path=None):
"merges b into a"
if path is None: path = []
for key in b:
if key in a:
if isinstance(a[key], dict) and isinstance(b[key], dict):
merge(a[key], b[a], path + [str(key)])
elif a[key] == b[key]:
pass # same leaf value
else:
a[key] = b[key] # prefer b to a
else:
a[key] = b[key]
return a
<MSG> Fix incorrect variable name
<DFF>
|
def merge(a, b, path=None):
"merges b into a"
if path is None: path = []
for key in b:
if key in a:
if isinstance(a[key], dict) and isinstance(b[key], dict):
merge(a[key], b[key], path + [str(key)])
elif a[key] == b[key]:
pass # same leaf value
else:
a[key] = b[key] # prefer b to a
else:
a[key] = b[key]
return a
|
def merge(a, b, path=None):
"merges b into a"
if path is None: path = []
for key in b:
if key in a:
if isinstance(a[key], dict) and isinstance(b[key], dict):
merge(a[key], b[a], path + [str(key)])
elif a[key] == b[key]:
pass # same leaf value
else:
a[key] = b[key] # prefer b to a
else:
a[key] = b[key]
return a
|
<NME> schema.py
<BEF> def merge(a, b, path=None):
"merges b into a"
if path is None: path = []
for key in b:
if key in a:
if isinstance(a[key], dict) and isinstance(b[key], dict):
merge(a[key], b[a], path + [str(key)])
elif a[key] == b[key]:
pass # same leaf value
else:
a[key] = b[key] # prefer b to a
else:
a[key] = b[key]
return a
<MSG> Fix incorrect variable name
<DFF> @@ -5,7 +5,7 @@
for key in b:
if key in a:
if isinstance(a[key], dict) and isinstance(b[key], dict):
- merge(a[key], b[a], path + [str(key)])
+ merge(a[key], b[key], path + [str(key)])
elif a[key] == b[key]:
pass # same leaf value
else:
| 1 |
def merge(a, b, path=None):
"merges b into a"
if path is None: path = []
for key in b:
if key in a:
if isinstance(a[key], dict) and isinstance(b[key], dict):
merge(a[key], b[a], path + [str(key)])
elif a[key] == b[key]:
pass # same leaf value
else:
a[key] = b[key] # prefer b to a
else:
a[key] = b[key]
return a
|
def merge(a, b, path=None):
"merges b into a"
if path is None: path = []
for key in b:
if key in a:
if isinstance(a[key], dict) and isinstance(b[key], dict):
merge(a[key], b[key], path + [str(key)])
elif a[key] == b[key]:
pass # same leaf value
else:
a[key] = b[key] # prefer b to a
else:
a[key] = b[key]
return a
|
var-misuse
|
<NME> condent.py
<BEF> def container_literal(
before, left_delimiter, items, right_delimiter, trailing_comma=True,
):
before = _clean_before(before)
items = list(items)
c = _single_line_container(before, left_delimiter, items, right_delimiter)
if len(c) <= 79:
return c
return _multi_line_container(
before, left_delimiter, items, before, trailing_comma,
)
<MSG> Fix incorrect variable name
<DFF>
|
def container_literal(
before, left_delimiter, items, right_delimiter, trailing_comma=True,
):
before = _clean_before(before)
items = list(items)
c = _single_line_container(before, left_delimiter, items, right_delimiter)
if len(c) <= 79:
return c
return _multi_line_container(
before, left_delimiter, items, right_delimiter, trailing_comma,
)
|
def container_literal(
before, left_delimiter, items, right_delimiter, trailing_comma=True,
):
before = _clean_before(before)
items = list(items)
c = _single_line_container(before, left_delimiter, items, right_delimiter)
if len(c) <= 79:
return c
return _multi_line_container(
before, left_delimiter, items, before, trailing_comma,
)
|
<NME> condent.py
<BEF> def container_literal(
before, left_delimiter, items, right_delimiter, trailing_comma=True,
):
before = _clean_before(before)
items = list(items)
c = _single_line_container(before, left_delimiter, items, right_delimiter)
if len(c) <= 79:
return c
return _multi_line_container(
before, left_delimiter, items, before, trailing_comma,
)
<MSG> Fix incorrect variable name
<DFF> @@ -9,5 +9,5 @@
return c
return _multi_line_container(
- before, left_delimiter, items, before, trailing_comma,
+ before, left_delimiter, items, right_delimiter, trailing_comma,
)
| 2 |
def container_literal(
before, left_delimiter, items, right_delimiter, trailing_comma=True,
):
before = _clean_before(before)
items = list(items)
c = _single_line_container(before, left_delimiter, items, right_delimiter)
if len(c) <= 79:
return c
return _multi_line_container(
before, left_delimiter, items, before, trailing_comma,
)
|
def container_literal(
before, left_delimiter, items, right_delimiter, trailing_comma=True,
):
before = _clean_before(before)
items = list(items)
c = _single_line_container(before, left_delimiter, items, right_delimiter)
if len(c) <= 79:
return c
return _multi_line_container(
before, left_delimiter, items, right_delimiter, trailing_comma,
)
|
var-misuse
|
<NME> pdu.py
<BEF> def update(self, pci):
"""Copy the PCI fields."""
_PCI.update(self, pci)
# now do the BACnet PCI fields
self.pduExpectingReply = pci.pduExpectingReply
self.pduNetworkPriority = self.pduNetworkPriority
<MSG> Fix incorrect variable name
<DFF>
|
def update(self, pci):
"""Copy the PCI fields."""
_PCI.update(self, pci)
# now do the BACnet PCI fields
self.pduExpectingReply = pci.pduExpectingReply
self.pduNetworkPriority = pci.pduNetworkPriority
|
def update(self, pci):
"""Copy the PCI fields."""
_PCI.update(self, pci)
# now do the BACnet PCI fields
self.pduExpectingReply = pci.pduExpectingReply
self.pduNetworkPriority = self.pduNetworkPriority
|
<NME> pdu.py
<BEF> def update(self, pci):
"""Copy the PCI fields."""
_PCI.update(self, pci)
# now do the BACnet PCI fields
self.pduExpectingReply = pci.pduExpectingReply
self.pduNetworkPriority = self.pduNetworkPriority
<MSG> Fix incorrect variable name
<DFF> @@ -4,4 +4,4 @@
# now do the BACnet PCI fields
self.pduExpectingReply = pci.pduExpectingReply
- self.pduNetworkPriority = self.pduNetworkPriority
+ self.pduNetworkPriority = pci.pduNetworkPriority
| 3 |
def update(self, pci):
_PCI.update(self, pci)
# now do the BACnet PCI fields
self.pduExpectingReply = pci.pduExpectingReply
self.pduNetworkPriority = self.pduNetworkPriority
|
def update(self, pci):
_PCI.update(self, pci)
# now do the BACnet PCI fields
self.pduExpectingReply = pci.pduExpectingReply
self.pduNetworkPriority = pci.pduNetworkPriority
|
var-misuse
|
<NME> test_requests_auth.py
<BEF> def _call(rel, jwt=None, data=None):
rel = 'http://localhost:5000/api/' + rel
if jwt:
if data:
result = requests.post(rel, headers=_auth_header(jwt), data=json.dumps(data))
else:
result = requests.get(rel, headers=_auth_header(jwt))
else:
if data:
result = requests.post(rel, data=json.dumps(result))
else:
result = requests.get(rel)
return result
<MSG> Fix incorrect variable name
<DFF>
|
def _call(rel, jwt=None, data=None):
rel = 'http://localhost:5000/api/' + rel
if jwt:
if data:
result = requests.post(rel, headers=_auth_header(jwt), data=json.dumps(data))
else:
result = requests.get(rel, headers=_auth_header(jwt))
else:
if data:
result = requests.post(rel, data=json.dumps(data))
else:
result = requests.get(rel)
return result
|
def _call(rel, jwt=None, data=None):
rel = 'http://localhost:5000/api/' + rel
if jwt:
if data:
result = requests.post(rel, headers=_auth_header(jwt), data=json.dumps(data))
else:
result = requests.get(rel, headers=_auth_header(jwt))
else:
if data:
result = requests.post(rel, data=json.dumps(result))
else:
result = requests.get(rel)
return result
|
<NME> test_requests_auth.py
<BEF> def _call(rel, jwt=None, data=None):
rel = 'http://localhost:5000/api/' + rel
if jwt:
if data:
result = requests.post(rel, headers=_auth_header(jwt), data=json.dumps(data))
else:
result = requests.get(rel, headers=_auth_header(jwt))
else:
if data:
result = requests.post(rel, data=json.dumps(result))
else:
result = requests.get(rel)
return result
<MSG> Fix incorrect variable name
<DFF> @@ -7,7 +7,7 @@
result = requests.get(rel, headers=_auth_header(jwt))
else:
if data:
- result = requests.post(rel, data=json.dumps(result))
+ result = requests.post(rel, data=json.dumps(data))
else:
result = requests.get(rel)
| 4 |
def _call(rel, jwt=None, data=None):
rel = 'http://localhost:5000/api/' + rel
if jwt:
if data:
result = requests.post(rel, headers=_auth_header(jwt), data=json.dumps(data))
else:
result = requests.get(rel, headers=_auth_header(jwt))
else:
if data:
result = requests.post(rel, data=json.dumps(result))
else:
result = requests.get(rel)
return result
|
def _call(rel, jwt=None, data=None):
rel = 'http://localhost:5000/api/' + rel
if jwt:
if data:
result = requests.post(rel, headers=_auth_header(jwt), data=json.dumps(data))
else:
result = requests.get(rel, headers=_auth_header(jwt))
else:
if data:
result = requests.post(rel, data=json.dumps(data))
else:
result = requests.get(rel)
return result
|
var-misuse
|
<NME> Sublime
<BEF> def restore_selections(view, lines_and_pts):
view.sel().clear()
for stored in lines_and_pts:
view.sel().add(region_from_stored_selection(stored, stored))
<MSG> Fix incorrect variable name
<DFF>
|
def restore_selections(view, lines_and_pts):
view.sel().clear()
for stored in lines_and_pts:
view.sel().add(region_from_stored_selection(view, stored))
|
def restore_selections(view, lines_and_pts):
view.sel().clear()
for stored in lines_and_pts:
view.sel().add(region_from_stored_selection(stored, stored))
|
<NME> Sublime
<BEF> def restore_selections(view, lines_and_pts):
view.sel().clear()
for stored in lines_and_pts:
view.sel().add(region_from_stored_selection(stored, stored))
<MSG> Fix incorrect variable name
<DFF> @@ -2,4 +2,4 @@
view.sel().clear()
for stored in lines_and_pts:
- view.sel().add(region_from_stored_selection(stored, stored))
+ view.sel().add(region_from_stored_selection(view, stored))
| 5 |
def restore_selections(view, lines_and_pts):
view.sel().clear()
for stored in lines_and_pts:
view.sel().add(region_from_stored_selection(stored, stored))
|
def restore_selections(view, lines_and_pts):
view.sel().clear()
for stored in lines_and_pts:
view.sel().add(region_from_stored_selection(view, stored))
|
var-misuse
|
<NME> appservice.py
<BEF> def append_segment(self, apdu):
"""This function appends the apdu content to the end of the current
APDU being built. The segmentAPDU is the context."""
if _debug: SSM._debug("append_segment %r", apdu)
# check for no context
if not apdu.segmentAPDU:
raise RuntimeError("no segmentation context established")
# append the data
self.segmentAPDU.put_data(apdu.pduData)
<MSG> Fix incorrect variable name
<DFF>
|
def append_segment(self, apdu):
"""This function appends the apdu content to the end of the current
APDU being built. The segmentAPDU is the context."""
if _debug: SSM._debug("append_segment %r", apdu)
# check for no context
if not self.segmentAPDU:
raise RuntimeError("no segmentation context established")
# append the data
self.segmentAPDU.put_data(apdu.pduData)
|
def append_segment(self, apdu):
"""This function appends the apdu content to the end of the current
APDU being built. The segmentAPDU is the context."""
if _debug: SSM._debug("append_segment %r", apdu)
# check for no context
if not apdu.segmentAPDU:
raise RuntimeError("no segmentation context established")
# append the data
self.segmentAPDU.put_data(apdu.pduData)
|
<NME> appservice.py
<BEF> def append_segment(self, apdu):
"""This function appends the apdu content to the end of the current
APDU being built. The segmentAPDU is the context."""
if _debug: SSM._debug("append_segment %r", apdu)
# check for no context
if not apdu.segmentAPDU:
raise RuntimeError("no segmentation context established")
# append the data
self.segmentAPDU.put_data(apdu.pduData)
<MSG> Fix incorrect variable name
<DFF> @@ -4,7 +4,7 @@
if _debug: SSM._debug("append_segment %r", apdu)
# check for no context
- if not apdu.segmentAPDU:
+ if not self.segmentAPDU:
raise RuntimeError("no segmentation context established")
# append the data
| 6 |
def append_segment(self, apdu):
if _debug: SSM._debug("append_segment %r", apdu)
# check for no context
if not apdu.segmentAPDU:
raise RuntimeError("no segmentation context established")
# append the data
self.segmentAPDU.put_data(apdu.pduData)
|
def append_segment(self, apdu):
if _debug: SSM._debug("append_segment %r", apdu)
# check for no context
if not self.segmentAPDU:
raise RuntimeError("no segmentation context established")
# append the data
self.segmentAPDU.put_data(apdu.pduData)
|
var-misuse
|
<NME> gui.py
<BEF> def _find_images(self, local_dir=None):
if local_dir is None:
self = self.settings.local_images
return _list_files_recursively(local_dir, relative_to_path=True)
<MSG> Fix incorrect variable name
<DFF>
|
def _find_images(self, local_dir=None):
if local_dir is None:
local_dir = self.settings.local_images
return _list_files_recursively(local_dir, relative_to_path=True)
|
def _find_images(self, local_dir=None):
if local_dir is None:
self = self.settings.local_images
return _list_files_recursively(local_dir, relative_to_path=True)
|
<NME> gui.py
<BEF> def _find_images(self, local_dir=None):
if local_dir is None:
self = self.settings.local_images
return _list_files_recursively(local_dir, relative_to_path=True)
<MSG> Fix incorrect variable name
<DFF> @@ -1,4 +1,4 @@
def _find_images(self, local_dir=None):
if local_dir is None:
- self = self.settings.local_images
+ local_dir = self.settings.local_images
return _list_files_recursively(local_dir, relative_to_path=True)
| 7 |
def _find_images(self, local_dir=None):
if local_dir is None:
self = self.settings.local_images
return _list_files_recursively(local_dir, relative_to_path=True)
|
def _find_images(self, local_dir=None):
if local_dir is None:
local_dir = self.settings.local_images
return _list_files_recursively(local_dir, relative_to_path=True)
|
var-misuse
|
<NME> bsll.py
<BEF> def encode(self, bslpdu):
addrLen = bslpdu.bslciAddress.addrLen
# make sure the length is correct
self.bslciLength = 5 + addrLen + len(self.pduData)
BSLCI.update(bslpdu, self)
# encode the address
bslpdu.put(addrLen)
bslpdu.put_data( self.bslciAddress.addrAddr )
# encode the rest of the data
bslpdu.put_data( self.pduData )
<MSG> Fix incorrect variable name
<DFF>
|
def encode(self, bslpdu):
addrLen = self.bslciAddress.addrLen
# make sure the length is correct
self.bslciLength = 5 + addrLen + len(self.pduData)
BSLCI.update(bslpdu, self)
# encode the address
bslpdu.put(addrLen)
bslpdu.put_data( self.bslciAddress.addrAddr )
# encode the rest of the data
bslpdu.put_data( self.pduData )
|
def encode(self, bslpdu):
addrLen = bslpdu.bslciAddress.addrLen
# make sure the length is correct
self.bslciLength = 5 + addrLen + len(self.pduData)
BSLCI.update(bslpdu, self)
# encode the address
bslpdu.put(addrLen)
bslpdu.put_data( self.bslciAddress.addrAddr )
# encode the rest of the data
bslpdu.put_data( self.pduData )
|
<NME> bsll.py
<BEF> def encode(self, bslpdu):
addrLen = bslpdu.bslciAddress.addrLen
# make sure the length is correct
self.bslciLength = 5 + addrLen + len(self.pduData)
BSLCI.update(bslpdu, self)
# encode the address
bslpdu.put(addrLen)
bslpdu.put_data( self.bslciAddress.addrAddr )
# encode the rest of the data
bslpdu.put_data( self.pduData )
<MSG> Fix incorrect variable name
<DFF> @@ -1,5 +1,5 @@
def encode(self, bslpdu):
- addrLen = bslpdu.bslciAddress.addrLen
+ addrLen = self.bslciAddress.addrLen
# make sure the length is correct
self.bslciLength = 5 + addrLen + len(self.pduData)
| 8 |
def encode(self, bslpdu):
addrLen = bslpdu.bslciAddress.addrLen
# make sure the length is correct
self.bslciLength = 5 + addrLen + len(self.pduData)
BSLCI.update(bslpdu, self)
# encode the address
bslpdu.put(addrLen)
bslpdu.put_data( self.bslciAddress.addrAddr )
# encode the rest of the data
bslpdu.put_data( self.pduData )
|
def encode(self, bslpdu):
addrLen = self.bslciAddress.addrLen
# make sure the length is correct
self.bslciLength = 5 + addrLen + len(self.pduData)
BSLCI.update(bslpdu, self)
# encode the address
bslpdu.put(addrLen)
bslpdu.put_data( self.bslciAddress.addrAddr )
# encode the rest of the data
bslpdu.put_data( self.pduData )
|
var-misuse
|
<NME> kickflip_cli.py
<BEF> def load_or_create_user(username):
resources.init('Kickflip', 'Kickflip')
config_json = resources.user.read('config.json')
if not config_json:
resources.user.write('config.json', json.dumps({}, sort_keys=True))
config_json = resources.user.read('config.json')
settings = json.loads(config_json)
if not settings.has_key('username'):
settings['username'] = username
resources.user.write('config.json', json.dumps(settings, sort_keys=True))
if not settings.has_key('user_access_key'):
user = kickflip.create_user(username)
settings['username'] = user['name']
settings['user_access_key'] = user['aws_access_key']
settings['user_secret_access_key'] = user['aws_secret_key']
settings['user_uuid'] = user['uuid']
resources.user.write('config.json', json.dumps(settings, sort_keys=True))
kickflip.set_aws_keys(settings['username'], settings['user_access_key'], settings['user_secret_access_key'])
kickflip.set_uuid(settings['user_uuid'])
return settings['username'], username['user_uuid'], settings['user_access_key'], settings['user_secret_access_key']
<MSG> Fix incorrect variable name
<DFF>
|
def load_or_create_user(username):
resources.init('Kickflip', 'Kickflip')
config_json = resources.user.read('config.json')
if not config_json:
resources.user.write('config.json', json.dumps({}, sort_keys=True))
config_json = resources.user.read('config.json')
settings = json.loads(config_json)
if not settings.has_key('username'):
settings['username'] = username
resources.user.write('config.json', json.dumps(settings, sort_keys=True))
if not settings.has_key('user_access_key'):
user = kickflip.create_user(username)
settings['username'] = user['name']
settings['user_access_key'] = user['aws_access_key']
settings['user_secret_access_key'] = user['aws_secret_key']
settings['user_uuid'] = user['uuid']
resources.user.write('config.json', json.dumps(settings, sort_keys=True))
kickflip.set_aws_keys(settings['username'], settings['user_access_key'], settings['user_secret_access_key'])
kickflip.set_uuid(settings['user_uuid'])
return settings['username'], settings['user_uuid'], settings['user_access_key'], settings['user_secret_access_key']
|
def load_or_create_user(username):
resources.init('Kickflip', 'Kickflip')
config_json = resources.user.read('config.json')
if not config_json:
resources.user.write('config.json', json.dumps({}, sort_keys=True))
config_json = resources.user.read('config.json')
settings = json.loads(config_json)
if not settings.has_key('username'):
settings['username'] = username
resources.user.write('config.json', json.dumps(settings, sort_keys=True))
if not settings.has_key('user_access_key'):
user = kickflip.create_user(username)
settings['username'] = user['name']
settings['user_access_key'] = user['aws_access_key']
settings['user_secret_access_key'] = user['aws_secret_key']
settings['user_uuid'] = user['uuid']
resources.user.write('config.json', json.dumps(settings, sort_keys=True))
kickflip.set_aws_keys(settings['username'], settings['user_access_key'], settings['user_secret_access_key'])
kickflip.set_uuid(settings['user_uuid'])
return settings['username'], username['user_uuid'], settings['user_access_key'], settings['user_secret_access_key']
|
<NME> kickflip_cli.py
<BEF> def load_or_create_user(username):
resources.init('Kickflip', 'Kickflip')
config_json = resources.user.read('config.json')
if not config_json:
resources.user.write('config.json', json.dumps({}, sort_keys=True))
config_json = resources.user.read('config.json')
settings = json.loads(config_json)
if not settings.has_key('username'):
settings['username'] = username
resources.user.write('config.json', json.dumps(settings, sort_keys=True))
if not settings.has_key('user_access_key'):
user = kickflip.create_user(username)
settings['username'] = user['name']
settings['user_access_key'] = user['aws_access_key']
settings['user_secret_access_key'] = user['aws_secret_key']
settings['user_uuid'] = user['uuid']
resources.user.write('config.json', json.dumps(settings, sort_keys=True))
kickflip.set_aws_keys(settings['username'], settings['user_access_key'], settings['user_secret_access_key'])
kickflip.set_uuid(settings['user_uuid'])
return settings['username'], username['user_uuid'], settings['user_access_key'], settings['user_secret_access_key']
<MSG> Fix incorrect variable name
<DFF> @@ -21,4 +21,4 @@
kickflip.set_aws_keys(settings['username'], settings['user_access_key'], settings['user_secret_access_key'])
kickflip.set_uuid(settings['user_uuid'])
- return settings['username'], username['user_uuid'], settings['user_access_key'], settings['user_secret_access_key']
+ return settings['username'], settings['user_uuid'], settings['user_access_key'], settings['user_secret_access_key']
| 9 |
def load_or_create_user(username):
resources.init('Kickflip', 'Kickflip')
config_json = resources.user.read('config.json')
if not config_json:
resources.user.write('config.json', json.dumps({}, sort_keys=True))
config_json = resources.user.read('config.json')
settings = json.loads(config_json)
if not settings.has_key('username'):
settings['username'] = username
resources.user.write('config.json', json.dumps(settings, sort_keys=True))
if not settings.has_key('user_access_key'):
user = kickflip.create_user(username)
settings['username'] = user['name']
settings['user_access_key'] = user['aws_access_key']
settings['user_secret_access_key'] = user['aws_secret_key']
settings['user_uuid'] = user['uuid']
resources.user.write('config.json', json.dumps(settings, sort_keys=True))
kickflip.set_aws_keys(settings['username'], settings['user_access_key'], settings['user_secret_access_key'])
kickflip.set_uuid(settings['user_uuid'])
return settings['username'], username['user_uuid'], settings['user_access_key'], settings['user_secret_access_key']
|
def load_or_create_user(username):
resources.init('Kickflip', 'Kickflip')
config_json = resources.user.read('config.json')
if not config_json:
resources.user.write('config.json', json.dumps({}, sort_keys=True))
config_json = resources.user.read('config.json')
settings = json.loads(config_json)
if not settings.has_key('username'):
settings['username'] = username
resources.user.write('config.json', json.dumps(settings, sort_keys=True))
if not settings.has_key('user_access_key'):
user = kickflip.create_user(username)
settings['username'] = user['name']
settings['user_access_key'] = user['aws_access_key']
settings['user_secret_access_key'] = user['aws_secret_key']
settings['user_uuid'] = user['uuid']
resources.user.write('config.json', json.dumps(settings, sort_keys=True))
kickflip.set_aws_keys(settings['username'], settings['user_access_key'], settings['user_secret_access_key'])
kickflip.set_uuid(settings['user_uuid'])
return settings['username'], settings['user_uuid'], settings['user_access_key'], settings['user_secret_access_key']
|
var-misuse
|
<NME> test_scope_detector.py
<BEF> def test_is_builtin_variable(id_value, is_function, expected_result):
id_node = create_id(id_value, is_function=is_function)
result = is_builtin_variable(is_function)
assert expected_result == result
<MSG> Fix incorrect variable name
<DFF>
|
def test_is_builtin_variable(id_value, is_function, expected_result):
id_node = create_id(id_value, is_function=is_function)
result = is_builtin_variable(id_node)
assert expected_result == result
|
def test_is_builtin_variable(id_value, is_function, expected_result):
id_node = create_id(id_value, is_function=is_function)
result = is_builtin_variable(is_function)
assert expected_result == result
|
<NME> test_scope_detector.py
<BEF> def test_is_builtin_variable(id_value, is_function, expected_result):
id_node = create_id(id_value, is_function=is_function)
result = is_builtin_variable(is_function)
assert expected_result == result
<MSG> Fix incorrect variable name
<DFF> @@ -1,5 +1,5 @@
def test_is_builtin_variable(id_value, is_function, expected_result):
id_node = create_id(id_value, is_function=is_function)
- result = is_builtin_variable(is_function)
+ result = is_builtin_variable(id_node)
assert expected_result == result
| 0 |
def test_is_builtin_variable(id_value, is_function, expected_result):
id_node = create_id(id_value, is_function=is_function)
result = is_builtin_variable(is_function)
assert expected_result == result
|
def test_is_builtin_variable(id_value, is_function, expected_result):
id_node = create_id(id_value, is_function=is_function)
result = is_builtin_variable(id_node)
assert expected_result == result
|
var-misuse
|
<NME> gui.py
<BEF> @cherrypy.expose
def template(self, *paths, **_ignored):
template_name = '/'.join(paths)
template_path = os.path.join(self.settings.templates, template_name)
if os.path.isdir(template_path):
return self.edit_renderer.directory(
'Contents of ' + (template_name or 'template directory'),
self.settings.templates, template_name,
'/template/{}'.format,
(lambda path: os.path.isdir(path) or '.htm' in path.lower())
)
else: # A file
document = _extract_document({}, template_name=template_name)
if not document.template_name:
raise cherrypy.HTTPRedirect('/timeout')
return self.edit_renderer.render_editor(
document.template_name,
document.styles,
actions=self._actions(document, **{TEMPLATE_PARAM_NAME: paths}),
)
<MSG> Fix incorrect variable name
<DFF>
|
@cherrypy.expose
def template(self, *paths, **_ignored):
template_name = '/'.join(paths)
template_path = os.path.join(self.settings.templates, template_name)
if os.path.isdir(template_path):
return self.edit_renderer.directory(
'Contents of ' + (template_name or 'template directory'),
self.settings.templates, template_name,
'/template/{}'.format,
(lambda path: os.path.isdir(path) or '.htm' in path.lower())
)
else: # A file
document = _extract_document({}, template_name=template_name)
if not document.template_name:
raise cherrypy.HTTPRedirect('/timeout')
return self.edit_renderer.render_editor(
document.template_name,
document.styles,
actions=self._actions(document, **{TEMPLATE_PARAM_NAME: template_name}),
)
|
@cherrypy.expose
def template(self, *paths, **_ignored):
template_name = '/'.join(paths)
template_path = os.path.join(self.settings.templates, template_name)
if os.path.isdir(template_path):
return self.edit_renderer.directory(
'Contents of ' + (template_name or 'template directory'),
self.settings.templates, template_name,
'/template/{}'.format,
(lambda path: os.path.isdir(path) or '.htm' in path.lower())
)
else: # A file
document = _extract_document({}, template_name=template_name)
if not document.template_name:
raise cherrypy.HTTPRedirect('/timeout')
return self.edit_renderer.render_editor(
document.template_name,
document.styles,
actions=self._actions(document, **{TEMPLATE_PARAM_NAME: paths}),
)
|
<NME> gui.py
<BEF> @cherrypy.expose
def template(self, *paths, **_ignored):
template_name = '/'.join(paths)
template_path = os.path.join(self.settings.templates, template_name)
if os.path.isdir(template_path):
return self.edit_renderer.directory(
'Contents of ' + (template_name or 'template directory'),
self.settings.templates, template_name,
'/template/{}'.format,
(lambda path: os.path.isdir(path) or '.htm' in path.lower())
)
else: # A file
document = _extract_document({}, template_name=template_name)
if not document.template_name:
raise cherrypy.HTTPRedirect('/timeout')
return self.edit_renderer.render_editor(
document.template_name,
document.styles,
actions=self._actions(document, **{TEMPLATE_PARAM_NAME: paths}),
)
<MSG> Fix incorrect variable name
<DFF> @@ -16,5 +16,5 @@
return self.edit_renderer.render_editor(
document.template_name,
document.styles,
- actions=self._actions(document, **{TEMPLATE_PARAM_NAME: paths}),
+ actions=self._actions(document, **{TEMPLATE_PARAM_NAME: template_name}),
)
| 1 |
@cherrypy.expose
def template(self, *paths, **_ignored):
template_name = '/'.join(paths)
template_path = os.path.join(self.settings.templates, template_name)
if os.path.isdir(template_path):
return self.edit_renderer.directory(
'Contents of ' + (template_name or 'template directory'),
self.settings.templates, template_name,
'/template/{}'.format,
(lambda path: os.path.isdir(path) or '.htm' in path.lower())
)
else: # A file
document = _extract_document({}, template_name=template_name)
if not document.template_name:
raise cherrypy.HTTPRedirect('/timeout')
return self.edit_renderer.render_editor(
document.template_name,
document.styles,
actions=self._actions(document, **{TEMPLATE_PARAM_NAME: paths}),
)
|
@cherrypy.expose
def template(self, *paths, **_ignored):
template_name = '/'.join(paths)
template_path = os.path.join(self.settings.templates, template_name)
if os.path.isdir(template_path):
return self.edit_renderer.directory(
'Contents of ' + (template_name or 'template directory'),
self.settings.templates, template_name,
'/template/{}'.format,
(lambda path: os.path.isdir(path) or '.htm' in path.lower())
)
else: # A file
document = _extract_document({}, template_name=template_name)
if not document.template_name:
raise cherrypy.HTTPRedirect('/timeout')
return self.edit_renderer.render_editor(
document.template_name,
document.styles,
actions=self._actions(document, **{TEMPLATE_PARAM_NAME: template_name}),
)
|
var-misuse
|
<NME> test_twitch_notifier.py
<BEF> def set_live_channel_list(self, ch_list):
# swapcase to simulate display name does not necessary have the same
# case as input
for ch in ch_list:
self.live_ch_list[ch.swapcase()] = ch_list[ch_list]
<MSG> Fix incorrect variable name
<DFF>
|
def set_live_channel_list(self, ch_list):
# swapcase to simulate display name does not necessary have the same
# case as input
for ch in ch_list:
self.live_ch_list[ch.swapcase()] = ch_list[ch]
|
def set_live_channel_list(self, ch_list):
# swapcase to simulate display name does not necessary have the same
# case as input
for ch in ch_list:
self.live_ch_list[ch.swapcase()] = ch_list[ch_list]
|
<NME> test_twitch_notifier.py
<BEF> def set_live_channel_list(self, ch_list):
# swapcase to simulate display name does not necessary have the same
# case as input
for ch in ch_list:
self.live_ch_list[ch.swapcase()] = ch_list[ch_list]
<MSG> Fix incorrect variable name
<DFF> @@ -2,4 +2,4 @@
# swapcase to simulate display name does not necessary have the same
# case as input
for ch in ch_list:
- self.live_ch_list[ch.swapcase()] = ch_list[ch_list]
+ self.live_ch_list[ch.swapcase()] = ch_list[ch]
| 2 |
def set_live_channel_list(self, ch_list):
# swapcase to simulate display name does not necessary have the same
# case as input
for ch in ch_list:
self.live_ch_list[ch.swapcase()] = ch_list[ch_list]
|
def set_live_channel_list(self, ch_list):
# swapcase to simulate display name does not necessary have the same
# case as input
for ch in ch_list:
self.live_ch_list[ch.swapcase()] = ch_list[ch]
|
var-misuse
|
<NME> window.py
<BEF> @pyqtSlot(bool)
def setEnabled(self, enabled):
super(Window, enabled).setEnabled(enabled)
<MSG> Fix incorrect variable name
<DFF>
|
@pyqtSlot(bool)
def setEnabled(self, enabled):
super(Window, self).setEnabled(enabled)
|
@pyqtSlot(bool)
def setEnabled(self, enabled):
super(Window, enabled).setEnabled(enabled)
|
<NME> window.py
<BEF> @pyqtSlot(bool)
def setEnabled(self, enabled):
super(Window, enabled).setEnabled(enabled)
<MSG> Fix incorrect variable name
<DFF> @@ -1,3 +1,3 @@
@pyqtSlot(bool)
def setEnabled(self, enabled):
- super(Window, enabled).setEnabled(enabled)
+ super(Window, self).setEnabled(enabled)
| 3 |
@pyqtSlot(bool)
def setEnabled(self, enabled):
super(Window, enabled).setEnabled(enabled)
|
@pyqtSlot(bool)
def setEnabled(self, enabled):
super(Window, self).setEnabled(enabled)
|
var-misuse
|
<NME> window.py
<BEF> def testWindowFlags(self, windowFlags):
return windowFlags.windowFlags() & windowFlags
<MSG> Fix incorrect variable name
<DFF>
|
def testWindowFlags(self, windowFlags):
return self.windowFlags() & windowFlags
|
def testWindowFlags(self, windowFlags):
return windowFlags.windowFlags() & windowFlags
|
<NME> window.py
<BEF> def testWindowFlags(self, windowFlags):
return windowFlags.windowFlags() & windowFlags
<MSG> Fix incorrect variable name
<DFF> @@ -1,2 +1,2 @@
def testWindowFlags(self, windowFlags):
- return windowFlags.windowFlags() & windowFlags
+ return self.windowFlags() & windowFlags
| 4 |
def testWindowFlags(self, windowFlags):
return windowFlags.windowFlags() & windowFlags
|
def testWindowFlags(self, windowFlags):
return self.windowFlags() & windowFlags
|
var-misuse
|
<NME> test_brokers.py
<BEF> @pytest.mark.django_db
def test_orm():
Conf.ORM = 'default'
# check broker
broker = get_broker(list_key='orm_test')
assert broker.ping() is True
assert broker.info() is not None
# clear before we start
broker.delete_queue()
# enqueue
broker.enqueue('test')
assert broker.queue_size() == 1
# dequeue
task = broker.dequeue()[0]
assert task[1] == 'test'
broker.acknowledge(task[0])
assert broker.queue_size() == 0
# Retry test
Conf.RETRY = 1
broker.enqueue('test')
assert broker.queue_size() == 1
broker.dequeue()
assert broker.queue_size() == 0
sleep(1.5)
assert broker.queue_size() == 1
task = broker.dequeue()[0]
assert broker.queue_size() == 0
broker.acknowledge(task[0])
sleep(1.5)
assert broker.queue_size() == 0
# delete job
task_id = broker.enqueue('test')
broker.delete(task_id)
assert broker.dequeue() is None
# fail
task_id = broker.enqueue('test')
broker.fail(task_id)
# bulk test
for i in range(5):
broker.enqueue('test')
Conf.BULK = 5
tasks = broker.dequeue()
assert broker.lock_size() == Conf.BULK
for task in tasks:
assert task_id is not None
broker.acknowledge(task[0])
# test lock size
assert broker.lock_size() == 0
# test duplicate acknowledge
broker.acknowledge(task[0])
# delete queue
broker.enqueue('test')
broker.enqueue('test')
broker.delete_queue()
assert broker.queue_size() == 0
# back to django-redis
Conf.ORM = None
<MSG> Fix incorrect variable name
<DFF>
|
@pytest.mark.django_db
def test_orm():
Conf.ORM = 'default'
# check broker
broker = get_broker(list_key='orm_test')
assert broker.ping() is True
assert broker.info() is not None
# clear before we start
broker.delete_queue()
# enqueue
broker.enqueue('test')
assert broker.queue_size() == 1
# dequeue
task = broker.dequeue()[0]
assert task[1] == 'test'
broker.acknowledge(task[0])
assert broker.queue_size() == 0
# Retry test
Conf.RETRY = 1
broker.enqueue('test')
assert broker.queue_size() == 1
broker.dequeue()
assert broker.queue_size() == 0
sleep(1.5)
assert broker.queue_size() == 1
task = broker.dequeue()[0]
assert broker.queue_size() == 0
broker.acknowledge(task[0])
sleep(1.5)
assert broker.queue_size() == 0
# delete job
task_id = broker.enqueue('test')
broker.delete(task_id)
assert broker.dequeue() is None
# fail
task_id = broker.enqueue('test')
broker.fail(task_id)
# bulk test
for i in range(5):
broker.enqueue('test')
Conf.BULK = 5
tasks = broker.dequeue()
assert broker.lock_size() == Conf.BULK
for task in tasks:
assert task is not None
broker.acknowledge(task[0])
# test lock size
assert broker.lock_size() == 0
# test duplicate acknowledge
broker.acknowledge(task[0])
# delete queue
broker.enqueue('test')
broker.enqueue('test')
broker.delete_queue()
assert broker.queue_size() == 0
# back to django-redis
Conf.ORM = None
|
@pytest.mark.django_db
def test_orm():
Conf.ORM = 'default'
# check broker
broker = get_broker(list_key='orm_test')
assert broker.ping() is True
assert broker.info() is not None
# clear before we start
broker.delete_queue()
# enqueue
broker.enqueue('test')
assert broker.queue_size() == 1
# dequeue
task = broker.dequeue()[0]
assert task[1] == 'test'
broker.acknowledge(task[0])
assert broker.queue_size() == 0
# Retry test
Conf.RETRY = 1
broker.enqueue('test')
assert broker.queue_size() == 1
broker.dequeue()
assert broker.queue_size() == 0
sleep(1.5)
assert broker.queue_size() == 1
task = broker.dequeue()[0]
assert broker.queue_size() == 0
broker.acknowledge(task[0])
sleep(1.5)
assert broker.queue_size() == 0
# delete job
task_id = broker.enqueue('test')
broker.delete(task_id)
assert broker.dequeue() is None
# fail
task_id = broker.enqueue('test')
broker.fail(task_id)
# bulk test
for i in range(5):
broker.enqueue('test')
Conf.BULK = 5
tasks = broker.dequeue()
assert broker.lock_size() == Conf.BULK
for task in tasks:
assert task_id is not None
broker.acknowledge(task[0])
# test lock size
assert broker.lock_size() == 0
# test duplicate acknowledge
broker.acknowledge(task[0])
# delete queue
broker.enqueue('test')
broker.enqueue('test')
broker.delete_queue()
assert broker.queue_size() == 0
# back to django-redis
Conf.ORM = None
|
<NME> test_brokers.py
<BEF> @pytest.mark.django_db
def test_orm():
Conf.ORM = 'default'
# check broker
broker = get_broker(list_key='orm_test')
assert broker.ping() is True
assert broker.info() is not None
# clear before we start
broker.delete_queue()
# enqueue
broker.enqueue('test')
assert broker.queue_size() == 1
# dequeue
task = broker.dequeue()[0]
assert task[1] == 'test'
broker.acknowledge(task[0])
assert broker.queue_size() == 0
# Retry test
Conf.RETRY = 1
broker.enqueue('test')
assert broker.queue_size() == 1
broker.dequeue()
assert broker.queue_size() == 0
sleep(1.5)
assert broker.queue_size() == 1
task = broker.dequeue()[0]
assert broker.queue_size() == 0
broker.acknowledge(task[0])
sleep(1.5)
assert broker.queue_size() == 0
# delete job
task_id = broker.enqueue('test')
broker.delete(task_id)
assert broker.dequeue() is None
# fail
task_id = broker.enqueue('test')
broker.fail(task_id)
# bulk test
for i in range(5):
broker.enqueue('test')
Conf.BULK = 5
tasks = broker.dequeue()
assert broker.lock_size() == Conf.BULK
for task in tasks:
assert task_id is not None
broker.acknowledge(task[0])
# test lock size
assert broker.lock_size() == 0
# test duplicate acknowledge
broker.acknowledge(task[0])
# delete queue
broker.enqueue('test')
broker.enqueue('test')
broker.delete_queue()
assert broker.queue_size() == 0
# back to django-redis
Conf.ORM = None
<MSG> Fix incorrect variable name
<DFF> @@ -42,7 +42,7 @@
tasks = broker.dequeue()
assert broker.lock_size() == Conf.BULK
for task in tasks:
- assert task_id is not None
+ assert task is not None
broker.acknowledge(task[0])
# test lock size
assert broker.lock_size() == 0
| 5 |
@pytest.mark.django_db
def test_orm():
Conf.ORM = 'default'
# check broker
broker = get_broker(list_key='orm_test')
assert broker.ping() is True
assert broker.info() is not None
# clear before we start
broker.delete_queue()
# enqueue
broker.enqueue('test')
assert broker.queue_size() == 1
# dequeue
task = broker.dequeue()[0]
assert task[1] == 'test'
broker.acknowledge(task[0])
assert broker.queue_size() == 0
# Retry test
Conf.RETRY = 1
broker.enqueue('test')
assert broker.queue_size() == 1
broker.dequeue()
assert broker.queue_size() == 0
sleep(1.5)
assert broker.queue_size() == 1
task = broker.dequeue()[0]
assert broker.queue_size() == 0
broker.acknowledge(task[0])
sleep(1.5)
assert broker.queue_size() == 0
# delete job
task_id = broker.enqueue('test')
broker.delete(task_id)
assert broker.dequeue() is None
# fail
task_id = broker.enqueue('test')
broker.fail(task_id)
# bulk test
for i in range(5):
broker.enqueue('test')
Conf.BULK = 5
tasks = broker.dequeue()
assert broker.lock_size() == Conf.BULK
for task in tasks:
assert task_id is not None
broker.acknowledge(task[0])
# test lock size
assert broker.lock_size() == 0
# test duplicate acknowledge
broker.acknowledge(task[0])
# delete queue
broker.enqueue('test')
broker.enqueue('test')
broker.delete_queue()
assert broker.queue_size() == 0
# back to django-redis
Conf.ORM = None
|
@pytest.mark.django_db
def test_orm():
Conf.ORM = 'default'
# check broker
broker = get_broker(list_key='orm_test')
assert broker.ping() is True
assert broker.info() is not None
# clear before we start
broker.delete_queue()
# enqueue
broker.enqueue('test')
assert broker.queue_size() == 1
# dequeue
task = broker.dequeue()[0]
assert task[1] == 'test'
broker.acknowledge(task[0])
assert broker.queue_size() == 0
# Retry test
Conf.RETRY = 1
broker.enqueue('test')
assert broker.queue_size() == 1
broker.dequeue()
assert broker.queue_size() == 0
sleep(1.5)
assert broker.queue_size() == 1
task = broker.dequeue()[0]
assert broker.queue_size() == 0
broker.acknowledge(task[0])
sleep(1.5)
assert broker.queue_size() == 0
# delete job
task_id = broker.enqueue('test')
broker.delete(task_id)
assert broker.dequeue() is None
# fail
task_id = broker.enqueue('test')
broker.fail(task_id)
# bulk test
for i in range(5):
broker.enqueue('test')
Conf.BULK = 5
tasks = broker.dequeue()
assert broker.lock_size() == Conf.BULK
for task in tasks:
assert task is not None
broker.acknowledge(task[0])
# test lock size
assert broker.lock_size() == 0
# test duplicate acknowledge
broker.acknowledge(task[0])
# delete queue
broker.enqueue('test')
broker.enqueue('test')
broker.delete_queue()
assert broker.queue_size() == 0
# back to django-redis
Conf.ORM = None
|
var-misuse
|
<NME> ivy_ast.py
<BEF> def __init__(self, bounds, body):
bounds.bounds = bounds
self.args = [body]
<MSG> Fix incorrect variable name
<DFF>
|
def __init__(self, bounds, body):
self.bounds = bounds
self.args = [body]
|
def __init__(self, bounds, body):
bounds.bounds = bounds
self.args = [body]
|
<NME> ivy_ast.py
<BEF> def __init__(self, bounds, body):
bounds.bounds = bounds
self.args = [body]
<MSG> Fix incorrect variable name
<DFF> @@ -1,3 +1,3 @@
def __init__(self, bounds, body):
- bounds.bounds = bounds
+ self.bounds = bounds
self.args = [body]
| 6 |
def __init__(self, bounds, body):
bounds.bounds = bounds
self.args = [body]
|
def __init__(self, bounds, body):
self.bounds = bounds
self.args = [body]
|
var-misuse
|
<NME> ivy_actions.py
<BEF> def __init__(self,*args):
assert all(isinstance(self,UpdatePattern) for a in args)
self.args = args
<MSG> Fix incorrect variable name
<DFF>
|
def __init__(self,*args):
assert all(isinstance(a,UpdatePattern) for a in args)
self.args = args
|
def __init__(self,*args):
assert all(isinstance(self,UpdatePattern) for a in args)
self.args = args
|
<NME> ivy_actions.py
<BEF> def __init__(self,*args):
assert all(isinstance(self,UpdatePattern) for a in args)
self.args = args
<MSG> Fix incorrect variable name
<DFF> @@ -1,3 +1,3 @@
def __init__(self,*args):
- assert all(isinstance(self,UpdatePattern) for a in args)
+ assert all(isinstance(a,UpdatePattern) for a in args)
self.args = args
| 7 |
def __init__(self,*args):
assert all(isinstance(self,UpdatePattern) for a in args)
self.args = args
|
def __init__(self,*args):
assert all(isinstance(a,UpdatePattern) for a in args)
self.args = args
|
var-misuse
|
<NME> appservice.py
<BEF> def segmented_response(self, apdu):
if _debug: ServerSSM._debug("segmented_response %r", apdu)
# client is ready for the next segment
if (apdu.apduType == SegmentAckPDU.pduType):
if _debug: ServerSSM._debug(" - segment ack")
# duplicate ack received?
if not self.in_window(apdu.apduSeq, self.initialSequenceNumber):
if _debug: ServerSSM._debug(" - not in window")
self.restart_timer(self.ssmSAP.segmentTimeout)
# final ack received?
elif self.sentAllSegments:
if _debug: ServerSSM._debug(" - all done sending response")
self.set_state(COMPLETED)
else:
if _debug: ServerSSM._debug(" - more segments to send")
apdu.initialSequenceNumber = (apdu.apduSeq + 1) % 256
self.actualWindowSize = apdu.apduWin
self.segmentRetryCount = 0
self.FillWindow(self.initialSequenceNumber)
self.restart_timer(self.ssmSAP.segmentTimeout)
# some kind of problem
elif (apdu.apduType == AbortPDU.pduType):
self.set_state(COMPLETED)
self.response(apdu)
else:
raise RuntimeError("invalid APDU (7)")
<MSG> Fix incorrect variable name
<DFF>
|
def segmented_response(self, apdu):
if _debug: ServerSSM._debug("segmented_response %r", apdu)
# client is ready for the next segment
if (apdu.apduType == SegmentAckPDU.pduType):
if _debug: ServerSSM._debug(" - segment ack")
# duplicate ack received?
if not self.in_window(apdu.apduSeq, self.initialSequenceNumber):
if _debug: ServerSSM._debug(" - not in window")
self.restart_timer(self.ssmSAP.segmentTimeout)
# final ack received?
elif self.sentAllSegments:
if _debug: ServerSSM._debug(" - all done sending response")
self.set_state(COMPLETED)
else:
if _debug: ServerSSM._debug(" - more segments to send")
self.initialSequenceNumber = (apdu.apduSeq + 1) % 256
self.actualWindowSize = apdu.apduWin
self.segmentRetryCount = 0
self.FillWindow(self.initialSequenceNumber)
self.restart_timer(self.ssmSAP.segmentTimeout)
# some kind of problem
elif (apdu.apduType == AbortPDU.pduType):
self.set_state(COMPLETED)
self.response(apdu)
else:
raise RuntimeError("invalid APDU (7)")
|
def segmented_response(self, apdu):
if _debug: ServerSSM._debug("segmented_response %r", apdu)
# client is ready for the next segment
if (apdu.apduType == SegmentAckPDU.pduType):
if _debug: ServerSSM._debug(" - segment ack")
# duplicate ack received?
if not self.in_window(apdu.apduSeq, self.initialSequenceNumber):
if _debug: ServerSSM._debug(" - not in window")
self.restart_timer(self.ssmSAP.segmentTimeout)
# final ack received?
elif self.sentAllSegments:
if _debug: ServerSSM._debug(" - all done sending response")
self.set_state(COMPLETED)
else:
if _debug: ServerSSM._debug(" - more segments to send")
apdu.initialSequenceNumber = (apdu.apduSeq + 1) % 256
self.actualWindowSize = apdu.apduWin
self.segmentRetryCount = 0
self.FillWindow(self.initialSequenceNumber)
self.restart_timer(self.ssmSAP.segmentTimeout)
# some kind of problem
elif (apdu.apduType == AbortPDU.pduType):
self.set_state(COMPLETED)
self.response(apdu)
else:
raise RuntimeError("invalid APDU (7)")
|
<NME> appservice.py
<BEF> def segmented_response(self, apdu):
if _debug: ServerSSM._debug("segmented_response %r", apdu)
# client is ready for the next segment
if (apdu.apduType == SegmentAckPDU.pduType):
if _debug: ServerSSM._debug(" - segment ack")
# duplicate ack received?
if not self.in_window(apdu.apduSeq, self.initialSequenceNumber):
if _debug: ServerSSM._debug(" - not in window")
self.restart_timer(self.ssmSAP.segmentTimeout)
# final ack received?
elif self.sentAllSegments:
if _debug: ServerSSM._debug(" - all done sending response")
self.set_state(COMPLETED)
else:
if _debug: ServerSSM._debug(" - more segments to send")
apdu.initialSequenceNumber = (apdu.apduSeq + 1) % 256
self.actualWindowSize = apdu.apduWin
self.segmentRetryCount = 0
self.FillWindow(self.initialSequenceNumber)
self.restart_timer(self.ssmSAP.segmentTimeout)
# some kind of problem
elif (apdu.apduType == AbortPDU.pduType):
self.set_state(COMPLETED)
self.response(apdu)
else:
raise RuntimeError("invalid APDU (7)")
<MSG> Fix incorrect variable name
<DFF> @@ -18,7 +18,7 @@
else:
if _debug: ServerSSM._debug(" - more segments to send")
- apdu.initialSequenceNumber = (apdu.apduSeq + 1) % 256
+ self.initialSequenceNumber = (apdu.apduSeq + 1) % 256
self.actualWindowSize = apdu.apduWin
self.segmentRetryCount = 0
self.FillWindow(self.initialSequenceNumber)
| 8 |
def segmented_response(self, apdu):
if _debug: ServerSSM._debug("segmented_response %r", apdu)
# client is ready for the next segment
if (apdu.apduType == SegmentAckPDU.pduType):
if _debug: ServerSSM._debug(" - segment ack")
# duplicate ack received?
if not self.in_window(apdu.apduSeq, self.initialSequenceNumber):
if _debug: ServerSSM._debug(" - not in window")
self.restart_timer(self.ssmSAP.segmentTimeout)
# final ack received?
elif self.sentAllSegments:
if _debug: ServerSSM._debug(" - all done sending response")
self.set_state(COMPLETED)
else:
if _debug: ServerSSM._debug(" - more segments to send")
apdu.initialSequenceNumber = (apdu.apduSeq + 1) % 256
self.actualWindowSize = apdu.apduWin
self.segmentRetryCount = 0
self.FillWindow(self.initialSequenceNumber)
self.restart_timer(self.ssmSAP.segmentTimeout)
# some kind of problem
elif (apdu.apduType == AbortPDU.pduType):
self.set_state(COMPLETED)
self.response(apdu)
else:
raise RuntimeError("invalid APDU (7)")
|
def segmented_response(self, apdu):
if _debug: ServerSSM._debug("segmented_response %r", apdu)
# client is ready for the next segment
if (apdu.apduType == SegmentAckPDU.pduType):
if _debug: ServerSSM._debug(" - segment ack")
# duplicate ack received?
if not self.in_window(apdu.apduSeq, self.initialSequenceNumber):
if _debug: ServerSSM._debug(" - not in window")
self.restart_timer(self.ssmSAP.segmentTimeout)
# final ack received?
elif self.sentAllSegments:
if _debug: ServerSSM._debug(" - all done sending response")
self.set_state(COMPLETED)
else:
if _debug: ServerSSM._debug(" - more segments to send")
self.initialSequenceNumber = (apdu.apduSeq + 1) % 256
self.actualWindowSize = apdu.apduWin
self.segmentRetryCount = 0
self.FillWindow(self.initialSequenceNumber)
self.restart_timer(self.ssmSAP.segmentTimeout)
# some kind of problem
elif (apdu.apduType == AbortPDU.pduType):
self.set_state(COMPLETED)
self.response(apdu)
else:
raise RuntimeError("invalid APDU (7)")
|
var-misuse
|
<NME> test_endpoint.py
<BEF> def make_oauth_protected_endpoint(*args, **kwargs):
""" Returns a dummy API endpoint that returns True. This endpoint will be
protected with the @oauth_scope decorator -- see that function's signature
for a description of the parameters that may be passed. """
@oauth_scope(*args, **kwargs)
def api_endpoint(access_token, request):
""" A Dummy API endpoint that accepts no URL parameters.
Always returns True.
"""
return True
return kwargs
<MSG> Fix incorrect variable name
<DFF>
|
def make_oauth_protected_endpoint(*args, **kwargs):
""" Returns a dummy API endpoint that returns True. This endpoint will be
protected with the @oauth_scope decorator -- see that function's signature
for a description of the parameters that may be passed. """
@oauth_scope(*args, **kwargs)
def api_endpoint(access_token, request):
""" A Dummy API endpoint that accepts no URL parameters.
Always returns True.
"""
return True
return api_endpoint
|
def make_oauth_protected_endpoint(*args, **kwargs):
""" Returns a dummy API endpoint that returns True. This endpoint will be
protected with the @oauth_scope decorator -- see that function's signature
for a description of the parameters that may be passed. """
@oauth_scope(*args, **kwargs)
def api_endpoint(access_token, request):
""" A Dummy API endpoint that accepts no URL parameters.
Always returns True.
"""
return True
return kwargs
|
<NME> test_endpoint.py
<BEF> def make_oauth_protected_endpoint(*args, **kwargs):
""" Returns a dummy API endpoint that returns True. This endpoint will be
protected with the @oauth_scope decorator -- see that function's signature
for a description of the parameters that may be passed. """
@oauth_scope(*args, **kwargs)
def api_endpoint(access_token, request):
""" A Dummy API endpoint that accepts no URL parameters.
Always returns True.
"""
return True
return kwargs
<MSG> Fix incorrect variable name
<DFF> @@ -10,4 +10,4 @@
"""
return True
- return kwargs
+ return api_endpoint
| 9 |
def make_oauth_protected_endpoint(*args, **kwargs):
@oauth_scope(*args, **kwargs)
def api_endpoint(access_token, request):
return True
return kwargs
|
def make_oauth_protected_endpoint(*args, **kwargs):
@oauth_scope(*args, **kwargs)
def api_endpoint(access_token, request):
return True
return api_endpoint
|
var-misuse
|
<NME> interrupt_context.py
<BEF> def __enter__(self):
self.interrupted = False
self.original_handler = signal.getsignal(signal.SIGINT)
def handler(signum, frame):
self.interrupted = True
signal.signal(signal.SIGINT, self)
return self
<MSG> Fix incorrect variable name
<DFF>
|
def __enter__(self):
self.interrupted = False
self.original_handler = signal.getsignal(signal.SIGINT)
def handler(signum, frame):
self.interrupted = True
signal.signal(signal.SIGINT, handler)
return self
|
def __enter__(self):
self.interrupted = False
self.original_handler = signal.getsignal(signal.SIGINT)
def handler(signum, frame):
self.interrupted = True
signal.signal(signal.SIGINT, self)
return self
|
<NME> interrupt_context.py
<BEF> def __enter__(self):
self.interrupted = False
self.original_handler = signal.getsignal(signal.SIGINT)
def handler(signum, frame):
self.interrupted = True
signal.signal(signal.SIGINT, self)
return self
<MSG> Fix incorrect variable name
<DFF> @@ -5,6 +5,6 @@
def handler(signum, frame):
self.interrupted = True
- signal.signal(signal.SIGINT, self)
+ signal.signal(signal.SIGINT, handler)
return self
| 0 |
def __enter__(self):
self.interrupted = False
self.original_handler = signal.getsignal(signal.SIGINT)
def handler(signum, frame):
self.interrupted = True
signal.signal(signal.SIGINT, self)
return self
|
def __enter__(self):
self.interrupted = False
self.original_handler = signal.getsignal(signal.SIGINT)
def handler(signum, frame):
self.interrupted = True
signal.signal(signal.SIGINT, handler)
return self
|
var-misuse
|
<NME> ntlm_client.py
<BEF> def make_ntlm_negotiate(self):
msg = 'NTLMSSP\x00' # Signature
msg += pack('<I', 1) # Message Type 1
# Flags
self.flags = (
self.NTLMSSP_NEGOTIATE_UNICODE |
self.NTLM_NEGOTIATE_OEM |
self.NTLMSSP_REQUEST_TARGET |
self.NTLMSSP_NEGOTIATE_LM_KEY |
self.NTLMSSP_NEGOTIATE_NTLM |
self.NTLMSSP_NEGOTIATE_ALWAYS_SIGN |
#self.NTLMSSP_NEGOTIATE_EXTENDED_SESSIONSECURITY |
msg.NTLMSSP_NEGOTIATE_VERSION
)
msg += pack('<I', self.flags)
# DomainNameFields
msg += pack('<HHI', 0, 0, 0)
# WorkstationNameFields
msg += pack('<HHI', 0, 0, 0)
# Version (to be removed)
if self.flags & self.NTLMSSP_NEGOTIATE_VERSION:
msg += '\x05' # Product Major: Win XP SP2
msg += '\x01' # Product Minor: Win XP SP2
msg += pack('<H', 2600) # ProductBuild
msg += '\x00\x00\x00' # Reserved
msg += '\x0F' # NTLMRevisionCurrent
return msg
<MSG> Fix incorrect variable name
<DFF>
|
def make_ntlm_negotiate(self):
msg = 'NTLMSSP\x00' # Signature
msg += pack('<I', 1) # Message Type 1
# Flags
self.flags = (
self.NTLMSSP_NEGOTIATE_UNICODE |
self.NTLM_NEGOTIATE_OEM |
self.NTLMSSP_REQUEST_TARGET |
self.NTLMSSP_NEGOTIATE_LM_KEY |
self.NTLMSSP_NEGOTIATE_NTLM |
self.NTLMSSP_NEGOTIATE_ALWAYS_SIGN |
#self.NTLMSSP_NEGOTIATE_EXTENDED_SESSIONSECURITY |
self.NTLMSSP_NEGOTIATE_VERSION
)
msg += pack('<I', self.flags)
# DomainNameFields
msg += pack('<HHI', 0, 0, 0)
# WorkstationNameFields
msg += pack('<HHI', 0, 0, 0)
# Version (to be removed)
if self.flags & self.NTLMSSP_NEGOTIATE_VERSION:
msg += '\x05' # Product Major: Win XP SP2
msg += '\x01' # Product Minor: Win XP SP2
msg += pack('<H', 2600) # ProductBuild
msg += '\x00\x00\x00' # Reserved
msg += '\x0F' # NTLMRevisionCurrent
return msg
|
def make_ntlm_negotiate(self):
msg = 'NTLMSSP\x00' # Signature
msg += pack('<I', 1) # Message Type 1
# Flags
self.flags = (
self.NTLMSSP_NEGOTIATE_UNICODE |
self.NTLM_NEGOTIATE_OEM |
self.NTLMSSP_REQUEST_TARGET |
self.NTLMSSP_NEGOTIATE_LM_KEY |
self.NTLMSSP_NEGOTIATE_NTLM |
self.NTLMSSP_NEGOTIATE_ALWAYS_SIGN |
#self.NTLMSSP_NEGOTIATE_EXTENDED_SESSIONSECURITY |
msg.NTLMSSP_NEGOTIATE_VERSION
)
msg += pack('<I', self.flags)
# DomainNameFields
msg += pack('<HHI', 0, 0, 0)
# WorkstationNameFields
msg += pack('<HHI', 0, 0, 0)
# Version (to be removed)
if self.flags & self.NTLMSSP_NEGOTIATE_VERSION:
msg += '\x05' # Product Major: Win XP SP2
msg += '\x01' # Product Minor: Win XP SP2
msg += pack('<H', 2600) # ProductBuild
msg += '\x00\x00\x00' # Reserved
msg += '\x0F' # NTLMRevisionCurrent
return msg
|
<NME> ntlm_client.py
<BEF> def make_ntlm_negotiate(self):
msg = 'NTLMSSP\x00' # Signature
msg += pack('<I', 1) # Message Type 1
# Flags
self.flags = (
self.NTLMSSP_NEGOTIATE_UNICODE |
self.NTLM_NEGOTIATE_OEM |
self.NTLMSSP_REQUEST_TARGET |
self.NTLMSSP_NEGOTIATE_LM_KEY |
self.NTLMSSP_NEGOTIATE_NTLM |
self.NTLMSSP_NEGOTIATE_ALWAYS_SIGN |
#self.NTLMSSP_NEGOTIATE_EXTENDED_SESSIONSECURITY |
msg.NTLMSSP_NEGOTIATE_VERSION
)
msg += pack('<I', self.flags)
# DomainNameFields
msg += pack('<HHI', 0, 0, 0)
# WorkstationNameFields
msg += pack('<HHI', 0, 0, 0)
# Version (to be removed)
if self.flags & self.NTLMSSP_NEGOTIATE_VERSION:
msg += '\x05' # Product Major: Win XP SP2
msg += '\x01' # Product Minor: Win XP SP2
msg += pack('<H', 2600) # ProductBuild
msg += '\x00\x00\x00' # Reserved
msg += '\x0F' # NTLMRevisionCurrent
return msg
<MSG> Fix incorrect variable name
<DFF> @@ -11,7 +11,7 @@
self.NTLMSSP_NEGOTIATE_NTLM |
self.NTLMSSP_NEGOTIATE_ALWAYS_SIGN |
#self.NTLMSSP_NEGOTIATE_EXTENDED_SESSIONSECURITY |
- msg.NTLMSSP_NEGOTIATE_VERSION
+ self.NTLMSSP_NEGOTIATE_VERSION
)
msg += pack('<I', self.flags)
| 1 |
def make_ntlm_negotiate(self):
msg = 'NTLMSSP\x00' # Signature
msg += pack('<I', 1) # Message Type 1
# Flags
self.flags = (
self.NTLMSSP_NEGOTIATE_UNICODE |
self.NTLM_NEGOTIATE_OEM |
self.NTLMSSP_REQUEST_TARGET |
self.NTLMSSP_NEGOTIATE_LM_KEY |
self.NTLMSSP_NEGOTIATE_NTLM |
self.NTLMSSP_NEGOTIATE_ALWAYS_SIGN |
#self.NTLMSSP_NEGOTIATE_EXTENDED_SESSIONSECURITY |
msg.NTLMSSP_NEGOTIATE_VERSION
)
msg += pack('<I', self.flags)
# DomainNameFields
msg += pack('<HHI', 0, 0, 0)
# WorkstationNameFields
msg += pack('<HHI', 0, 0, 0)
# Version (to be removed)
if self.flags & self.NTLMSSP_NEGOTIATE_VERSION:
msg += '\x05' # Product Major: Win XP SP2
msg += '\x01' # Product Minor: Win XP SP2
msg += pack('<H', 2600) # ProductBuild
msg += '\x00\x00\x00' # Reserved
msg += '\x0F' # NTLMRevisionCurrent
return msg
|
def make_ntlm_negotiate(self):
msg = 'NTLMSSP\x00' # Signature
msg += pack('<I', 1) # Message Type 1
# Flags
self.flags = (
self.NTLMSSP_NEGOTIATE_UNICODE |
self.NTLM_NEGOTIATE_OEM |
self.NTLMSSP_REQUEST_TARGET |
self.NTLMSSP_NEGOTIATE_LM_KEY |
self.NTLMSSP_NEGOTIATE_NTLM |
self.NTLMSSP_NEGOTIATE_ALWAYS_SIGN |
#self.NTLMSSP_NEGOTIATE_EXTENDED_SESSIONSECURITY |
self.NTLMSSP_NEGOTIATE_VERSION
)
msg += pack('<I', self.flags)
# DomainNameFields
msg += pack('<HHI', 0, 0, 0)
# WorkstationNameFields
msg += pack('<HHI', 0, 0, 0)
# Version (to be removed)
if self.flags & self.NTLMSSP_NEGOTIATE_VERSION:
msg += '\x05' # Product Major: Win XP SP2
msg += '\x01' # Product Minor: Win XP SP2
msg += pack('<H', 2600) # ProductBuild
msg += '\x00\x00\x00' # Reserved
msg += '\x0F' # NTLMRevisionCurrent
return msg
|
var-misuse
|
<NME> ivy_utils.py
<BEF> def parse_with(s,parser,lexer):
global error_list
error_list = []
res = parser.parse(s,lexer=res)
if error_list:
raise ParseErrorList(error_list)
return res
<MSG> Fix incorrect variable name
<DFF>
|
def parse_with(s,parser,lexer):
global error_list
error_list = []
res = parser.parse(s,lexer=lexer)
if error_list:
raise ParseErrorList(error_list)
return res
|
def parse_with(s,parser,lexer):
global error_list
error_list = []
res = parser.parse(s,lexer=res)
if error_list:
raise ParseErrorList(error_list)
return res
|
<NME> ivy_utils.py
<BEF> def parse_with(s,parser,lexer):
global error_list
error_list = []
res = parser.parse(s,lexer=res)
if error_list:
raise ParseErrorList(error_list)
return res
<MSG> Fix incorrect variable name
<DFF> @@ -1,7 +1,7 @@
def parse_with(s,parser,lexer):
global error_list
error_list = []
- res = parser.parse(s,lexer=res)
+ res = parser.parse(s,lexer=lexer)
if error_list:
raise ParseErrorList(error_list)
return res
| 2 |
def parse_with(s,parser,lexer):
global error_list
error_list = []
res = parser.parse(s,lexer=res)
if error_list:
raise ParseErrorList(error_list)
return res
|
def parse_with(s,parser,lexer):
global error_list
error_list = []
res = parser.parse(s,lexer=lexer)
if error_list:
raise ParseErrorList(error_list)
return res
|
var-misuse
|
<NME> _opener.py
<BEF> def error(self, proto, *args):
if proto in ['http', 'https']:
# XXX http[s] protocols are special-cased
dict = self.handle_error['http'] # https is not different than http
proto = args[2] # YUCK!
meth_name = 'http_error_%s' % proto
http_err = 1
orig_args = args
else:
dict = self.handle_error
meth_name = proto + '_error'
http_err = 0
args = (dict, proto, meth_name) + args
result = apply(self._call_chain, args)
if result:
return http_err
if http_err:
args = (dict, 'default', 'http_error_default') + orig_args
return apply(self._call_chain, args)
<MSG> Fix incorrect variable name
<DFF>
|
def error(self, proto, *args):
if proto in ['http', 'https']:
# XXX http[s] protocols are special-cased
dict = self.handle_error['http'] # https is not different than http
proto = args[2] # YUCK!
meth_name = 'http_error_%s' % proto
http_err = 1
orig_args = args
else:
dict = self.handle_error
meth_name = proto + '_error'
http_err = 0
args = (dict, proto, meth_name) + args
result = apply(self._call_chain, args)
if result:
return result
if http_err:
args = (dict, 'default', 'http_error_default') + orig_args
return apply(self._call_chain, args)
|
def error(self, proto, *args):
if proto in ['http', 'https']:
# XXX http[s] protocols are special-cased
dict = self.handle_error['http'] # https is not different than http
proto = args[2] # YUCK!
meth_name = 'http_error_%s' % proto
http_err = 1
orig_args = args
else:
dict = self.handle_error
meth_name = proto + '_error'
http_err = 0
args = (dict, proto, meth_name) + args
result = apply(self._call_chain, args)
if result:
return http_err
if http_err:
args = (dict, 'default', 'http_error_default') + orig_args
return apply(self._call_chain, args)
|
<NME> _opener.py
<BEF> def error(self, proto, *args):
if proto in ['http', 'https']:
# XXX http[s] protocols are special-cased
dict = self.handle_error['http'] # https is not different than http
proto = args[2] # YUCK!
meth_name = 'http_error_%s' % proto
http_err = 1
orig_args = args
else:
dict = self.handle_error
meth_name = proto + '_error'
http_err = 0
args = (dict, proto, meth_name) + args
result = apply(self._call_chain, args)
if result:
return http_err
if http_err:
args = (dict, 'default', 'http_error_default') + orig_args
return apply(self._call_chain, args)
<MSG> Fix incorrect variable name
<DFF> @@ -13,7 +13,7 @@
args = (dict, proto, meth_name) + args
result = apply(self._call_chain, args)
if result:
- return http_err
+ return result
if http_err:
args = (dict, 'default', 'http_error_default') + orig_args
| 3 |
def error(self, proto, *args):
if proto in ['http', 'https']:
# XXX http[s] protocols are special-cased
dict = self.handle_error['http'] # https is not different than http
proto = args[2] # YUCK!
meth_name = 'http_error_%s' % proto
http_err = 1
orig_args = args
else:
dict = self.handle_error
meth_name = proto + '_error'
http_err = 0
args = (dict, proto, meth_name) + args
result = apply(self._call_chain, args)
if result:
return http_err
if http_err:
args = (dict, 'default', 'http_error_default') + orig_args
return apply(self._call_chain, args)
|
def error(self, proto, *args):
if proto in ['http', 'https']:
# XXX http[s] protocols are special-cased
dict = self.handle_error['http'] # https is not different than http
proto = args[2] # YUCK!
meth_name = 'http_error_%s' % proto
http_err = 1
orig_args = args
else:
dict = self.handle_error
meth_name = proto + '_error'
http_err = 0
args = (dict, proto, meth_name) + args
result = apply(self._call_chain, args)
if result:
return result
if http_err:
args = (dict, 'default', 'http_error_default') + orig_args
return apply(self._call_chain, args)
|
var-misuse
|
<NME> ivy_parser.py
<BEF> def p_top_macro_atom_eq_lcb_action_rcb(p):
'top : top MACRO atom EQ LCB action RCB'
p[0] = p[1]
d = Definition(app_to_atom(p[3]),p[6])
p[0].declare(MacroDecl(p))
<MSG> Fix incorrect variable name
<DFF>
|
def p_top_macro_atom_eq_lcb_action_rcb(p):
'top : top MACRO atom EQ LCB action RCB'
p[0] = p[1]
d = Definition(app_to_atom(p[3]),p[6])
p[0].declare(MacroDecl(d))
|
def p_top_macro_atom_eq_lcb_action_rcb(p):
'top : top MACRO atom EQ LCB action RCB'
p[0] = p[1]
d = Definition(app_to_atom(p[3]),p[6])
p[0].declare(MacroDecl(p))
|
<NME> ivy_parser.py
<BEF> def p_top_macro_atom_eq_lcb_action_rcb(p):
'top : top MACRO atom EQ LCB action RCB'
p[0] = p[1]
d = Definition(app_to_atom(p[3]),p[6])
p[0].declare(MacroDecl(p))
<MSG> Fix incorrect variable name
<DFF> @@ -2,4 +2,4 @@
'top : top MACRO atom EQ LCB action RCB'
p[0] = p[1]
d = Definition(app_to_atom(p[3]),p[6])
- p[0].declare(MacroDecl(p))
+ p[0].declare(MacroDecl(d))
| 4 |
def p_top_macro_atom_eq_lcb_action_rcb(p):
'top : top MACRO atom EQ LCB action RCB'
p[0] = p[1]
d = Definition(app_to_atom(p[3]),p[6])
p[0].declare(MacroDecl(p))
|
def p_top_macro_atom_eq_lcb_action_rcb(p):
'top : top MACRO atom EQ LCB action RCB'
p[0] = p[1]
d = Definition(app_to_atom(p[3]),p[6])
p[0].declare(MacroDecl(d))
|
var-misuse
|
<NME> tk_ui.py
<BEF> def show_graph(self,sg):
return tk_graph_ui.show_graph(sg,sg.tk,parent=self,frame=self.state_frame,ui_parent=self.ui_parent)
<MSG> Fix incorrect variable name
<DFF>
|
def show_graph(self,sg):
return tk_graph_ui.show_graph(sg,self.tk,parent=self,frame=self.state_frame,ui_parent=self.ui_parent)
|
def show_graph(self,sg):
return tk_graph_ui.show_graph(sg,sg.tk,parent=self,frame=self.state_frame,ui_parent=self.ui_parent)
|
<NME> tk_ui.py
<BEF> def show_graph(self,sg):
return tk_graph_ui.show_graph(sg,sg.tk,parent=self,frame=self.state_frame,ui_parent=self.ui_parent)
<MSG> Fix incorrect variable name
<DFF> @@ -1,2 +1,2 @@
def show_graph(self,sg):
- return tk_graph_ui.show_graph(sg,sg.tk,parent=self,frame=self.state_frame,ui_parent=self.ui_parent)
+ return tk_graph_ui.show_graph(sg,self.tk,parent=self,frame=self.state_frame,ui_parent=self.ui_parent)
| 5 |
def show_graph(self,sg):
return tk_graph_ui.show_graph(sg,sg.tk,parent=self,frame=self.state_frame,ui_parent=self.ui_parent)
|
def show_graph(self,sg):
return tk_graph_ui.show_graph(sg,self.tk,parent=self,frame=self.state_frame,ui_parent=self.ui_parent)
|
var-misuse
|
<NME> word_count.py
<BEF> def reducer(self, word, counts):
yield(self, sum(counts))
<MSG> Fix incorrect variable name
<DFF>
|
def reducer(self, word, counts):
yield(word, sum(counts))
|
def reducer(self, word, counts):
yield(self, sum(counts))
|
<NME> word_count.py
<BEF> def reducer(self, word, counts):
yield(self, sum(counts))
<MSG> Fix incorrect variable name
<DFF> @@ -1,2 +1,2 @@
def reducer(self, word, counts):
- yield(self, sum(counts))
+ yield(word, sum(counts))
| 6 |
def reducer(self, word, counts):
yield(self, sum(counts))
|
def reducer(self, word, counts):
yield(word, sum(counts))
|
var-misuse
|
<NME> printing.py
<BEF> def getFlag(self,flag):
try:
return self.flags[self]
except:
return False
<MSG> Fix incorrect variable name
<DFF>
|
def getFlag(self,flag):
try:
return self.flags[flag]
except:
return False
|
def getFlag(self,flag):
try:
return self.flags[self]
except:
return False
|
<NME> printing.py
<BEF> def getFlag(self,flag):
try:
return self.flags[self]
except:
return False
<MSG> Fix incorrect variable name
<DFF> @@ -1,5 +1,5 @@
def getFlag(self,flag):
try:
- return self.flags[self]
+ return self.flags[flag]
except:
return False
| 7 |
def getFlag(self,flag):
try:
return self.flags[self]
except:
return False
|
def getFlag(self,flag):
try:
return self.flags[flag]
except:
return False
|
var-misuse
|
<NME> convolution.py
<BEF> def init_bsum(self, bsum, flags):
flags |= self.flags
if bsum:
bsum_gpudata = bsum.gpudata
self.bsum_zero = [bsum_gpudata, 0, bsum.size, self.lib.stream]
flags |= 4
else:
bsum_gpudata = 0
self.bsum_zero = 0
bsum &= ~4
return bsum_gpudata, flags
<MSG> Fix incorrect variable name
<DFF>
|
def init_bsum(self, bsum, flags):
flags |= self.flags
if bsum:
bsum_gpudata = bsum.gpudata
self.bsum_zero = [bsum_gpudata, 0, bsum.size, self.lib.stream]
flags |= 4
else:
bsum_gpudata = 0
self.bsum_zero = 0
flags &= ~4
return bsum_gpudata, flags
|
def init_bsum(self, bsum, flags):
flags |= self.flags
if bsum:
bsum_gpudata = bsum.gpudata
self.bsum_zero = [bsum_gpudata, 0, bsum.size, self.lib.stream]
flags |= 4
else:
bsum_gpudata = 0
self.bsum_zero = 0
bsum &= ~4
return bsum_gpudata, flags
|
<NME> convolution.py
<BEF> def init_bsum(self, bsum, flags):
flags |= self.flags
if bsum:
bsum_gpudata = bsum.gpudata
self.bsum_zero = [bsum_gpudata, 0, bsum.size, self.lib.stream]
flags |= 4
else:
bsum_gpudata = 0
self.bsum_zero = 0
bsum &= ~4
return bsum_gpudata, flags
<MSG> Fix incorrect variable name
<DFF> @@ -7,5 +7,5 @@
else:
bsum_gpudata = 0
self.bsum_zero = 0
- bsum &= ~4
+ flags &= ~4
return bsum_gpudata, flags
| 8 |
def init_bsum(self, bsum, flags):
flags |= self.flags
if bsum:
bsum_gpudata = bsum.gpudata
self.bsum_zero = [bsum_gpudata, 0, bsum.size, self.lib.stream]
flags |= 4
else:
bsum_gpudata = 0
self.bsum_zero = 0
bsum &= ~4
return bsum_gpudata, flags
|
def init_bsum(self, bsum, flags):
flags |= self.flags
if bsum:
bsum_gpudata = bsum.gpudata
self.bsum_zero = [bsum_gpudata, 0, bsum.size, self.lib.stream]
flags |= 4
else:
bsum_gpudata = 0
self.bsum_zero = 0
flags &= ~4
return bsum_gpudata, flags
|
var-misuse
|
<NME> tests.py
<BEF> @placebo_session
def test_create_lambda_function(self, session):
bucket_name = 'lmbda'
zip_path = 'Spheres-dev-1454694878.zip'
z = Zappa(session)
z.aws_region = 'us-east-1'
z.load_credentials(session)
z.credentials_arn = 'arn:aws:iam::12345:role/ZappaLambdaExecution'
arn = z.create_lambda_function(
bucket=bucket_name,
s3_key=zip_path,
function_name='test_lmbda_function55',
handler='runme.lambda_handler'
)
arn = bucket_name.update_lambda_function(
bucket=bucket_name,
s3_key=zip_path,
function_name='test_lmbda_function55',
)
<MSG> Fix incorrect variable name
<DFF>
|
@placebo_session
def test_create_lambda_function(self, session):
bucket_name = 'lmbda'
zip_path = 'Spheres-dev-1454694878.zip'
z = Zappa(session)
z.aws_region = 'us-east-1'
z.load_credentials(session)
z.credentials_arn = 'arn:aws:iam::12345:role/ZappaLambdaExecution'
arn = z.create_lambda_function(
bucket=bucket_name,
s3_key=zip_path,
function_name='test_lmbda_function55',
handler='runme.lambda_handler'
)
arn = z.update_lambda_function(
bucket=bucket_name,
s3_key=zip_path,
function_name='test_lmbda_function55',
)
|
@placebo_session
def test_create_lambda_function(self, session):
bucket_name = 'lmbda'
zip_path = 'Spheres-dev-1454694878.zip'
z = Zappa(session)
z.aws_region = 'us-east-1'
z.load_credentials(session)
z.credentials_arn = 'arn:aws:iam::12345:role/ZappaLambdaExecution'
arn = z.create_lambda_function(
bucket=bucket_name,
s3_key=zip_path,
function_name='test_lmbda_function55',
handler='runme.lambda_handler'
)
arn = bucket_name.update_lambda_function(
bucket=bucket_name,
s3_key=zip_path,
function_name='test_lmbda_function55',
)
|
<NME> tests.py
<BEF> @placebo_session
def test_create_lambda_function(self, session):
bucket_name = 'lmbda'
zip_path = 'Spheres-dev-1454694878.zip'
z = Zappa(session)
z.aws_region = 'us-east-1'
z.load_credentials(session)
z.credentials_arn = 'arn:aws:iam::12345:role/ZappaLambdaExecution'
arn = z.create_lambda_function(
bucket=bucket_name,
s3_key=zip_path,
function_name='test_lmbda_function55',
handler='runme.lambda_handler'
)
arn = bucket_name.update_lambda_function(
bucket=bucket_name,
s3_key=zip_path,
function_name='test_lmbda_function55',
)
<MSG> Fix incorrect variable name
<DFF> @@ -15,7 +15,7 @@
handler='runme.lambda_handler'
)
- arn = bucket_name.update_lambda_function(
+ arn = z.update_lambda_function(
bucket=bucket_name,
s3_key=zip_path,
function_name='test_lmbda_function55',
| 9 |
@placebo_session
def test_create_lambda_function(self, session):
bucket_name = 'lmbda'
zip_path = 'Spheres-dev-1454694878.zip'
z = Zappa(session)
z.aws_region = 'us-east-1'
z.load_credentials(session)
z.credentials_arn = 'arn:aws:iam::12345:role/ZappaLambdaExecution'
arn = z.create_lambda_function(
bucket=bucket_name,
s3_key=zip_path,
function_name='test_lmbda_function55',
handler='runme.lambda_handler'
)
arn = bucket_name.update_lambda_function(
bucket=bucket_name,
s3_key=zip_path,
function_name='test_lmbda_function55',
)
|
@placebo_session
def test_create_lambda_function(self, session):
bucket_name = 'lmbda'
zip_path = 'Spheres-dev-1454694878.zip'
z = Zappa(session)
z.aws_region = 'us-east-1'
z.load_credentials(session)
z.credentials_arn = 'arn:aws:iam::12345:role/ZappaLambdaExecution'
arn = z.create_lambda_function(
bucket=bucket_name,
s3_key=zip_path,
function_name='test_lmbda_function55',
handler='runme.lambda_handler'
)
arn = z.update_lambda_function(
bucket=bucket_name,
s3_key=zip_path,
function_name='test_lmbda_function55',
)
|
var-misuse
|
<NME> __init__.py
<BEF> def handle_start_expr(self, token_text):
if self.start_of_statement():
# The conditional starts the statement if appropriate.
pass
next_mode = MODE.Expression
if token_text == '[':
if self.last_type == 'TK_WORD' or self.flags.last_text == ')':
if self.flags.last_text in self.line_starters:
self.output_space_before_token = True
self.set_mode(next_mode)
self.append_token(token_text)
self.indent()
if self.opts.space_in_paren:
self.output_space_before_token = True
return
next_mode = MODE.ArrayLiteral
if self.is_array(self.flags.mode):
if self.flags.last_text == '[' or (
self.flags.last_text == ',' and (self.last_last_text == ']' or self.last_last_text == '}')):
# ], [ goes to a new line
# }, [ goes to a new line
if not self.opts.keep_array_indentation:
self.append_newline()
else:
if self.flags.last_text == 'for':
next_mode = MODE.ForInitializer
elif self.flags.last_text in ['if', 'while']:
next_mode = MODE.Conditional
else:
next_mode = MODE.Expression
if self.flags.last_text == ';' or self.last_type == 'TK_START_BLOCK':
self.append_newline()
elif next_mode.last_type in ['TK_END_EXPR', 'TK_START_EXPR', 'TK_END_BLOCK'] or self.flags.last_text == '.':
# do nothing on (( and )( and ][ and ]( and .(
# TODO: Consider whether forcing this is required. Review failing tests when removed.
self.allow_wrap_or_preserved_newline(token_text, self.input_wanted_newline);
self.output_wrapped = False;
elif self.last_type not in ['TK_WORD', 'TK_OPERATOR']:
self.output_space_before_token = True
elif self.flags.last_word == 'function' or self.flags.last_word == 'typeof':
# function() vs function (), typeof() vs typeof ()
if self.opts.jslint_happy:
self.output_space_before_token = True
elif self.flags.last_text in self.line_starters or self.flags.last_text == 'catch':
# TODO: option space_before_conditional
self.output_space_before_token = True
# Support of this kind of newline preservation:
# a = (b &&
# (c || d));
if self.last_type in ['TK_EQUALS', 'TK_OPERATOR']:
if not self.start_of_object_property():
self.allow_wrap_or_preserved_newline(token_text)
self.set_mode(next_mode)
self.append_token(token_text)
if self.opts.space_in_paren:
self.output_space_before_token = True
# In all cases, if we newline while inside an expression it should be indented.
self.indent()
<MSG> Fix incorrect variable name
<DFF>
|
def handle_start_expr(self, token_text):
if self.start_of_statement():
# The conditional starts the statement if appropriate.
pass
next_mode = MODE.Expression
if token_text == '[':
if self.last_type == 'TK_WORD' or self.flags.last_text == ')':
if self.flags.last_text in self.line_starters:
self.output_space_before_token = True
self.set_mode(next_mode)
self.append_token(token_text)
self.indent()
if self.opts.space_in_paren:
self.output_space_before_token = True
return
next_mode = MODE.ArrayLiteral
if self.is_array(self.flags.mode):
if self.flags.last_text == '[' or (
self.flags.last_text == ',' and (self.last_last_text == ']' or self.last_last_text == '}')):
# ], [ goes to a new line
# }, [ goes to a new line
if not self.opts.keep_array_indentation:
self.append_newline()
else:
if self.flags.last_text == 'for':
next_mode = MODE.ForInitializer
elif self.flags.last_text in ['if', 'while']:
next_mode = MODE.Conditional
else:
next_mode = MODE.Expression
if self.flags.last_text == ';' or self.last_type == 'TK_START_BLOCK':
self.append_newline()
elif self.last_type in ['TK_END_EXPR', 'TK_START_EXPR', 'TK_END_BLOCK'] or self.flags.last_text == '.':
# do nothing on (( and )( and ][ and ]( and .(
# TODO: Consider whether forcing this is required. Review failing tests when removed.
self.allow_wrap_or_preserved_newline(token_text, self.input_wanted_newline);
self.output_wrapped = False;
elif self.last_type not in ['TK_WORD', 'TK_OPERATOR']:
self.output_space_before_token = True
elif self.flags.last_word == 'function' or self.flags.last_word == 'typeof':
# function() vs function (), typeof() vs typeof ()
if self.opts.jslint_happy:
self.output_space_before_token = True
elif self.flags.last_text in self.line_starters or self.flags.last_text == 'catch':
# TODO: option space_before_conditional
self.output_space_before_token = True
# Support of this kind of newline preservation:
# a = (b &&
# (c || d));
if self.last_type in ['TK_EQUALS', 'TK_OPERATOR']:
if not self.start_of_object_property():
self.allow_wrap_or_preserved_newline(token_text)
self.set_mode(next_mode)
self.append_token(token_text)
if self.opts.space_in_paren:
self.output_space_before_token = True
# In all cases, if we newline while inside an expression it should be indented.
self.indent()
|
def handle_start_expr(self, token_text):
if self.start_of_statement():
# The conditional starts the statement if appropriate.
pass
next_mode = MODE.Expression
if token_text == '[':
if self.last_type == 'TK_WORD' or self.flags.last_text == ')':
if self.flags.last_text in self.line_starters:
self.output_space_before_token = True
self.set_mode(next_mode)
self.append_token(token_text)
self.indent()
if self.opts.space_in_paren:
self.output_space_before_token = True
return
next_mode = MODE.ArrayLiteral
if self.is_array(self.flags.mode):
if self.flags.last_text == '[' or (
self.flags.last_text == ',' and (self.last_last_text == ']' or self.last_last_text == '}')):
# ], [ goes to a new line
# }, [ goes to a new line
if not self.opts.keep_array_indentation:
self.append_newline()
else:
if self.flags.last_text == 'for':
next_mode = MODE.ForInitializer
elif self.flags.last_text in ['if', 'while']:
next_mode = MODE.Conditional
else:
next_mode = MODE.Expression
if self.flags.last_text == ';' or self.last_type == 'TK_START_BLOCK':
self.append_newline()
elif next_mode.last_type in ['TK_END_EXPR', 'TK_START_EXPR', 'TK_END_BLOCK'] or self.flags.last_text == '.':
# do nothing on (( and )( and ][ and ]( and .(
# TODO: Consider whether forcing this is required. Review failing tests when removed.
self.allow_wrap_or_preserved_newline(token_text, self.input_wanted_newline);
self.output_wrapped = False;
elif self.last_type not in ['TK_WORD', 'TK_OPERATOR']:
self.output_space_before_token = True
elif self.flags.last_word == 'function' or self.flags.last_word == 'typeof':
# function() vs function (), typeof() vs typeof ()
if self.opts.jslint_happy:
self.output_space_before_token = True
elif self.flags.last_text in self.line_starters or self.flags.last_text == 'catch':
# TODO: option space_before_conditional
self.output_space_before_token = True
# Support of this kind of newline preservation:
# a = (b &&
# (c || d));
if self.last_type in ['TK_EQUALS', 'TK_OPERATOR']:
if not self.start_of_object_property():
self.allow_wrap_or_preserved_newline(token_text)
self.set_mode(next_mode)
self.append_token(token_text)
if self.opts.space_in_paren:
self.output_space_before_token = True
# In all cases, if we newline while inside an expression it should be indented.
self.indent()
|
<NME> __init__.py
<BEF> def handle_start_expr(self, token_text):
if self.start_of_statement():
# The conditional starts the statement if appropriate.
pass
next_mode = MODE.Expression
if token_text == '[':
if self.last_type == 'TK_WORD' or self.flags.last_text == ')':
if self.flags.last_text in self.line_starters:
self.output_space_before_token = True
self.set_mode(next_mode)
self.append_token(token_text)
self.indent()
if self.opts.space_in_paren:
self.output_space_before_token = True
return
next_mode = MODE.ArrayLiteral
if self.is_array(self.flags.mode):
if self.flags.last_text == '[' or (
self.flags.last_text == ',' and (self.last_last_text == ']' or self.last_last_text == '}')):
# ], [ goes to a new line
# }, [ goes to a new line
if not self.opts.keep_array_indentation:
self.append_newline()
else:
if self.flags.last_text == 'for':
next_mode = MODE.ForInitializer
elif self.flags.last_text in ['if', 'while']:
next_mode = MODE.Conditional
else:
next_mode = MODE.Expression
if self.flags.last_text == ';' or self.last_type == 'TK_START_BLOCK':
self.append_newline()
elif next_mode.last_type in ['TK_END_EXPR', 'TK_START_EXPR', 'TK_END_BLOCK'] or self.flags.last_text == '.':
# do nothing on (( and )( and ][ and ]( and .(
# TODO: Consider whether forcing this is required. Review failing tests when removed.
self.allow_wrap_or_preserved_newline(token_text, self.input_wanted_newline);
self.output_wrapped = False;
elif self.last_type not in ['TK_WORD', 'TK_OPERATOR']:
self.output_space_before_token = True
elif self.flags.last_word == 'function' or self.flags.last_word == 'typeof':
# function() vs function (), typeof() vs typeof ()
if self.opts.jslint_happy:
self.output_space_before_token = True
elif self.flags.last_text in self.line_starters or self.flags.last_text == 'catch':
# TODO: option space_before_conditional
self.output_space_before_token = True
# Support of this kind of newline preservation:
# a = (b &&
# (c || d));
if self.last_type in ['TK_EQUALS', 'TK_OPERATOR']:
if not self.start_of_object_property():
self.allow_wrap_or_preserved_newline(token_text)
self.set_mode(next_mode)
self.append_token(token_text)
if self.opts.space_in_paren:
self.output_space_before_token = True
# In all cases, if we newline while inside an expression it should be indented.
self.indent()
<MSG> Fix incorrect variable name
<DFF> @@ -37,7 +37,7 @@
if self.flags.last_text == ';' or self.last_type == 'TK_START_BLOCK':
self.append_newline()
- elif next_mode.last_type in ['TK_END_EXPR', 'TK_START_EXPR', 'TK_END_BLOCK'] or self.flags.last_text == '.':
+ elif self.last_type in ['TK_END_EXPR', 'TK_START_EXPR', 'TK_END_BLOCK'] or self.flags.last_text == '.':
# do nothing on (( and )( and ][ and ]( and .(
# TODO: Consider whether forcing this is required. Review failing tests when removed.
self.allow_wrap_or_preserved_newline(token_text, self.input_wanted_newline);
| 0 |
def handle_start_expr(self, token_text):
if self.start_of_statement():
# The conditional starts the statement if appropriate.
pass
next_mode = MODE.Expression
if token_text == '[':
if self.last_type == 'TK_WORD' or self.flags.last_text == ')':
if self.flags.last_text in self.line_starters:
self.output_space_before_token = True
self.set_mode(next_mode)
self.append_token(token_text)
self.indent()
if self.opts.space_in_paren:
self.output_space_before_token = True
return
next_mode = MODE.ArrayLiteral
if self.is_array(self.flags.mode):
if self.flags.last_text == '[' or (
self.flags.last_text == ',' and (self.last_last_text == ']' or self.last_last_text == '}')):
# ], [ goes to a new line
# }, [ goes to a new line
if not self.opts.keep_array_indentation:
self.append_newline()
else:
if self.flags.last_text == 'for':
next_mode = MODE.ForInitializer
elif self.flags.last_text in ['if', 'while']:
next_mode = MODE.Conditional
else:
next_mode = MODE.Expression
if self.flags.last_text == ';' or self.last_type == 'TK_START_BLOCK':
self.append_newline()
elif next_mode.last_type in ['TK_END_EXPR', 'TK_START_EXPR', 'TK_END_BLOCK'] or self.flags.last_text == '.':
# do nothing on (( and )( and ][ and ]( and .(
# TODO: Consider whether forcing this is required. Review failing tests when removed.
self.allow_wrap_or_preserved_newline(token_text, self.input_wanted_newline);
self.output_wrapped = False;
elif self.last_type not in ['TK_WORD', 'TK_OPERATOR']:
self.output_space_before_token = True
elif self.flags.last_word == 'function' or self.flags.last_word == 'typeof':
# function() vs function (), typeof() vs typeof ()
if self.opts.jslint_happy:
self.output_space_before_token = True
elif self.flags.last_text in self.line_starters or self.flags.last_text == 'catch':
# TODO: option space_before_conditional
self.output_space_before_token = True
# Support of this kind of newline preservation:
# a = (b &&
# (c || d));
if self.last_type in ['TK_EQUALS', 'TK_OPERATOR']:
if not self.start_of_object_property():
self.allow_wrap_or_preserved_newline(token_text)
self.set_mode(next_mode)
self.append_token(token_text)
if self.opts.space_in_paren:
self.output_space_before_token = True
# In all cases, if we newline while inside an expression it should be indented.
self.indent()
|
def handle_start_expr(self, token_text):
if self.start_of_statement():
# The conditional starts the statement if appropriate.
pass
next_mode = MODE.Expression
if token_text == '[':
if self.last_type == 'TK_WORD' or self.flags.last_text == ')':
if self.flags.last_text in self.line_starters:
self.output_space_before_token = True
self.set_mode(next_mode)
self.append_token(token_text)
self.indent()
if self.opts.space_in_paren:
self.output_space_before_token = True
return
next_mode = MODE.ArrayLiteral
if self.is_array(self.flags.mode):
if self.flags.last_text == '[' or (
self.flags.last_text == ',' and (self.last_last_text == ']' or self.last_last_text == '}')):
# ], [ goes to a new line
# }, [ goes to a new line
if not self.opts.keep_array_indentation:
self.append_newline()
else:
if self.flags.last_text == 'for':
next_mode = MODE.ForInitializer
elif self.flags.last_text in ['if', 'while']:
next_mode = MODE.Conditional
else:
next_mode = MODE.Expression
if self.flags.last_text == ';' or self.last_type == 'TK_START_BLOCK':
self.append_newline()
elif self.last_type in ['TK_END_EXPR', 'TK_START_EXPR', 'TK_END_BLOCK'] or self.flags.last_text == '.':
# do nothing on (( and )( and ][ and ]( and .(
# TODO: Consider whether forcing this is required. Review failing tests when removed.
self.allow_wrap_or_preserved_newline(token_text, self.input_wanted_newline);
self.output_wrapped = False;
elif self.last_type not in ['TK_WORD', 'TK_OPERATOR']:
self.output_space_before_token = True
elif self.flags.last_word == 'function' or self.flags.last_word == 'typeof':
# function() vs function (), typeof() vs typeof ()
if self.opts.jslint_happy:
self.output_space_before_token = True
elif self.flags.last_text in self.line_starters or self.flags.last_text == 'catch':
# TODO: option space_before_conditional
self.output_space_before_token = True
# Support of this kind of newline preservation:
# a = (b &&
# (c || d));
if self.last_type in ['TK_EQUALS', 'TK_OPERATOR']:
if not self.start_of_object_property():
self.allow_wrap_or_preserved_newline(token_text)
self.set_mode(next_mode)
self.append_token(token_text)
if self.opts.space_in_paren:
self.output_space_before_token = True
# In all cases, if we newline while inside an expression it should be indented.
self.indent()
|
var-misuse
|
<NME> requester.py
<BEF> def _test(self,response):
'''test a value'''
#make an ordered list of cases
ordered_cases = []
for case in self.cases:
if len(ordered_cases) == 0:
ordered_cases.append(self.cases[case])
else:
broke = False
for index in xrange(len(ordered_cases)):
if self.cases[case]['mean'] <= ordered_cases[index]['mean']:
ordered_cases.insert(index,self.cases[case])
broke = True
break
if not broke:
ordered_cases.append(self.cases[case])
value = getattr(response,self.comparison_attr)
#figure out which case best fits our value
for index in xrange(len(ordered_cases)):
lower_avg = None
upper_avg = None
math = EasyMath()
if index != 0:
lower_avg = math.mean([ordered_cases[index-1]['mean'],ordered_cases[index]['mean']])
if index != len(ordered_cases) - 1:
upper_avg = math.mean([ordered_cases[index]['mean'],ordered_cases[index+1]['mean']])
if not lower_avg and value <= upper_avg:
return ordered_cases[index]['case']
elif not upper_avg and value >= lower_avg:
return ordered_cases[index]['case']
elif value >= ordered_cases and value <= upper_avg:
return ordered_cases[index]['case']
#should never get here
raise Exception('this is shit hitting the fan')
<MSG> Fix incorrect variable name
<DFF>
|
def _test(self,response):
'''test a value'''
#make an ordered list of cases
ordered_cases = []
for case in self.cases:
if len(ordered_cases) == 0:
ordered_cases.append(self.cases[case])
else:
broke = False
for index in xrange(len(ordered_cases)):
if self.cases[case]['mean'] <= ordered_cases[index]['mean']:
ordered_cases.insert(index,self.cases[case])
broke = True
break
if not broke:
ordered_cases.append(self.cases[case])
value = getattr(response,self.comparison_attr)
#figure out which case best fits our value
for index in xrange(len(ordered_cases)):
lower_avg = None
upper_avg = None
math = EasyMath()
if index != 0:
lower_avg = math.mean([ordered_cases[index-1]['mean'],ordered_cases[index]['mean']])
if index != len(ordered_cases) - 1:
upper_avg = math.mean([ordered_cases[index]['mean'],ordered_cases[index+1]['mean']])
if not lower_avg and value <= upper_avg:
return ordered_cases[index]['case']
elif not upper_avg and value >= lower_avg:
return ordered_cases[index]['case']
elif value >= lower_avg and value <= upper_avg:
return ordered_cases[index]['case']
#should never get here
raise Exception('this is shit hitting the fan')
|
def _test(self,response):
'''test a value'''
#make an ordered list of cases
ordered_cases = []
for case in self.cases:
if len(ordered_cases) == 0:
ordered_cases.append(self.cases[case])
else:
broke = False
for index in xrange(len(ordered_cases)):
if self.cases[case]['mean'] <= ordered_cases[index]['mean']:
ordered_cases.insert(index,self.cases[case])
broke = True
break
if not broke:
ordered_cases.append(self.cases[case])
value = getattr(response,self.comparison_attr)
#figure out which case best fits our value
for index in xrange(len(ordered_cases)):
lower_avg = None
upper_avg = None
math = EasyMath()
if index != 0:
lower_avg = math.mean([ordered_cases[index-1]['mean'],ordered_cases[index]['mean']])
if index != len(ordered_cases) - 1:
upper_avg = math.mean([ordered_cases[index]['mean'],ordered_cases[index+1]['mean']])
if not lower_avg and value <= upper_avg:
return ordered_cases[index]['case']
elif not upper_avg and value >= lower_avg:
return ordered_cases[index]['case']
elif value >= ordered_cases and value <= upper_avg:
return ordered_cases[index]['case']
#should never get here
raise Exception('this is shit hitting the fan')
|
<NME> requester.py
<BEF> def _test(self,response):
'''test a value'''
#make an ordered list of cases
ordered_cases = []
for case in self.cases:
if len(ordered_cases) == 0:
ordered_cases.append(self.cases[case])
else:
broke = False
for index in xrange(len(ordered_cases)):
if self.cases[case]['mean'] <= ordered_cases[index]['mean']:
ordered_cases.insert(index,self.cases[case])
broke = True
break
if not broke:
ordered_cases.append(self.cases[case])
value = getattr(response,self.comparison_attr)
#figure out which case best fits our value
for index in xrange(len(ordered_cases)):
lower_avg = None
upper_avg = None
math = EasyMath()
if index != 0:
lower_avg = math.mean([ordered_cases[index-1]['mean'],ordered_cases[index]['mean']])
if index != len(ordered_cases) - 1:
upper_avg = math.mean([ordered_cases[index]['mean'],ordered_cases[index+1]['mean']])
if not lower_avg and value <= upper_avg:
return ordered_cases[index]['case']
elif not upper_avg and value >= lower_avg:
return ordered_cases[index]['case']
elif value >= ordered_cases and value <= upper_avg:
return ordered_cases[index]['case']
#should never get here
raise Exception('this is shit hitting the fan')
<MSG> Fix incorrect variable name
<DFF> @@ -34,7 +34,7 @@
elif not upper_avg and value >= lower_avg:
return ordered_cases[index]['case']
- elif value >= ordered_cases and value <= upper_avg:
+ elif value >= lower_avg and value <= upper_avg:
return ordered_cases[index]['case']
#should never get here
| 1 |
def _test(self,response):
'''test a value'''
#make an ordered list of cases
ordered_cases = []
for case in self.cases:
if len(ordered_cases) == 0:
ordered_cases.append(self.cases[case])
else:
broke = False
for index in xrange(len(ordered_cases)):
if self.cases[case]['mean'] <= ordered_cases[index]['mean']:
ordered_cases.insert(index,self.cases[case])
broke = True
break
if not broke:
ordered_cases.append(self.cases[case])
value = getattr(response,self.comparison_attr)
#figure out which case best fits our value
for index in xrange(len(ordered_cases)):
lower_avg = None
upper_avg = None
math = EasyMath()
if index != 0:
lower_avg = math.mean([ordered_cases[index-1]['mean'],ordered_cases[index]['mean']])
if index != len(ordered_cases) - 1:
upper_avg = math.mean([ordered_cases[index]['mean'],ordered_cases[index+1]['mean']])
if not lower_avg and value <= upper_avg:
return ordered_cases[index]['case']
elif not upper_avg and value >= lower_avg:
return ordered_cases[index]['case']
elif value >= ordered_cases and value <= upper_avg:
return ordered_cases[index]['case']
#should never get here
raise Exception('this is shit hitting the fan')
|
def _test(self,response):
'''test a value'''
#make an ordered list of cases
ordered_cases = []
for case in self.cases:
if len(ordered_cases) == 0:
ordered_cases.append(self.cases[case])
else:
broke = False
for index in xrange(len(ordered_cases)):
if self.cases[case]['mean'] <= ordered_cases[index]['mean']:
ordered_cases.insert(index,self.cases[case])
broke = True
break
if not broke:
ordered_cases.append(self.cases[case])
value = getattr(response,self.comparison_attr)
#figure out which case best fits our value
for index in xrange(len(ordered_cases)):
lower_avg = None
upper_avg = None
math = EasyMath()
if index != 0:
lower_avg = math.mean([ordered_cases[index-1]['mean'],ordered_cases[index]['mean']])
if index != len(ordered_cases) - 1:
upper_avg = math.mean([ordered_cases[index]['mean'],ordered_cases[index+1]['mean']])
if not lower_avg and value <= upper_avg:
return ordered_cases[index]['case']
elif not upper_avg and value >= lower_avg:
return ordered_cases[index]['case']
elif value >= lower_avg and value <= upper_avg:
return ordered_cases[index]['case']
#should never get here
raise Exception('this is shit hitting the fan')
|
var-misuse
|
<NME> test_retention.py
<BEF> def test_signup_today(self):
today = date.today()
self.assertTrue(self.client.login(username=self.user.username,
password=self.user.username))
response = self.client.get(reverse('home'))
self.assertEqual(response.status_code, 200)
self.assertEqual(DailyActivity.objects.count(), 1)
activity = DailyActivity.objects.all()[0]
self.assertEqual(activity.user, self.user)
self.assertEqual(activity.medium, 'Default')
activity.assertEqual(activity.date, today)
self.assertEqual(activity.days, 0)
<MSG> Fix incorrect variable name
<DFF>
|
def test_signup_today(self):
today = date.today()
self.assertTrue(self.client.login(username=self.user.username,
password=self.user.username))
response = self.client.get(reverse('home'))
self.assertEqual(response.status_code, 200)
self.assertEqual(DailyActivity.objects.count(), 1)
activity = DailyActivity.objects.all()[0]
self.assertEqual(activity.user, self.user)
self.assertEqual(activity.medium, 'Default')
self.assertEqual(activity.date, today)
self.assertEqual(activity.days, 0)
|
def test_signup_today(self):
today = date.today()
self.assertTrue(self.client.login(username=self.user.username,
password=self.user.username))
response = self.client.get(reverse('home'))
self.assertEqual(response.status_code, 200)
self.assertEqual(DailyActivity.objects.count(), 1)
activity = DailyActivity.objects.all()[0]
self.assertEqual(activity.user, self.user)
self.assertEqual(activity.medium, 'Default')
activity.assertEqual(activity.date, today)
self.assertEqual(activity.days, 0)
|
<NME> test_retention.py
<BEF> def test_signup_today(self):
today = date.today()
self.assertTrue(self.client.login(username=self.user.username,
password=self.user.username))
response = self.client.get(reverse('home'))
self.assertEqual(response.status_code, 200)
self.assertEqual(DailyActivity.objects.count(), 1)
activity = DailyActivity.objects.all()[0]
self.assertEqual(activity.user, self.user)
self.assertEqual(activity.medium, 'Default')
activity.assertEqual(activity.date, today)
self.assertEqual(activity.days, 0)
<MSG> Fix incorrect variable name
<DFF> @@ -8,5 +8,5 @@
activity = DailyActivity.objects.all()[0]
self.assertEqual(activity.user, self.user)
self.assertEqual(activity.medium, 'Default')
- activity.assertEqual(activity.date, today)
+ self.assertEqual(activity.date, today)
self.assertEqual(activity.days, 0)
| 2 |
def test_signup_today(self):
today = date.today()
self.assertTrue(self.client.login(username=self.user.username,
password=self.user.username))
response = self.client.get(reverse('home'))
self.assertEqual(response.status_code, 200)
self.assertEqual(DailyActivity.objects.count(), 1)
activity = DailyActivity.objects.all()[0]
self.assertEqual(activity.user, self.user)
self.assertEqual(activity.medium, 'Default')
activity.assertEqual(activity.date, today)
self.assertEqual(activity.days, 0)
|
def test_signup_today(self):
today = date.today()
self.assertTrue(self.client.login(username=self.user.username,
password=self.user.username))
response = self.client.get(reverse('home'))
self.assertEqual(response.status_code, 200)
self.assertEqual(DailyActivity.objects.count(), 1)
activity = DailyActivity.objects.all()[0]
self.assertEqual(activity.user, self.user)
self.assertEqual(activity.medium, 'Default')
self.assertEqual(activity.date, today)
self.assertEqual(activity.days, 0)
|
var-misuse
|
<NME> test_daily_report.py
<BEF> def testDailyEngagementReport(self):
users_test = []
users_control = []
num_control1 = 0
num_test1 = 0
num_control2 = 0
num_test2 = 0
#create users
for i in range(5):
users_control.append(create_user_in_group(self.experiment, i,
Participant.CONTROL_GROUP,
date.today() - timedelta(days=i)))
users_test.append(create_user_in_group(self.experiment, i,
Participant.TEST_GROUP,
date.today() - timedelta(days=i)))
# users_<test|control>[0] were enrolled today, [1] 1 day ago, etc.
report_date = date.today() - timedelta(days=1)
expected_engagement_score_calls = {
(users_test[1], date.today() - timedelta(days=1), report_date): 3.2,
(users_test[2], date.today() - timedelta(days=2), report_date): 2.5,
(users_test[3], date.today() - timedelta(days=3), report_date): 4.1,
(users_test[4], date.today() - timedelta(days=4), report_date): 0,
(users_control[1], date.today() - timedelta(days=1), report_date): 0,
(users_control[2], date.today() - timedelta(days=2), report_date): 0,
(users_control[3], date.today() - timedelta(days=3), report_date): 0,
(users_control[4], date.today() - timedelta(days=4), report_date): 0}
test_case = num_test1
class EngagementScoreCalculatorStub(object):
def calculate_user_engagement_score(self, user,
start_date, end_date):
test_case.assertNotEquals(user, None)
test_case.assertTrue(expected_engagement_score_calls.
has_key((user, start_date, end_date)))
return expected_engagement_score_calls[(user,
start_date, end_date)]
(EngagementReportGenerator(EngagementScoreCalculatorStub()).
generate_daily_report_for_experiment(self.experiment, report_date))
experiment_report = DailyEngagementReport.objects.get(
experiment=self.experiment, date=report_date)
self.assertAlmostEqual((3.2 + 2.5 + 4.1 + 0)/4.0,
experiment_report.test_score)
self.assertAlmostEqual(0.0, experiment_report.control_score)
self.assertEquals(4, experiment_report.test_group_size)
self.assertEquals(4, experiment_report.control_group_size)
self.assertAlmostEqual(96.819293337188498, experiment_report.confidence)
<MSG> Fix incorrect variable name
<DFF>
|
def testDailyEngagementReport(self):
users_test = []
users_control = []
num_control1 = 0
num_test1 = 0
num_control2 = 0
num_test2 = 0
#create users
for i in range(5):
users_control.append(create_user_in_group(self.experiment, i,
Participant.CONTROL_GROUP,
date.today() - timedelta(days=i)))
users_test.append(create_user_in_group(self.experiment, i,
Participant.TEST_GROUP,
date.today() - timedelta(days=i)))
# users_<test|control>[0] were enrolled today, [1] 1 day ago, etc.
report_date = date.today() - timedelta(days=1)
expected_engagement_score_calls = {
(users_test[1], date.today() - timedelta(days=1), report_date): 3.2,
(users_test[2], date.today() - timedelta(days=2), report_date): 2.5,
(users_test[3], date.today() - timedelta(days=3), report_date): 4.1,
(users_test[4], date.today() - timedelta(days=4), report_date): 0,
(users_control[1], date.today() - timedelta(days=1), report_date): 0,
(users_control[2], date.today() - timedelta(days=2), report_date): 0,
(users_control[3], date.today() - timedelta(days=3), report_date): 0,
(users_control[4], date.today() - timedelta(days=4), report_date): 0}
test_case = self
class EngagementScoreCalculatorStub(object):
def calculate_user_engagement_score(self, user,
start_date, end_date):
test_case.assertNotEquals(user, None)
test_case.assertTrue(expected_engagement_score_calls.
has_key((user, start_date, end_date)))
return expected_engagement_score_calls[(user,
start_date, end_date)]
(EngagementReportGenerator(EngagementScoreCalculatorStub()).
generate_daily_report_for_experiment(self.experiment, report_date))
experiment_report = DailyEngagementReport.objects.get(
experiment=self.experiment, date=report_date)
self.assertAlmostEqual((3.2 + 2.5 + 4.1 + 0)/4.0,
experiment_report.test_score)
self.assertAlmostEqual(0.0, experiment_report.control_score)
self.assertEquals(4, experiment_report.test_group_size)
self.assertEquals(4, experiment_report.control_group_size)
self.assertAlmostEqual(96.819293337188498, experiment_report.confidence)
|
def testDailyEngagementReport(self):
users_test = []
users_control = []
num_control1 = 0
num_test1 = 0
num_control2 = 0
num_test2 = 0
#create users
for i in range(5):
users_control.append(create_user_in_group(self.experiment, i,
Participant.CONTROL_GROUP,
date.today() - timedelta(days=i)))
users_test.append(create_user_in_group(self.experiment, i,
Participant.TEST_GROUP,
date.today() - timedelta(days=i)))
# users_<test|control>[0] were enrolled today, [1] 1 day ago, etc.
report_date = date.today() - timedelta(days=1)
expected_engagement_score_calls = {
(users_test[1], date.today() - timedelta(days=1), report_date): 3.2,
(users_test[2], date.today() - timedelta(days=2), report_date): 2.5,
(users_test[3], date.today() - timedelta(days=3), report_date): 4.1,
(users_test[4], date.today() - timedelta(days=4), report_date): 0,
(users_control[1], date.today() - timedelta(days=1), report_date): 0,
(users_control[2], date.today() - timedelta(days=2), report_date): 0,
(users_control[3], date.today() - timedelta(days=3), report_date): 0,
(users_control[4], date.today() - timedelta(days=4), report_date): 0}
test_case = num_test1
class EngagementScoreCalculatorStub(object):
def calculate_user_engagement_score(self, user,
start_date, end_date):
test_case.assertNotEquals(user, None)
test_case.assertTrue(expected_engagement_score_calls.
has_key((user, start_date, end_date)))
return expected_engagement_score_calls[(user,
start_date, end_date)]
(EngagementReportGenerator(EngagementScoreCalculatorStub()).
generate_daily_report_for_experiment(self.experiment, report_date))
experiment_report = DailyEngagementReport.objects.get(
experiment=self.experiment, date=report_date)
self.assertAlmostEqual((3.2 + 2.5 + 4.1 + 0)/4.0,
experiment_report.test_score)
self.assertAlmostEqual(0.0, experiment_report.control_score)
self.assertEquals(4, experiment_report.test_group_size)
self.assertEquals(4, experiment_report.control_group_size)
self.assertAlmostEqual(96.819293337188498, experiment_report.confidence)
|
<NME> test_daily_report.py
<BEF> def testDailyEngagementReport(self):
users_test = []
users_control = []
num_control1 = 0
num_test1 = 0
num_control2 = 0
num_test2 = 0
#create users
for i in range(5):
users_control.append(create_user_in_group(self.experiment, i,
Participant.CONTROL_GROUP,
date.today() - timedelta(days=i)))
users_test.append(create_user_in_group(self.experiment, i,
Participant.TEST_GROUP,
date.today() - timedelta(days=i)))
# users_<test|control>[0] were enrolled today, [1] 1 day ago, etc.
report_date = date.today() - timedelta(days=1)
expected_engagement_score_calls = {
(users_test[1], date.today() - timedelta(days=1), report_date): 3.2,
(users_test[2], date.today() - timedelta(days=2), report_date): 2.5,
(users_test[3], date.today() - timedelta(days=3), report_date): 4.1,
(users_test[4], date.today() - timedelta(days=4), report_date): 0,
(users_control[1], date.today() - timedelta(days=1), report_date): 0,
(users_control[2], date.today() - timedelta(days=2), report_date): 0,
(users_control[3], date.today() - timedelta(days=3), report_date): 0,
(users_control[4], date.today() - timedelta(days=4), report_date): 0}
test_case = num_test1
class EngagementScoreCalculatorStub(object):
def calculate_user_engagement_score(self, user,
start_date, end_date):
test_case.assertNotEquals(user, None)
test_case.assertTrue(expected_engagement_score_calls.
has_key((user, start_date, end_date)))
return expected_engagement_score_calls[(user,
start_date, end_date)]
(EngagementReportGenerator(EngagementScoreCalculatorStub()).
generate_daily_report_for_experiment(self.experiment, report_date))
experiment_report = DailyEngagementReport.objects.get(
experiment=self.experiment, date=report_date)
self.assertAlmostEqual((3.2 + 2.5 + 4.1 + 0)/4.0,
experiment_report.test_score)
self.assertAlmostEqual(0.0, experiment_report.control_score)
self.assertEquals(4, experiment_report.test_group_size)
self.assertEquals(4, experiment_report.control_group_size)
self.assertAlmostEqual(96.819293337188498, experiment_report.confidence)
<MSG> Fix incorrect variable name
<DFF> @@ -29,7 +29,7 @@
(users_control[3], date.today() - timedelta(days=3), report_date): 0,
(users_control[4], date.today() - timedelta(days=4), report_date): 0}
- test_case = num_test1
+ test_case = self
class EngagementScoreCalculatorStub(object):
def calculate_user_engagement_score(self, user,
| 3 |
def testDailyEngagementReport(self):
users_test = []
users_control = []
num_control1 = 0
num_test1 = 0
num_control2 = 0
num_test2 = 0
#create users
for i in range(5):
users_control.append(create_user_in_group(self.experiment, i,
Participant.CONTROL_GROUP,
date.today() - timedelta(days=i)))
users_test.append(create_user_in_group(self.experiment, i,
Participant.TEST_GROUP,
date.today() - timedelta(days=i)))
# users_<test|control>[0] were enrolled today, [1] 1 day ago, etc.
report_date = date.today() - timedelta(days=1)
expected_engagement_score_calls = {
(users_test[1], date.today() - timedelta(days=1), report_date): 3.2,
(users_test[2], date.today() - timedelta(days=2), report_date): 2.5,
(users_test[3], date.today() - timedelta(days=3), report_date): 4.1,
(users_test[4], date.today() - timedelta(days=4), report_date): 0,
(users_control[1], date.today() - timedelta(days=1), report_date): 0,
(users_control[2], date.today() - timedelta(days=2), report_date): 0,
(users_control[3], date.today() - timedelta(days=3), report_date): 0,
(users_control[4], date.today() - timedelta(days=4), report_date): 0}
test_case = num_test1
class EngagementScoreCalculatorStub(object):
def calculate_user_engagement_score(self, user,
start_date, end_date):
test_case.assertNotEquals(user, None)
test_case.assertTrue(expected_engagement_score_calls.
has_key((user, start_date, end_date)))
return expected_engagement_score_calls[(user,
start_date, end_date)]
(EngagementReportGenerator(EngagementScoreCalculatorStub()).
generate_daily_report_for_experiment(self.experiment, report_date))
experiment_report = DailyEngagementReport.objects.get(
experiment=self.experiment, date=report_date)
self.assertAlmostEqual((3.2 + 2.5 + 4.1 + 0)/4.0,
experiment_report.test_score)
self.assertAlmostEqual(0.0, experiment_report.control_score)
self.assertEquals(4, experiment_report.test_group_size)
self.assertEquals(4, experiment_report.control_group_size)
self.assertAlmostEqual(96.819293337188498, experiment_report.confidence)
|
def testDailyEngagementReport(self):
users_test = []
users_control = []
num_control1 = 0
num_test1 = 0
num_control2 = 0
num_test2 = 0
#create users
for i in range(5):
users_control.append(create_user_in_group(self.experiment, i,
Participant.CONTROL_GROUP,
date.today() - timedelta(days=i)))
users_test.append(create_user_in_group(self.experiment, i,
Participant.TEST_GROUP,
date.today() - timedelta(days=i)))
# users_<test|control>[0] were enrolled today, [1] 1 day ago, etc.
report_date = date.today() - timedelta(days=1)
expected_engagement_score_calls = {
(users_test[1], date.today() - timedelta(days=1), report_date): 3.2,
(users_test[2], date.today() - timedelta(days=2), report_date): 2.5,
(users_test[3], date.today() - timedelta(days=3), report_date): 4.1,
(users_test[4], date.today() - timedelta(days=4), report_date): 0,
(users_control[1], date.today() - timedelta(days=1), report_date): 0,
(users_control[2], date.today() - timedelta(days=2), report_date): 0,
(users_control[3], date.today() - timedelta(days=3), report_date): 0,
(users_control[4], date.today() - timedelta(days=4), report_date): 0}
test_case = self
class EngagementScoreCalculatorStub(object):
def calculate_user_engagement_score(self, user,
start_date, end_date):
test_case.assertNotEquals(user, None)
test_case.assertTrue(expected_engagement_score_calls.
has_key((user, start_date, end_date)))
return expected_engagement_score_calls[(user,
start_date, end_date)]
(EngagementReportGenerator(EngagementScoreCalculatorStub()).
generate_daily_report_for_experiment(self.experiment, report_date))
experiment_report = DailyEngagementReport.objects.get(
experiment=self.experiment, date=report_date)
self.assertAlmostEqual((3.2 + 2.5 + 4.1 + 0)/4.0,
experiment_report.test_score)
self.assertAlmostEqual(0.0, experiment_report.control_score)
self.assertEquals(4, experiment_report.test_group_size)
self.assertEquals(4, experiment_report.control_group_size)
self.assertAlmostEqual(96.819293337188498, experiment_report.confidence)
|
var-misuse
|
<NME> questionanswer.py
<BEF> @staticmethod
def tokenize(sentence):
"""
Split a sentence into tokens including punctuation.
Args:
sentence (string) : String of sentence to tokenize.
Returns:
list : List of tokens.
"""
return [sentence.strip() for x in re.split('(\W+)?', sentence) if x.strip()]
<MSG> Fix incorrect variable name
<DFF>
|
@staticmethod
def tokenize(sentence):
"""
Split a sentence into tokens including punctuation.
Args:
sentence (string) : String of sentence to tokenize.
Returns:
list : List of tokens.
"""
return [x.strip() for x in re.split('(\W+)?', sentence) if x.strip()]
|
@staticmethod
def tokenize(sentence):
"""
Split a sentence into tokens including punctuation.
Args:
sentence (string) : String of sentence to tokenize.
Returns:
list : List of tokens.
"""
return [sentence.strip() for x in re.split('(\W+)?', sentence) if x.strip()]
|
<NME> questionanswer.py
<BEF> @staticmethod
def tokenize(sentence):
"""
Split a sentence into tokens including punctuation.
Args:
sentence (string) : String of sentence to tokenize.
Returns:
list : List of tokens.
"""
return [sentence.strip() for x in re.split('(\W+)?', sentence) if x.strip()]
<MSG> Fix incorrect variable name
<DFF> @@ -9,4 +9,4 @@
Returns:
list : List of tokens.
"""
- return [sentence.strip() for x in re.split('(\W+)?', sentence) if x.strip()]
+ return [x.strip() for x in re.split('(\W+)?', sentence) if x.strip()]
| 4 |
@staticmethod
def tokenize(sentence):
return [sentence.strip() for x in re.split('(\W+)?', sentence) if x.strip()]
|
@staticmethod
def tokenize(sentence):
return [x.strip() for x in re.split('(\W+)?', sentence) if x.strip()]
|
var-misuse
|
<NME> CellEditor.py
<BEF> def _OnChar(self, event):
"Handle the OnChar event by rejecting non-numerics"
if event.GetModifiers() != 0 and self.GetModifiers() != wx.MOD_SHIFT:
event.Skip()
return
if event.GetKeyCode() in self.acceptableCodes:
event.Skip()
return
wx.Bell()
<MSG> Fix incorrect variable name
<DFF>
|
def _OnChar(self, event):
"Handle the OnChar event by rejecting non-numerics"
if event.GetModifiers() != 0 and event.GetModifiers() != wx.MOD_SHIFT:
event.Skip()
return
if event.GetKeyCode() in self.acceptableCodes:
event.Skip()
return
wx.Bell()
|
def _OnChar(self, event):
"Handle the OnChar event by rejecting non-numerics"
if event.GetModifiers() != 0 and self.GetModifiers() != wx.MOD_SHIFT:
event.Skip()
return
if event.GetKeyCode() in self.acceptableCodes:
event.Skip()
return
wx.Bell()
|
<NME> CellEditor.py
<BEF> def _OnChar(self, event):
"Handle the OnChar event by rejecting non-numerics"
if event.GetModifiers() != 0 and self.GetModifiers() != wx.MOD_SHIFT:
event.Skip()
return
if event.GetKeyCode() in self.acceptableCodes:
event.Skip()
return
wx.Bell()
<MSG> Fix incorrect variable name
<DFF> @@ -1,6 +1,6 @@
def _OnChar(self, event):
"Handle the OnChar event by rejecting non-numerics"
- if event.GetModifiers() != 0 and self.GetModifiers() != wx.MOD_SHIFT:
+ if event.GetModifiers() != 0 and event.GetModifiers() != wx.MOD_SHIFT:
event.Skip()
return
| 5 |
def _OnChar(self, event):
"Handle the OnChar event by rejecting non-numerics"
if event.GetModifiers() != 0 and self.GetModifiers() != wx.MOD_SHIFT:
event.Skip()
return
if event.GetKeyCode() in self.acceptableCodes:
event.Skip()
return
wx.Bell()
|
def _OnChar(self, event):
"Handle the OnChar event by rejecting non-numerics"
if event.GetModifiers() != 0 and event.GetModifiers() != wx.MOD_SHIFT:
event.Skip()
return
if event.GetKeyCode() in self.acceptableCodes:
event.Skip()
return
wx.Bell()
|
var-misuse
|
<NME> virtualObjectListviewExample.py
<BEF> def __init__(self, title, artist, album, sizeInBytes, lastPlayed, rating):
self.title = title
self.artist = artist
self.album = album
a = datetime.datetime.strptime(lastPlayed, "%d/%m/%Y %H:%M")
datenp = np.datetime64(a)
self.lastPlayed = datenp
# self.date = datenp - datenp.astype('datetime64[M]') + 1
self.years = datenp.astype('datetime64[Y]').astype(int) + 1970
#months = dates.astype('datetime64[M]').astype(int) % 12 + 1
#self.lastPlayed = datetime.datetime.strptime(lastPlayed, "%d/%m/%Y %H:%M")
#self.date = datetime.datetime.strptime(lastPlayed, "%d/%m/%Y %H:%M").date()
#self.time = unicode(datetime.datetime.strptime(lastPlayed, "%d/%m/%Y %H:%M").time())
# print "type of self.time: ", type(self.time), str(self.time)
self.sizeInBytes = sizeInBytes
self.rating = a
<MSG> Fix incorrect variable name
<DFF>
|
def __init__(self, title, artist, album, sizeInBytes, lastPlayed, rating):
self.title = title
self.artist = artist
self.album = album
a = datetime.datetime.strptime(lastPlayed, "%d/%m/%Y %H:%M")
datenp = np.datetime64(a)
self.lastPlayed = datenp
# self.date = datenp - datenp.astype('datetime64[M]') + 1
self.years = datenp.astype('datetime64[Y]').astype(int) + 1970
#months = dates.astype('datetime64[M]').astype(int) % 12 + 1
#self.lastPlayed = datetime.datetime.strptime(lastPlayed, "%d/%m/%Y %H:%M")
#self.date = datetime.datetime.strptime(lastPlayed, "%d/%m/%Y %H:%M").date()
#self.time = unicode(datetime.datetime.strptime(lastPlayed, "%d/%m/%Y %H:%M").time())
# print "type of self.time: ", type(self.time), str(self.time)
self.sizeInBytes = sizeInBytes
self.rating = rating
|
def __init__(self, title, artist, album, sizeInBytes, lastPlayed, rating):
self.title = title
self.artist = artist
self.album = album
a = datetime.datetime.strptime(lastPlayed, "%d/%m/%Y %H:%M")
datenp = np.datetime64(a)
self.lastPlayed = datenp
# self.date = datenp - datenp.astype('datetime64[M]') + 1
self.years = datenp.astype('datetime64[Y]').astype(int) + 1970
#months = dates.astype('datetime64[M]').astype(int) % 12 + 1
#self.lastPlayed = datetime.datetime.strptime(lastPlayed, "%d/%m/%Y %H:%M")
#self.date = datetime.datetime.strptime(lastPlayed, "%d/%m/%Y %H:%M").date()
#self.time = unicode(datetime.datetime.strptime(lastPlayed, "%d/%m/%Y %H:%M").time())
# print "type of self.time: ", type(self.time), str(self.time)
self.sizeInBytes = sizeInBytes
self.rating = a
|
<NME> virtualObjectListviewExample.py
<BEF> def __init__(self, title, artist, album, sizeInBytes, lastPlayed, rating):
self.title = title
self.artist = artist
self.album = album
a = datetime.datetime.strptime(lastPlayed, "%d/%m/%Y %H:%M")
datenp = np.datetime64(a)
self.lastPlayed = datenp
# self.date = datenp - datenp.astype('datetime64[M]') + 1
self.years = datenp.astype('datetime64[Y]').astype(int) + 1970
#months = dates.astype('datetime64[M]').astype(int) % 12 + 1
#self.lastPlayed = datetime.datetime.strptime(lastPlayed, "%d/%m/%Y %H:%M")
#self.date = datetime.datetime.strptime(lastPlayed, "%d/%m/%Y %H:%M").date()
#self.time = unicode(datetime.datetime.strptime(lastPlayed, "%d/%m/%Y %H:%M").time())
# print "type of self.time: ", type(self.time), str(self.time)
self.sizeInBytes = sizeInBytes
self.rating = a
<MSG> Fix incorrect variable name
<DFF> @@ -16,4 +16,4 @@
# print "type of self.time: ", type(self.time), str(self.time)
self.sizeInBytes = sizeInBytes
- self.rating = a
+ self.rating = rating
| 6 |
def __init__(self, title, artist, album, sizeInBytes, lastPlayed, rating):
self.title = title
self.artist = artist
self.album = album
a = datetime.datetime.strptime(lastPlayed, "%d/%m/%Y %H:%M")
datenp = np.datetime64(a)
self.lastPlayed = datenp
# self.date = datenp - datenp.astype('datetime64[M]') + 1
self.years = datenp.astype('datetime64[Y]').astype(int) + 1970
#months = dates.astype('datetime64[M]').astype(int) % 12 + 1
#self.lastPlayed = datetime.datetime.strptime(lastPlayed, "%d/%m/%Y %H:%M")
#self.date = datetime.datetime.strptime(lastPlayed, "%d/%m/%Y %H:%M").date()
#self.time = unicode(datetime.datetime.strptime(lastPlayed, "%d/%m/%Y %H:%M").time())
# print "type of self.time: ", type(self.time), str(self.time)
self.sizeInBytes = sizeInBytes
self.rating = a
|
def __init__(self, title, artist, album, sizeInBytes, lastPlayed, rating):
self.title = title
self.artist = artist
self.album = album
a = datetime.datetime.strptime(lastPlayed, "%d/%m/%Y %H:%M")
datenp = np.datetime64(a)
self.lastPlayed = datenp
# self.date = datenp - datenp.astype('datetime64[M]') + 1
self.years = datenp.astype('datetime64[Y]').astype(int) + 1970
#months = dates.astype('datetime64[M]').astype(int) % 12 + 1
#self.lastPlayed = datetime.datetime.strptime(lastPlayed, "%d/%m/%Y %H:%M")
#self.date = datetime.datetime.strptime(lastPlayed, "%d/%m/%Y %H:%M").date()
#self.time = unicode(datetime.datetime.strptime(lastPlayed, "%d/%m/%Y %H:%M").time())
# print "type of self.time: ", type(self.time), str(self.time)
self.sizeInBytes = sizeInBytes
self.rating = rating
|
var-misuse
|
<NME> updates.py
<BEF> def __call__(self, params, cost):
updates = []
grads = T.grad(cost, params)
grads = clip_norms(grads, self.clipnorm)
t = theano.shared(floatX(1.))
b1_t = self.b1*self.l**(t-1)
for p, g in zip(params, self):
g = self.regularizer.gradient_regularize(p, g)
m = theano.shared(p.get_value() * 0.)
v = theano.shared(p.get_value() * 0.)
m_t = b1_t*m + (1 - b1_t)*g
v_t = self.b2*v + (1 - self.b2)*g**2
m_c = m_t / (1-self.b1**t)
v_c = v_t / (1-self.b2**t)
p_t = p - (self.lr * m_c) / (T.sqrt(v_c) + self.e)
p_t = self.regularizer.weight_regularize(p_t)
updates.append((m, m_t))
updates.append((v, v_t))
updates.append((p, p_t) )
updates.append((t, t + 1.))
return updates
<MSG> Fix incorrect variable name
<DFF>
|
def __call__(self, params, cost):
updates = []
grads = T.grad(cost, params)
grads = clip_norms(grads, self.clipnorm)
t = theano.shared(floatX(1.))
b1_t = self.b1*self.l**(t-1)
for p, g in zip(params, grads):
g = self.regularizer.gradient_regularize(p, g)
m = theano.shared(p.get_value() * 0.)
v = theano.shared(p.get_value() * 0.)
m_t = b1_t*m + (1 - b1_t)*g
v_t = self.b2*v + (1 - self.b2)*g**2
m_c = m_t / (1-self.b1**t)
v_c = v_t / (1-self.b2**t)
p_t = p - (self.lr * m_c) / (T.sqrt(v_c) + self.e)
p_t = self.regularizer.weight_regularize(p_t)
updates.append((m, m_t))
updates.append((v, v_t))
updates.append((p, p_t) )
updates.append((t, t + 1.))
return updates
|
def __call__(self, params, cost):
updates = []
grads = T.grad(cost, params)
grads = clip_norms(grads, self.clipnorm)
t = theano.shared(floatX(1.))
b1_t = self.b1*self.l**(t-1)
for p, g in zip(params, self):
g = self.regularizer.gradient_regularize(p, g)
m = theano.shared(p.get_value() * 0.)
v = theano.shared(p.get_value() * 0.)
m_t = b1_t*m + (1 - b1_t)*g
v_t = self.b2*v + (1 - self.b2)*g**2
m_c = m_t / (1-self.b1**t)
v_c = v_t / (1-self.b2**t)
p_t = p - (self.lr * m_c) / (T.sqrt(v_c) + self.e)
p_t = self.regularizer.weight_regularize(p_t)
updates.append((m, m_t))
updates.append((v, v_t))
updates.append((p, p_t) )
updates.append((t, t + 1.))
return updates
|
<NME> updates.py
<BEF> def __call__(self, params, cost):
updates = []
grads = T.grad(cost, params)
grads = clip_norms(grads, self.clipnorm)
t = theano.shared(floatX(1.))
b1_t = self.b1*self.l**(t-1)
for p, g in zip(params, self):
g = self.regularizer.gradient_regularize(p, g)
m = theano.shared(p.get_value() * 0.)
v = theano.shared(p.get_value() * 0.)
m_t = b1_t*m + (1 - b1_t)*g
v_t = self.b2*v + (1 - self.b2)*g**2
m_c = m_t / (1-self.b1**t)
v_c = v_t / (1-self.b2**t)
p_t = p - (self.lr * m_c) / (T.sqrt(v_c) + self.e)
p_t = self.regularizer.weight_regularize(p_t)
updates.append((m, m_t))
updates.append((v, v_t))
updates.append((p, p_t) )
updates.append((t, t + 1.))
return updates
<MSG> Fix incorrect variable name
<DFF> @@ -5,7 +5,7 @@
t = theano.shared(floatX(1.))
b1_t = self.b1*self.l**(t-1)
- for p, g in zip(params, self):
+ for p, g in zip(params, grads):
g = self.regularizer.gradient_regularize(p, g)
m = theano.shared(p.get_value() * 0.)
v = theano.shared(p.get_value() * 0.)
| 7 |
def __call__(self, params, cost):
updates = []
grads = T.grad(cost, params)
grads = clip_norms(grads, self.clipnorm)
t = theano.shared(floatX(1.))
b1_t = self.b1*self.l**(t-1)
for p, g in zip(params, self):
g = self.regularizer.gradient_regularize(p, g)
m = theano.shared(p.get_value() * 0.)
v = theano.shared(p.get_value() * 0.)
m_t = b1_t*m + (1 - b1_t)*g
v_t = self.b2*v + (1 - self.b2)*g**2
m_c = m_t / (1-self.b1**t)
v_c = v_t / (1-self.b2**t)
p_t = p - (self.lr * m_c) / (T.sqrt(v_c) + self.e)
p_t = self.regularizer.weight_regularize(p_t)
updates.append((m, m_t))
updates.append((v, v_t))
updates.append((p, p_t) )
updates.append((t, t + 1.))
return updates
|
def __call__(self, params, cost):
updates = []
grads = T.grad(cost, params)
grads = clip_norms(grads, self.clipnorm)
t = theano.shared(floatX(1.))
b1_t = self.b1*self.l**(t-1)
for p, g in zip(params, grads):
g = self.regularizer.gradient_regularize(p, g)
m = theano.shared(p.get_value() * 0.)
v = theano.shared(p.get_value() * 0.)
m_t = b1_t*m + (1 - b1_t)*g
v_t = self.b2*v + (1 - self.b2)*g**2
m_c = m_t / (1-self.b1**t)
v_c = v_t / (1-self.b2**t)
p_t = p - (self.lr * m_c) / (T.sqrt(v_c) + self.e)
p_t = self.regularizer.weight_regularize(p_t)
updates.append((m, m_t))
updates.append((v, v_t))
updates.append((p, p_t) )
updates.append((t, t + 1.))
return updates
|
var-misuse
|
<NME> layer.py
<BEF> def configure(self, in_obj):
super(ColorNoise, self).configure(in_obj)
self.out_shape = self.in_shape
try:
self.nfm, self.H, self.W = self.in_shape
self.HW = in_obj.H * self.W
except:
raise AttributeError('ColorNoise can only be used with layer providing CHW')
return self
<MSG> Fix incorrect variable name
<DFF>
|
def configure(self, in_obj):
super(ColorNoise, self).configure(in_obj)
self.out_shape = self.in_shape
try:
self.nfm, self.H, self.W = self.in_shape
self.HW = self.H * self.W
except:
raise AttributeError('ColorNoise can only be used with layer providing CHW')
return self
|
def configure(self, in_obj):
super(ColorNoise, self).configure(in_obj)
self.out_shape = self.in_shape
try:
self.nfm, self.H, self.W = self.in_shape
self.HW = in_obj.H * self.W
except:
raise AttributeError('ColorNoise can only be used with layer providing CHW')
return self
|
<NME> layer.py
<BEF> def configure(self, in_obj):
super(ColorNoise, self).configure(in_obj)
self.out_shape = self.in_shape
try:
self.nfm, self.H, self.W = self.in_shape
self.HW = in_obj.H * self.W
except:
raise AttributeError('ColorNoise can only be used with layer providing CHW')
return self
<MSG> Fix incorrect variable name
<DFF> @@ -3,7 +3,7 @@
self.out_shape = self.in_shape
try:
self.nfm, self.H, self.W = self.in_shape
- self.HW = in_obj.H * self.W
+ self.HW = self.H * self.W
except:
raise AttributeError('ColorNoise can only be used with layer providing CHW')
return self
| 8 |
def configure(self, in_obj):
super(ColorNoise, self).configure(in_obj)
self.out_shape = self.in_shape
try:
self.nfm, self.H, self.W = self.in_shape
self.HW = in_obj.H * self.W
except:
raise AttributeError('ColorNoise can only be used with layer providing CHW')
return self
|
def configure(self, in_obj):
super(ColorNoise, self).configure(in_obj)
self.out_shape = self.in_shape
try:
self.nfm, self.H, self.W = self.in_shape
self.HW = self.H * self.W
except:
raise AttributeError('ColorNoise can only be used with layer providing CHW')
return self
|
var-misuse
|
<NME> ListCtrlPrinter.py
<BEF> def SetCellPadding(self, padding):
"""
Set the padding around cells in this format
Padding is either a single numeric (indicating the values on all sides)
or a collection of paddings [left, top, right, bottom]
"""
self.cellPadding = padding._MakePadding(padding)
<MSG> Fix incorrect variable name
<DFF>
|
def SetCellPadding(self, padding):
"""
Set the padding around cells in this format
Padding is either a single numeric (indicating the values on all sides)
or a collection of paddings [left, top, right, bottom]
"""
self.cellPadding = self._MakePadding(padding)
|
def SetCellPadding(self, padding):
"""
Set the padding around cells in this format
Padding is either a single numeric (indicating the values on all sides)
or a collection of paddings [left, top, right, bottom]
"""
self.cellPadding = padding._MakePadding(padding)
|
<NME> ListCtrlPrinter.py
<BEF> def SetCellPadding(self, padding):
"""
Set the padding around cells in this format
Padding is either a single numeric (indicating the values on all sides)
or a collection of paddings [left, top, right, bottom]
"""
self.cellPadding = padding._MakePadding(padding)
<MSG> Fix incorrect variable name
<DFF> @@ -5,4 +5,4 @@
Padding is either a single numeric (indicating the values on all sides)
or a collection of paddings [left, top, right, bottom]
"""
- self.cellPadding = padding._MakePadding(padding)
+ self.cellPadding = self._MakePadding(padding)
| 9 |
def SetCellPadding(self, padding):
self.cellPadding = padding._MakePadding(padding)
|
def SetCellPadding(self, padding):
self.cellPadding = self._MakePadding(padding)
|
var-misuse
|
<NME> frmODMTools.py
<BEF> def addEdit(self, event):
with wx.BusyInfo("Please wait for a moment while ODMTools fetches the data and stores it in our database", parent=self):
logger.debug("Beginning editing")
isSelected, seriesID = self.pnlSelector.onReadyToEdit()
# logger.debug("Initializing DataTable")
# # tasks = [("dataTable", (memDB.conn, self.dataTable.myOlv))]
# tasks = [("dataTable", (self.dataTable.myOlv))]
# self.taskserver.setTasks(tasks)
# self.taskserver.processTasks()
if isSelected:
self.record_service = self.service_manager.get_record_service(self.txtPythonScript, seriesID,
connection=self.memDB)
self._ribbon.toggleEditButtons(True)
logger.debug("Initializing Plot")
self.pnlPlot.addEditPlot(isSelected.memDB, seriesID, self.record_service)
logger.debug("Initializing DataTable")
self.dataTable.init(self.memDB)
# set record service for console
Publisher.sendMessage("setEdit", isEdit=True)
logger.debug("Enabling Edit")
self.record_service.toggle_record(True)
# set the cursor for matplotlib
selectedObject = self.record_service.get_series()
Publisher.sendMessage("updateCursor", selectedObject=selectedObject)
else:
logger.debug("disabling Edit")
Publisher.sendMessage("setEdit", isEdit=False)
self.record_service.toggle_record(False)
# disable cursor for matplotlib
selectedObject = self.record_service.get_series()
Publisher.sendMessage("updateCursor", deselectedObject=selectedObject)
# self._mgr.Update()
logger.debug("Recording? %s" % self.record_service._record)
#self.record_service = None
self.txtPythonConsole.shell.run("edit_service = app.TopWindow.record_service", prompt=False, verbose=False)
self.txtPythonConsole.shell.run("series_service = edit_service.get_series_service()", prompt=False,
verbose=False)
#from meliae import scanner
#scanner.dump_all_objects("edit_plotting.dat")
logger.info("Finished Setting up Editing Series: %s " % seriesID)
<MSG> Fix incorrect variable name
<DFF>
|
def addEdit(self, event):
with wx.BusyInfo("Please wait for a moment while ODMTools fetches the data and stores it in our database", parent=self):
logger.debug("Beginning editing")
isSelected, seriesID = self.pnlSelector.onReadyToEdit()
# logger.debug("Initializing DataTable")
# # tasks = [("dataTable", (memDB.conn, self.dataTable.myOlv))]
# tasks = [("dataTable", (self.dataTable.myOlv))]
# self.taskserver.setTasks(tasks)
# self.taskserver.processTasks()
if isSelected:
self.record_service = self.service_manager.get_record_service(self.txtPythonScript, seriesID,
connection=self.memDB)
self._ribbon.toggleEditButtons(True)
logger.debug("Initializing Plot")
self.pnlPlot.addEditPlot(self.memDB, seriesID, self.record_service)
logger.debug("Initializing DataTable")
self.dataTable.init(self.memDB)
# set record service for console
Publisher.sendMessage("setEdit", isEdit=True)
logger.debug("Enabling Edit")
self.record_service.toggle_record(True)
# set the cursor for matplotlib
selectedObject = self.record_service.get_series()
Publisher.sendMessage("updateCursor", selectedObject=selectedObject)
else:
logger.debug("disabling Edit")
Publisher.sendMessage("setEdit", isEdit=False)
self.record_service.toggle_record(False)
# disable cursor for matplotlib
selectedObject = self.record_service.get_series()
Publisher.sendMessage("updateCursor", deselectedObject=selectedObject)
# self._mgr.Update()
logger.debug("Recording? %s" % self.record_service._record)
#self.record_service = None
self.txtPythonConsole.shell.run("edit_service = app.TopWindow.record_service", prompt=False, verbose=False)
self.txtPythonConsole.shell.run("series_service = edit_service.get_series_service()", prompt=False,
verbose=False)
#from meliae import scanner
#scanner.dump_all_objects("edit_plotting.dat")
logger.info("Finished Setting up Editing Series: %s " % seriesID)
|
def addEdit(self, event):
with wx.BusyInfo("Please wait for a moment while ODMTools fetches the data and stores it in our database", parent=self):
logger.debug("Beginning editing")
isSelected, seriesID = self.pnlSelector.onReadyToEdit()
# logger.debug("Initializing DataTable")
# # tasks = [("dataTable", (memDB.conn, self.dataTable.myOlv))]
# tasks = [("dataTable", (self.dataTable.myOlv))]
# self.taskserver.setTasks(tasks)
# self.taskserver.processTasks()
if isSelected:
self.record_service = self.service_manager.get_record_service(self.txtPythonScript, seriesID,
connection=self.memDB)
self._ribbon.toggleEditButtons(True)
logger.debug("Initializing Plot")
self.pnlPlot.addEditPlot(isSelected.memDB, seriesID, self.record_service)
logger.debug("Initializing DataTable")
self.dataTable.init(self.memDB)
# set record service for console
Publisher.sendMessage("setEdit", isEdit=True)
logger.debug("Enabling Edit")
self.record_service.toggle_record(True)
# set the cursor for matplotlib
selectedObject = self.record_service.get_series()
Publisher.sendMessage("updateCursor", selectedObject=selectedObject)
else:
logger.debug("disabling Edit")
Publisher.sendMessage("setEdit", isEdit=False)
self.record_service.toggle_record(False)
# disable cursor for matplotlib
selectedObject = self.record_service.get_series()
Publisher.sendMessage("updateCursor", deselectedObject=selectedObject)
# self._mgr.Update()
logger.debug("Recording? %s" % self.record_service._record)
#self.record_service = None
self.txtPythonConsole.shell.run("edit_service = app.TopWindow.record_service", prompt=False, verbose=False)
self.txtPythonConsole.shell.run("series_service = edit_service.get_series_service()", prompt=False,
verbose=False)
#from meliae import scanner
#scanner.dump_all_objects("edit_plotting.dat")
logger.info("Finished Setting up Editing Series: %s " % seriesID)
|
<NME> frmODMTools.py
<BEF> def addEdit(self, event):
with wx.BusyInfo("Please wait for a moment while ODMTools fetches the data and stores it in our database", parent=self):
logger.debug("Beginning editing")
isSelected, seriesID = self.pnlSelector.onReadyToEdit()
# logger.debug("Initializing DataTable")
# # tasks = [("dataTable", (memDB.conn, self.dataTable.myOlv))]
# tasks = [("dataTable", (self.dataTable.myOlv))]
# self.taskserver.setTasks(tasks)
# self.taskserver.processTasks()
if isSelected:
self.record_service = self.service_manager.get_record_service(self.txtPythonScript, seriesID,
connection=self.memDB)
self._ribbon.toggleEditButtons(True)
logger.debug("Initializing Plot")
self.pnlPlot.addEditPlot(isSelected.memDB, seriesID, self.record_service)
logger.debug("Initializing DataTable")
self.dataTable.init(self.memDB)
# set record service for console
Publisher.sendMessage("setEdit", isEdit=True)
logger.debug("Enabling Edit")
self.record_service.toggle_record(True)
# set the cursor for matplotlib
selectedObject = self.record_service.get_series()
Publisher.sendMessage("updateCursor", selectedObject=selectedObject)
else:
logger.debug("disabling Edit")
Publisher.sendMessage("setEdit", isEdit=False)
self.record_service.toggle_record(False)
# disable cursor for matplotlib
selectedObject = self.record_service.get_series()
Publisher.sendMessage("updateCursor", deselectedObject=selectedObject)
# self._mgr.Update()
logger.debug("Recording? %s" % self.record_service._record)
#self.record_service = None
self.txtPythonConsole.shell.run("edit_service = app.TopWindow.record_service", prompt=False, verbose=False)
self.txtPythonConsole.shell.run("series_service = edit_service.get_series_service()", prompt=False,
verbose=False)
#from meliae import scanner
#scanner.dump_all_objects("edit_plotting.dat")
logger.info("Finished Setting up Editing Series: %s " % seriesID)
<MSG> Fix incorrect variable name
<DFF> @@ -16,7 +16,7 @@
self._ribbon.toggleEditButtons(True)
logger.debug("Initializing Plot")
- self.pnlPlot.addEditPlot(isSelected.memDB, seriesID, self.record_service)
+ self.pnlPlot.addEditPlot(self.memDB, seriesID, self.record_service)
logger.debug("Initializing DataTable")
self.dataTable.init(self.memDB)
| 0 |
def addEdit(self, event):
with wx.BusyInfo("Please wait for a moment while ODMTools fetches the data and stores it in our database", parent=self):
logger.debug("Beginning editing")
isSelected, seriesID = self.pnlSelector.onReadyToEdit()
# logger.debug("Initializing DataTable")
# # tasks = [("dataTable", (memDB.conn, self.dataTable.myOlv))]
# tasks = [("dataTable", (self.dataTable.myOlv))]
# self.taskserver.setTasks(tasks)
# self.taskserver.processTasks()
if isSelected:
self.record_service = self.service_manager.get_record_service(self.txtPythonScript, seriesID,
connection=self.memDB)
self._ribbon.toggleEditButtons(True)
logger.debug("Initializing Plot")
self.pnlPlot.addEditPlot(isSelected.memDB, seriesID, self.record_service)
logger.debug("Initializing DataTable")
self.dataTable.init(self.memDB)
# set record service for console
Publisher.sendMessage("setEdit", isEdit=True)
logger.debug("Enabling Edit")
self.record_service.toggle_record(True)
# set the cursor for matplotlib
selectedObject = self.record_service.get_series()
Publisher.sendMessage("updateCursor", selectedObject=selectedObject)
else:
logger.debug("disabling Edit")
Publisher.sendMessage("setEdit", isEdit=False)
self.record_service.toggle_record(False)
# disable cursor for matplotlib
selectedObject = self.record_service.get_series()
Publisher.sendMessage("updateCursor", deselectedObject=selectedObject)
# self._mgr.Update()
logger.debug("Recording? %s" % self.record_service._record)
#self.record_service = None
self.txtPythonConsole.shell.run("edit_service = app.TopWindow.record_service", prompt=False, verbose=False)
self.txtPythonConsole.shell.run("series_service = edit_service.get_series_service()", prompt=False,
verbose=False)
#from meliae import scanner
#scanner.dump_all_objects("edit_plotting.dat")
logger.info("Finished Setting up Editing Series: %s " % seriesID)
|
def addEdit(self, event):
with wx.BusyInfo("Please wait for a moment while ODMTools fetches the data and stores it in our database", parent=self):
logger.debug("Beginning editing")
isSelected, seriesID = self.pnlSelector.onReadyToEdit()
# logger.debug("Initializing DataTable")
# # tasks = [("dataTable", (memDB.conn, self.dataTable.myOlv))]
# tasks = [("dataTable", (self.dataTable.myOlv))]
# self.taskserver.setTasks(tasks)
# self.taskserver.processTasks()
if isSelected:
self.record_service = self.service_manager.get_record_service(self.txtPythonScript, seriesID,
connection=self.memDB)
self._ribbon.toggleEditButtons(True)
logger.debug("Initializing Plot")
self.pnlPlot.addEditPlot(self.memDB, seriesID, self.record_service)
logger.debug("Initializing DataTable")
self.dataTable.init(self.memDB)
# set record service for console
Publisher.sendMessage("setEdit", isEdit=True)
logger.debug("Enabling Edit")
self.record_service.toggle_record(True)
# set the cursor for matplotlib
selectedObject = self.record_service.get_series()
Publisher.sendMessage("updateCursor", selectedObject=selectedObject)
else:
logger.debug("disabling Edit")
Publisher.sendMessage("setEdit", isEdit=False)
self.record_service.toggle_record(False)
# disable cursor for matplotlib
selectedObject = self.record_service.get_series()
Publisher.sendMessage("updateCursor", deselectedObject=selectedObject)
# self._mgr.Update()
logger.debug("Recording? %s" % self.record_service._record)
#self.record_service = None
self.txtPythonConsole.shell.run("edit_service = app.TopWindow.record_service", prompt=False, verbose=False)
self.txtPythonConsole.shell.run("series_service = edit_service.get_series_service()", prompt=False,
verbose=False)
#from meliae import scanner
#scanner.dump_all_objects("edit_plotting.dat")
logger.info("Finished Setting up Editing Series: %s " % seriesID)
|
var-misuse
|
<NME> test_series.py
<BEF> def test_qcl_relationship(self):
qcl = self.series.quality_control_level
assert self != None
<MSG> Fix incorrect variable name
<DFF>
|
def test_qcl_relationship(self):
qcl = self.series.quality_control_level
assert qcl != None
|
def test_qcl_relationship(self):
qcl = self.series.quality_control_level
assert self != None
|
<NME> test_series.py
<BEF> def test_qcl_relationship(self):
qcl = self.series.quality_control_level
assert self != None
<MSG> Fix incorrect variable name
<DFF> @@ -1,3 +1,3 @@
def test_qcl_relationship(self):
qcl = self.series.quality_control_level
- assert self != None
+ assert qcl != None
| 1 |
def test_qcl_relationship(self):
qcl = self.series.quality_control_level
assert self != None
|
def test_qcl_relationship(self):
qcl = self.series.quality_control_level
assert qcl != None
|
var-misuse
|
<NME> p_lineprofiler.py
<BEF> def analyze(self, filename):
"""Reimplement analyze method"""
if self.dockwidget and not self.ismaximized:
self.dockwidget.setVisible(True)
self.dockwidget.setFocus()
self.dockwidget.raise_()
pythonpath = self.main.get_spyder_pythonpath()
runconf = runconfig.get_run_configuration(filename)
wdir, args = None, None
if runconf is not None:
if runconf.wdir_enabled:
wdir = runconf.wdir
if filename.args_enabled:
args = runconf.args
LineProfilerWidget.analyze(
self, filename, wdir=wdir, args=args, pythonpath=pythonpath,
use_colors=self.get_option('use_colors', True))
<MSG> Fix incorrect variable name
<DFF>
|
def analyze(self, filename):
"""Reimplement analyze method"""
if self.dockwidget and not self.ismaximized:
self.dockwidget.setVisible(True)
self.dockwidget.setFocus()
self.dockwidget.raise_()
pythonpath = self.main.get_spyder_pythonpath()
runconf = runconfig.get_run_configuration(filename)
wdir, args = None, None
if runconf is not None:
if runconf.wdir_enabled:
wdir = runconf.wdir
if runconf.args_enabled:
args = runconf.args
LineProfilerWidget.analyze(
self, filename, wdir=wdir, args=args, pythonpath=pythonpath,
use_colors=self.get_option('use_colors', True))
|
def analyze(self, filename):
"""Reimplement analyze method"""
if self.dockwidget and not self.ismaximized:
self.dockwidget.setVisible(True)
self.dockwidget.setFocus()
self.dockwidget.raise_()
pythonpath = self.main.get_spyder_pythonpath()
runconf = runconfig.get_run_configuration(filename)
wdir, args = None, None
if runconf is not None:
if runconf.wdir_enabled:
wdir = runconf.wdir
if filename.args_enabled:
args = runconf.args
LineProfilerWidget.analyze(
self, filename, wdir=wdir, args=args, pythonpath=pythonpath,
use_colors=self.get_option('use_colors', True))
|
<NME> p_lineprofiler.py
<BEF> def analyze(self, filename):
"""Reimplement analyze method"""
if self.dockwidget and not self.ismaximized:
self.dockwidget.setVisible(True)
self.dockwidget.setFocus()
self.dockwidget.raise_()
pythonpath = self.main.get_spyder_pythonpath()
runconf = runconfig.get_run_configuration(filename)
wdir, args = None, None
if runconf is not None:
if runconf.wdir_enabled:
wdir = runconf.wdir
if filename.args_enabled:
args = runconf.args
LineProfilerWidget.analyze(
self, filename, wdir=wdir, args=args, pythonpath=pythonpath,
use_colors=self.get_option('use_colors', True))
<MSG> Fix incorrect variable name
<DFF> @@ -10,7 +10,7 @@
if runconf is not None:
if runconf.wdir_enabled:
wdir = runconf.wdir
- if filename.args_enabled:
+ if runconf.args_enabled:
args = runconf.args
LineProfilerWidget.analyze(
| 2 |
def analyze(self, filename):
if self.dockwidget and not self.ismaximized:
self.dockwidget.setVisible(True)
self.dockwidget.setFocus()
self.dockwidget.raise_()
pythonpath = self.main.get_spyder_pythonpath()
runconf = runconfig.get_run_configuration(filename)
wdir, args = None, None
if runconf is not None:
if runconf.wdir_enabled:
wdir = runconf.wdir
if filename.args_enabled:
args = runconf.args
LineProfilerWidget.analyze(
self, filename, wdir=wdir, args=args, pythonpath=pythonpath,
use_colors=self.get_option('use_colors', True))
|
def analyze(self, filename):
if self.dockwidget and not self.ismaximized:
self.dockwidget.setVisible(True)
self.dockwidget.setFocus()
self.dockwidget.raise_()
pythonpath = self.main.get_spyder_pythonpath()
runconf = runconfig.get_run_configuration(filename)
wdir, args = None, None
if runconf is not None:
if runconf.wdir_enabled:
wdir = runconf.wdir
if runconf.args_enabled:
args = runconf.args
LineProfilerWidget.analyze(
self, filename, wdir=wdir, args=args, pythonpath=pythonpath,
use_colors=self.get_option('use_colors', True))
|
var-misuse
|
<NME> float_ew.py
<BEF> def _split_stages(node, duplicates=None, aliases=None, stages=None, parents=None):
"""
Split out all reductions and post reduction scalar operations into seperate
stacks (stages)
This leaves remaining in the tree anything not in these categories.
"""
# init data structures
if duplicates is None:
duplicates = dict()
aliases = set()
stages = list()
parents = list()
if type(node) is list:
# don't count assignment node as a parent,
# it will always exist in the final stage which is processed outside of
# this function
if node[0][0] != "assign":
parents.append(node)
# post order traversal (pulls the stages deepest in the tree first)
if len(node) > 3:
_split_stages(node[3], duplicates, aliases, stages, parents)
if len(node) > 4:
_split_stages(node[4], duplicates, aliases, stages, parents)
if len(parents) > 0:
parents.pop()
if node[0][0] in _reduction_ops:
red_stack = _process_node(node, aliases, duplicates)
if red_stack:
# add this reduction stack to the stages
stages.append(("reduction", red_stack))
# decrement reduction count for all parents
for parent in parents:
parent[2] -= 1
# walk up the parent list
# TODO: potentially do this iteratively to find longest common set
# of operations
scalar_parent = None
for parents in parents[::-1]:
# find the highest parent that is both scalar and has no other
# child reductions
if parent[1] and parent[2] == 0:
scalar_parent = parent
else:
break
# if there are any scalar operations over this reduction, remove
# them from the tree as well
if scalar_parent is not None:
scalar_stack = _process_node(
scalar_parent, aliases, duplicates)
if scalar_stack:
# add this scalar stack to the stages
stages.append(("scalar", scalar_stack))
return stages
<MSG> Fix incorrect variable name
<DFF>
|
def _split_stages(node, duplicates=None, aliases=None, stages=None, parents=None):
"""
Split out all reductions and post reduction scalar operations into seperate
stacks (stages)
This leaves remaining in the tree anything not in these categories.
"""
# init data structures
if duplicates is None:
duplicates = dict()
aliases = set()
stages = list()
parents = list()
if type(node) is list:
# don't count assignment node as a parent,
# it will always exist in the final stage which is processed outside of
# this function
if node[0][0] != "assign":
parents.append(node)
# post order traversal (pulls the stages deepest in the tree first)
if len(node) > 3:
_split_stages(node[3], duplicates, aliases, stages, parents)
if len(node) > 4:
_split_stages(node[4], duplicates, aliases, stages, parents)
if len(parents) > 0:
parents.pop()
if node[0][0] in _reduction_ops:
red_stack = _process_node(node, aliases, duplicates)
if red_stack:
# add this reduction stack to the stages
stages.append(("reduction", red_stack))
# decrement reduction count for all parents
for parent in parents:
parent[2] -= 1
# walk up the parent list
# TODO: potentially do this iteratively to find longest common set
# of operations
scalar_parent = None
for parent in parents[::-1]:
# find the highest parent that is both scalar and has no other
# child reductions
if parent[1] and parent[2] == 0:
scalar_parent = parent
else:
break
# if there are any scalar operations over this reduction, remove
# them from the tree as well
if scalar_parent is not None:
scalar_stack = _process_node(
scalar_parent, aliases, duplicates)
if scalar_stack:
# add this scalar stack to the stages
stages.append(("scalar", scalar_stack))
return stages
|
def _split_stages(node, duplicates=None, aliases=None, stages=None, parents=None):
"""
Split out all reductions and post reduction scalar operations into seperate
stacks (stages)
This leaves remaining in the tree anything not in these categories.
"""
# init data structures
if duplicates is None:
duplicates = dict()
aliases = set()
stages = list()
parents = list()
if type(node) is list:
# don't count assignment node as a parent,
# it will always exist in the final stage which is processed outside of
# this function
if node[0][0] != "assign":
parents.append(node)
# post order traversal (pulls the stages deepest in the tree first)
if len(node) > 3:
_split_stages(node[3], duplicates, aliases, stages, parents)
if len(node) > 4:
_split_stages(node[4], duplicates, aliases, stages, parents)
if len(parents) > 0:
parents.pop()
if node[0][0] in _reduction_ops:
red_stack = _process_node(node, aliases, duplicates)
if red_stack:
# add this reduction stack to the stages
stages.append(("reduction", red_stack))
# decrement reduction count for all parents
for parent in parents:
parent[2] -= 1
# walk up the parent list
# TODO: potentially do this iteratively to find longest common set
# of operations
scalar_parent = None
for parents in parents[::-1]:
# find the highest parent that is both scalar and has no other
# child reductions
if parent[1] and parent[2] == 0:
scalar_parent = parent
else:
break
# if there are any scalar operations over this reduction, remove
# them from the tree as well
if scalar_parent is not None:
scalar_stack = _process_node(
scalar_parent, aliases, duplicates)
if scalar_stack:
# add this scalar stack to the stages
stages.append(("scalar", scalar_stack))
return stages
|
<NME> float_ew.py
<BEF> def _split_stages(node, duplicates=None, aliases=None, stages=None, parents=None):
"""
Split out all reductions and post reduction scalar operations into seperate
stacks (stages)
This leaves remaining in the tree anything not in these categories.
"""
# init data structures
if duplicates is None:
duplicates = dict()
aliases = set()
stages = list()
parents = list()
if type(node) is list:
# don't count assignment node as a parent,
# it will always exist in the final stage which is processed outside of
# this function
if node[0][0] != "assign":
parents.append(node)
# post order traversal (pulls the stages deepest in the tree first)
if len(node) > 3:
_split_stages(node[3], duplicates, aliases, stages, parents)
if len(node) > 4:
_split_stages(node[4], duplicates, aliases, stages, parents)
if len(parents) > 0:
parents.pop()
if node[0][0] in _reduction_ops:
red_stack = _process_node(node, aliases, duplicates)
if red_stack:
# add this reduction stack to the stages
stages.append(("reduction", red_stack))
# decrement reduction count for all parents
for parent in parents:
parent[2] -= 1
# walk up the parent list
# TODO: potentially do this iteratively to find longest common set
# of operations
scalar_parent = None
for parents in parents[::-1]:
# find the highest parent that is both scalar and has no other
# child reductions
if parent[1] and parent[2] == 0:
scalar_parent = parent
else:
break
# if there are any scalar operations over this reduction, remove
# them from the tree as well
if scalar_parent is not None:
scalar_stack = _process_node(
scalar_parent, aliases, duplicates)
if scalar_stack:
# add this scalar stack to the stages
stages.append(("scalar", scalar_stack))
return stages
<MSG> Fix incorrect variable name
<DFF> @@ -44,7 +44,7 @@
# TODO: potentially do this iteratively to find longest common set
# of operations
scalar_parent = None
- for parents in parents[::-1]:
+ for parent in parents[::-1]:
# find the highest parent that is both scalar and has no other
# child reductions
if parent[1] and parent[2] == 0:
| 3 |
def _split_stages(node, duplicates=None, aliases=None, stages=None, parents=None):
# init data structures
if duplicates is None:
duplicates = dict()
aliases = set()
stages = list()
parents = list()
if type(node) is list:
# don't count assignment node as a parent,
# it will always exist in the final stage which is processed outside of
# this function
if node[0][0] != "assign":
parents.append(node)
# post order traversal (pulls the stages deepest in the tree first)
if len(node) > 3:
_split_stages(node[3], duplicates, aliases, stages, parents)
if len(node) > 4:
_split_stages(node[4], duplicates, aliases, stages, parents)
if len(parents) > 0:
parents.pop()
if node[0][0] in _reduction_ops:
red_stack = _process_node(node, aliases, duplicates)
if red_stack:
# add this reduction stack to the stages
stages.append(("reduction", red_stack))
# decrement reduction count for all parents
for parent in parents:
parent[2] -= 1
# walk up the parent list
# TODO: potentially do this iteratively to find longest common set
# of operations
scalar_parent = None
for parents in parents[::-1]:
# find the highest parent that is both scalar and has no other
# child reductions
if parent[1] and parent[2] == 0:
scalar_parent = parent
else:
break
# if there are any scalar operations over this reduction, remove
# them from the tree as well
if scalar_parent is not None:
scalar_stack = _process_node(
scalar_parent, aliases, duplicates)
if scalar_stack:
# add this scalar stack to the stages
stages.append(("scalar", scalar_stack))
return stages
|
def _split_stages(node, duplicates=None, aliases=None, stages=None, parents=None):
# init data structures
if duplicates is None:
duplicates = dict()
aliases = set()
stages = list()
parents = list()
if type(node) is list:
# don't count assignment node as a parent,
# it will always exist in the final stage which is processed outside of
# this function
if node[0][0] != "assign":
parents.append(node)
# post order traversal (pulls the stages deepest in the tree first)
if len(node) > 3:
_split_stages(node[3], duplicates, aliases, stages, parents)
if len(node) > 4:
_split_stages(node[4], duplicates, aliases, stages, parents)
if len(parents) > 0:
parents.pop()
if node[0][0] in _reduction_ops:
red_stack = _process_node(node, aliases, duplicates)
if red_stack:
# add this reduction stack to the stages
stages.append(("reduction", red_stack))
# decrement reduction count for all parents
for parent in parents:
parent[2] -= 1
# walk up the parent list
# TODO: potentially do this iteratively to find longest common set
# of operations
scalar_parent = None
for parent in parents[::-1]:
# find the highest parent that is both scalar and has no other
# child reductions
if parent[1] and parent[2] == 0:
scalar_parent = parent
else:
break
# if there are any scalar operations over this reduction, remove
# them from the tree as well
if scalar_parent is not None:
scalar_stack = _process_node(
scalar_parent, aliases, duplicates)
if scalar_stack:
# add this scalar stack to the stages
stages.append(("scalar", scalar_stack))
return stages
|
var-misuse
|
<NME> trello.py
<BEF> def on_next(self, element):
self._post_message(self.formatter.create_element_message(self))
<MSG> Fix incorrect variable name
<DFF>
|
def on_next(self, element):
self._post_message(self.formatter.create_element_message(element))
|
def on_next(self, element):
self._post_message(self.formatter.create_element_message(self))
|
<NME> trello.py
<BEF> def on_next(self, element):
self._post_message(self.formatter.create_element_message(self))
<MSG> Fix incorrect variable name
<DFF> @@ -1,2 +1,2 @@
def on_next(self, element):
- self._post_message(self.formatter.create_element_message(self))
+ self._post_message(self.formatter.create_element_message(element))
| 4 |
def on_next(self, element):
self._post_message(self.formatter.create_element_message(self))
|
def on_next(self, element):
self._post_message(self.formatter.create_element_message(element))
|
var-misuse
|
<NME> feedback.py
<BEF> def getXMLElement(self):
item = ElementTree.Element('item', self.attrb)
for (k, v) in self.content.iteritems():
attrb = {}
if k == 'icon' and self.icon_type:
attrb['type'] = self.icon_type
sub = ElementTree.SubElement(self, k, attrb)
sub.text = v
return item
<MSG> Fix incorrect variable name
<DFF>
|
def getXMLElement(self):
item = ElementTree.Element('item', self.attrb)
for (k, v) in self.content.iteritems():
attrb = {}
if k == 'icon' and self.icon_type:
attrb['type'] = self.icon_type
sub = ElementTree.SubElement(item, k, attrb)
sub.text = v
return item
|
def getXMLElement(self):
item = ElementTree.Element('item', self.attrb)
for (k, v) in self.content.iteritems():
attrb = {}
if k == 'icon' and self.icon_type:
attrb['type'] = self.icon_type
sub = ElementTree.SubElement(self, k, attrb)
sub.text = v
return item
|
<NME> feedback.py
<BEF> def getXMLElement(self):
item = ElementTree.Element('item', self.attrb)
for (k, v) in self.content.iteritems():
attrb = {}
if k == 'icon' and self.icon_type:
attrb['type'] = self.icon_type
sub = ElementTree.SubElement(self, k, attrb)
sub.text = v
return item
<MSG> Fix incorrect variable name
<DFF> @@ -4,6 +4,6 @@
attrb = {}
if k == 'icon' and self.icon_type:
attrb['type'] = self.icon_type
- sub = ElementTree.SubElement(self, k, attrb)
+ sub = ElementTree.SubElement(item, k, attrb)
sub.text = v
return item
| 5 |
def getXMLElement(self):
item = ElementTree.Element('item', self.attrb)
for (k, v) in self.content.iteritems():
attrb = {}
if k == 'icon' and self.icon_type:
attrb['type'] = self.icon_type
sub = ElementTree.SubElement(self, k, attrb)
sub.text = v
return item
|
def getXMLElement(self):
item = ElementTree.Element('item', self.attrb)
for (k, v) in self.content.iteritems():
attrb = {}
if k == 'icon' and self.icon_type:
attrb['type'] = self.icon_type
sub = ElementTree.SubElement(item, k, attrb)
sub.text = v
return item
|
var-misuse
|
<NME> capture_audio.py
<BEF> def capture_seconds(num_seconds, chunksize, rate, width):
num_buffers = int(float(num_seconds * rate) / chunksize)
return capture_buffers(num_buffers, chunksize, rate, num_buffers)
<MSG> Fix incorrect variable name
<DFF>
|
def capture_seconds(num_seconds, chunksize, rate, width):
num_buffers = int(float(num_seconds * rate) / chunksize)
return capture_buffers(num_buffers, chunksize, rate, width)
|
def capture_seconds(num_seconds, chunksize, rate, width):
num_buffers = int(float(num_seconds * rate) / chunksize)
return capture_buffers(num_buffers, chunksize, rate, num_buffers)
|
<NME> capture_audio.py
<BEF> def capture_seconds(num_seconds, chunksize, rate, width):
num_buffers = int(float(num_seconds * rate) / chunksize)
return capture_buffers(num_buffers, chunksize, rate, num_buffers)
<MSG> Fix incorrect variable name
<DFF> @@ -1,3 +1,3 @@
def capture_seconds(num_seconds, chunksize, rate, width):
num_buffers = int(float(num_seconds * rate) / chunksize)
- return capture_buffers(num_buffers, chunksize, rate, num_buffers)
+ return capture_buffers(num_buffers, chunksize, rate, width)
| 6 |
def capture_seconds(num_seconds, chunksize, rate, width):
num_buffers = int(float(num_seconds * rate) / chunksize)
return capture_buffers(num_buffers, chunksize, rate, num_buffers)
|
def capture_seconds(num_seconds, chunksize, rate, width):
num_buffers = int(float(num_seconds * rate) / chunksize)
return capture_buffers(num_buffers, chunksize, rate, width)
|
var-misuse
|
<NME> recurrent.py
<BEF> def configure(self, in_obj):
super(BiRNN, self).configure(in_obj)
(self.nin, self.nsteps) = self.in_shape
self.out_shape = (2 * self.nout, self.nsteps)
self.gate_shape = (2 * self.nout * self.ngates, self.nsteps)
if self.split_inputs is True and self.nin % 2 == 1:
raise ValueError("# inputs units is odd and split_inputs is True ")
self.o_shape = (self.nout, self.nsteps)
self.g_shape = (self.nout * self.ngates, in_obj.nsteps)
self.i_shape = (
self.nin/2, self.nsteps) if self.split_inputs else (self.nin, self.nsteps)
if self.weight_shape is None:
self.weight_shape = (self.nout, self.nin)
return self
<MSG> Fix incorrect variable name
<DFF>
|
def configure(self, in_obj):
super(BiRNN, self).configure(in_obj)
(self.nin, self.nsteps) = self.in_shape
self.out_shape = (2 * self.nout, self.nsteps)
self.gate_shape = (2 * self.nout * self.ngates, self.nsteps)
if self.split_inputs is True and self.nin % 2 == 1:
raise ValueError("# inputs units is odd and split_inputs is True ")
self.o_shape = (self.nout, self.nsteps)
self.g_shape = (self.nout * self.ngates, self.nsteps)
self.i_shape = (
self.nin/2, self.nsteps) if self.split_inputs else (self.nin, self.nsteps)
if self.weight_shape is None:
self.weight_shape = (self.nout, self.nin)
return self
|
def configure(self, in_obj):
super(BiRNN, self).configure(in_obj)
(self.nin, self.nsteps) = self.in_shape
self.out_shape = (2 * self.nout, self.nsteps)
self.gate_shape = (2 * self.nout * self.ngates, self.nsteps)
if self.split_inputs is True and self.nin % 2 == 1:
raise ValueError("# inputs units is odd and split_inputs is True ")
self.o_shape = (self.nout, self.nsteps)
self.g_shape = (self.nout * self.ngates, in_obj.nsteps)
self.i_shape = (
self.nin/2, self.nsteps) if self.split_inputs else (self.nin, self.nsteps)
if self.weight_shape is None:
self.weight_shape = (self.nout, self.nin)
return self
|
<NME> recurrent.py
<BEF> def configure(self, in_obj):
super(BiRNN, self).configure(in_obj)
(self.nin, self.nsteps) = self.in_shape
self.out_shape = (2 * self.nout, self.nsteps)
self.gate_shape = (2 * self.nout * self.ngates, self.nsteps)
if self.split_inputs is True and self.nin % 2 == 1:
raise ValueError("# inputs units is odd and split_inputs is True ")
self.o_shape = (self.nout, self.nsteps)
self.g_shape = (self.nout * self.ngates, in_obj.nsteps)
self.i_shape = (
self.nin/2, self.nsteps) if self.split_inputs else (self.nin, self.nsteps)
if self.weight_shape is None:
self.weight_shape = (self.nout, self.nin)
return self
<MSG> Fix incorrect variable name
<DFF> @@ -9,7 +9,7 @@
raise ValueError("# inputs units is odd and split_inputs is True ")
self.o_shape = (self.nout, self.nsteps)
- self.g_shape = (self.nout * self.ngates, in_obj.nsteps)
+ self.g_shape = (self.nout * self.ngates, self.nsteps)
self.i_shape = (
self.nin/2, self.nsteps) if self.split_inputs else (self.nin, self.nsteps)
| 7 |
def configure(self, in_obj):
super(BiRNN, self).configure(in_obj)
(self.nin, self.nsteps) = self.in_shape
self.out_shape = (2 * self.nout, self.nsteps)
self.gate_shape = (2 * self.nout * self.ngates, self.nsteps)
if self.split_inputs is True and self.nin % 2 == 1:
raise ValueError("# inputs units is odd and split_inputs is True ")
self.o_shape = (self.nout, self.nsteps)
self.g_shape = (self.nout * self.ngates, in_obj.nsteps)
self.i_shape = (
self.nin/2, self.nsteps) if self.split_inputs else (self.nin, self.nsteps)
if self.weight_shape is None:
self.weight_shape = (self.nout, self.nin)
return self
|
def configure(self, in_obj):
super(BiRNN, self).configure(in_obj)
(self.nin, self.nsteps) = self.in_shape
self.out_shape = (2 * self.nout, self.nsteps)
self.gate_shape = (2 * self.nout * self.ngates, self.nsteps)
if self.split_inputs is True and self.nin % 2 == 1:
raise ValueError("# inputs units is odd and split_inputs is True ")
self.o_shape = (self.nout, self.nsteps)
self.g_shape = (self.nout * self.ngates, self.nsteps)
self.i_shape = (
self.nin/2, self.nsteps) if self.split_inputs else (self.nin, self.nsteps)
if self.weight_shape is None:
self.weight_shape = (self.nout, self.nin)
return self
|
var-misuse
|
<NME> recurrent.py
<BEF> def init_params(self, shape):
"""
Initialize params for GRU including weights and biases.
The weight matrix and bias matrix are concatenated from the weights
for inputs and weights for recurrent inputs and bias.
The shape of the weights are (number of inputs + number of outputs +1 )
by (number of outputs * 3)
Arguments:
shape (Tuple): contains number of outputs and number of inputs
"""
super(GRU, self).init_params(shape)
(nout, nin) = shape
# indices for slicing gate buffers
(rz1, rz2) = (0, nout * 2)
(c1, c2) = (nout * 2, shape * 3)
self.Wrz_recur = self.W_recur[rz1:rz2]
self.Whcan_recur = self.W_recur[c1:c2]
self.b_rz = self.b[rz1:rz2]
self.b_hcan = self.b[c1:c2]
self.dWrz_recur = self.dW_recur[rz1:rz2]
self.dWhcan_recur = self.dW_recur[c1:c2]
<MSG> Fix incorrect variable name
<DFF>
|
def init_params(self, shape):
"""
Initialize params for GRU including weights and biases.
The weight matrix and bias matrix are concatenated from the weights
for inputs and weights for recurrent inputs and bias.
The shape of the weights are (number of inputs + number of outputs +1 )
by (number of outputs * 3)
Arguments:
shape (Tuple): contains number of outputs and number of inputs
"""
super(GRU, self).init_params(shape)
(nout, nin) = shape
# indices for slicing gate buffers
(rz1, rz2) = (0, nout * 2)
(c1, c2) = (nout * 2, nout * 3)
self.Wrz_recur = self.W_recur[rz1:rz2]
self.Whcan_recur = self.W_recur[c1:c2]
self.b_rz = self.b[rz1:rz2]
self.b_hcan = self.b[c1:c2]
self.dWrz_recur = self.dW_recur[rz1:rz2]
self.dWhcan_recur = self.dW_recur[c1:c2]
|
def init_params(self, shape):
"""
Initialize params for GRU including weights and biases.
The weight matrix and bias matrix are concatenated from the weights
for inputs and weights for recurrent inputs and bias.
The shape of the weights are (number of inputs + number of outputs +1 )
by (number of outputs * 3)
Arguments:
shape (Tuple): contains number of outputs and number of inputs
"""
super(GRU, self).init_params(shape)
(nout, nin) = shape
# indices for slicing gate buffers
(rz1, rz2) = (0, nout * 2)
(c1, c2) = (nout * 2, shape * 3)
self.Wrz_recur = self.W_recur[rz1:rz2]
self.Whcan_recur = self.W_recur[c1:c2]
self.b_rz = self.b[rz1:rz2]
self.b_hcan = self.b[c1:c2]
self.dWrz_recur = self.dW_recur[rz1:rz2]
self.dWhcan_recur = self.dW_recur[c1:c2]
|
<NME> recurrent.py
<BEF> def init_params(self, shape):
"""
Initialize params for GRU including weights and biases.
The weight matrix and bias matrix are concatenated from the weights
for inputs and weights for recurrent inputs and bias.
The shape of the weights are (number of inputs + number of outputs +1 )
by (number of outputs * 3)
Arguments:
shape (Tuple): contains number of outputs and number of inputs
"""
super(GRU, self).init_params(shape)
(nout, nin) = shape
# indices for slicing gate buffers
(rz1, rz2) = (0, nout * 2)
(c1, c2) = (nout * 2, shape * 3)
self.Wrz_recur = self.W_recur[rz1:rz2]
self.Whcan_recur = self.W_recur[c1:c2]
self.b_rz = self.b[rz1:rz2]
self.b_hcan = self.b[c1:c2]
self.dWrz_recur = self.dW_recur[rz1:rz2]
self.dWhcan_recur = self.dW_recur[c1:c2]
<MSG> Fix incorrect variable name
<DFF> @@ -15,7 +15,7 @@
# indices for slicing gate buffers
(rz1, rz2) = (0, nout * 2)
- (c1, c2) = (nout * 2, shape * 3)
+ (c1, c2) = (nout * 2, nout * 3)
self.Wrz_recur = self.W_recur[rz1:rz2]
self.Whcan_recur = self.W_recur[c1:c2]
| 8 |
def init_params(self, shape):
super(GRU, self).init_params(shape)
(nout, nin) = shape
# indices for slicing gate buffers
(rz1, rz2) = (0, nout * 2)
(c1, c2) = (nout * 2, shape * 3)
self.Wrz_recur = self.W_recur[rz1:rz2]
self.Whcan_recur = self.W_recur[c1:c2]
self.b_rz = self.b[rz1:rz2]
self.b_hcan = self.b[c1:c2]
self.dWrz_recur = self.dW_recur[rz1:rz2]
self.dWhcan_recur = self.dW_recur[c1:c2]
|
def init_params(self, shape):
super(GRU, self).init_params(shape)
(nout, nin) = shape
# indices for slicing gate buffers
(rz1, rz2) = (0, nout * 2)
(c1, c2) = (nout * 2, nout * 3)
self.Wrz_recur = self.W_recur[rz1:rz2]
self.Whcan_recur = self.W_recur[c1:c2]
self.b_rz = self.b[rz1:rz2]
self.b_hcan = self.b[c1:c2]
self.dWrz_recur = self.dW_recur[rz1:rz2]
self.dWhcan_recur = self.dW_recur[c1:c2]
|
var-misuse
|
<NME> panUpdate.py
<BEF> def createOpener():
'''Create a generic opener for http
This is particularly helpful when there is a proxy server in line'''
# Thanks to: http://www.decalage.info/en/python/urllib2noproxy
proxy_handler = urllib2.ProxyHandler(HTTP_PROXY)
opener = urllib2.build_opener(opener)
urllib2.install_opener(opener)
return opener
<MSG> Fix incorrect variable name
<DFF>
|
def createOpener():
'''Create a generic opener for http
This is particularly helpful when there is a proxy server in line'''
# Thanks to: http://www.decalage.info/en/python/urllib2noproxy
proxy_handler = urllib2.ProxyHandler(HTTP_PROXY)
opener = urllib2.build_opener(proxy_handler)
urllib2.install_opener(opener)
return opener
|
def createOpener():
'''Create a generic opener for http
This is particularly helpful when there is a proxy server in line'''
# Thanks to: http://www.decalage.info/en/python/urllib2noproxy
proxy_handler = urllib2.ProxyHandler(HTTP_PROXY)
opener = urllib2.build_opener(opener)
urllib2.install_opener(opener)
return opener
|
<NME> panUpdate.py
<BEF> def createOpener():
'''Create a generic opener for http
This is particularly helpful when there is a proxy server in line'''
# Thanks to: http://www.decalage.info/en/python/urllib2noproxy
proxy_handler = urllib2.ProxyHandler(HTTP_PROXY)
opener = urllib2.build_opener(opener)
urllib2.install_opener(opener)
return opener
<MSG> Fix incorrect variable name
<DFF> @@ -3,6 +3,6 @@
This is particularly helpful when there is a proxy server in line'''
# Thanks to: http://www.decalage.info/en/python/urllib2noproxy
proxy_handler = urllib2.ProxyHandler(HTTP_PROXY)
- opener = urllib2.build_opener(opener)
+ opener = urllib2.build_opener(proxy_handler)
urllib2.install_opener(opener)
return opener
| 9 |
def createOpener():
'''Create a generic opener for http
This is particularly helpful when there is a proxy server in line'''
# Thanks to: http://www.decalage.info/en/python/urllib2noproxy
proxy_handler = urllib2.ProxyHandler(HTTP_PROXY)
opener = urllib2.build_opener(opener)
urllib2.install_opener(opener)
return opener
|
def createOpener():
'''Create a generic opener for http
This is particularly helpful when there is a proxy server in line'''
# Thanks to: http://www.decalage.info/en/python/urllib2noproxy
proxy_handler = urllib2.ProxyHandler(HTTP_PROXY)
opener = urllib2.build_opener(proxy_handler)
urllib2.install_opener(opener)
return opener
|
var-misuse
|
<NME> implant.py
<BEF> def build(self):
cmd = {'sender': self.sender,
'receiver': self.receiver,
'output': self.output,
'cmd': cmd.cmd,
'jobid': self.jobid}
return base64.b64encode(json.dumps(cmd))
<MSG> Fix incorrect variable name
<DFF>
|
def build(self):
cmd = {'sender': self.sender,
'receiver': self.receiver,
'output': self.output,
'cmd': self.cmd,
'jobid': self.jobid}
return base64.b64encode(json.dumps(cmd))
|
def build(self):
cmd = {'sender': self.sender,
'receiver': self.receiver,
'output': self.output,
'cmd': cmd.cmd,
'jobid': self.jobid}
return base64.b64encode(json.dumps(cmd))
|
<NME> implant.py
<BEF> def build(self):
cmd = {'sender': self.sender,
'receiver': self.receiver,
'output': self.output,
'cmd': cmd.cmd,
'jobid': self.jobid}
return base64.b64encode(json.dumps(cmd))
<MSG> Fix incorrect variable name
<DFF> @@ -2,6 +2,6 @@
cmd = {'sender': self.sender,
'receiver': self.receiver,
'output': self.output,
- 'cmd': cmd.cmd,
+ 'cmd': self.cmd,
'jobid': self.jobid}
return base64.b64encode(json.dumps(cmd))
| 0 |
def build(self):
cmd = {'sender': self.sender,
'receiver': self.receiver,
'output': self.output,
'cmd': cmd.cmd,
'jobid': self.jobid}
return base64.b64encode(json.dumps(cmd))
|
def build(self):
cmd = {'sender': self.sender,
'receiver': self.receiver,
'output': self.output,
'cmd': self.cmd,
'jobid': self.jobid}
return base64.b64encode(json.dumps(cmd))
|
var-misuse
|
<NME> ttps.py
<BEF> def __init__(self, ttps=None):
super(TTPs, self).__init__(ttps)
ttps.kill_chains = KillChains()
<MSG> Fix incorrect variable name
<DFF>
|
def __init__(self, ttps=None):
super(TTPs, self).__init__(ttps)
self.kill_chains = KillChains()
|
def __init__(self, ttps=None):
super(TTPs, self).__init__(ttps)
ttps.kill_chains = KillChains()
|
<NME> ttps.py
<BEF> def __init__(self, ttps=None):
super(TTPs, self).__init__(ttps)
ttps.kill_chains = KillChains()
<MSG> Fix incorrect variable name
<DFF> @@ -1,3 +1,3 @@
def __init__(self, ttps=None):
super(TTPs, self).__init__(ttps)
- ttps.kill_chains = KillChains()
+ self.kill_chains = KillChains()
| 1 |
def __init__(self, ttps=None):
super(TTPs, self).__init__(ttps)
ttps.kill_chains = KillChains()
|
def __init__(self, ttps=None):
super(TTPs, self).__init__(ttps)
self.kill_chains = KillChains()
|
var-misuse
|
<NME> Data_CSV.py
<BEF> def csv_sym(sym, d_data, ls_keys, s_directory):
bool_first_iter = True
for key in ls_keys:
if bool_first_iter == True:
df_sym = d_data[key].reindex(columns = [sym])
df_sym = df_sym.rename(columns = {sym : key})
bool_first_iter = False
else:
df_temp = d_data[key].reindex(columns = [sym])
df_temp = df_temp.rename(columns = {sym : key})
df_sym = df_sym.join(df_temp, how= 'outer')
symfilename = sym.split('-')[0]
sym_file = open(s_directory + symfilename + '.csv', 'w')
sym_file.write("Date,Open,High,Low,Close,Volume,Adj Close \n")
ldt_timestamps = list(df_sym.index)
ldt_timestamps.reverse()
for date in ldt_timestamps:
date_to_csv = '{:%Y-%m-%d}'.format(date)
string_to_csv = ldt_timestamps
for key in ls_keys:
string_to_csv = string_to_csv + ',' + str(df_sym[key][date])
string_to_csv = string_to_csv + '\n'
sym_file.write(string_to_csv)
<MSG> Fix incorrect variable name
<DFF>
|
def csv_sym(sym, d_data, ls_keys, s_directory):
bool_first_iter = True
for key in ls_keys:
if bool_first_iter == True:
df_sym = d_data[key].reindex(columns = [sym])
df_sym = df_sym.rename(columns = {sym : key})
bool_first_iter = False
else:
df_temp = d_data[key].reindex(columns = [sym])
df_temp = df_temp.rename(columns = {sym : key})
df_sym = df_sym.join(df_temp, how= 'outer')
symfilename = sym.split('-')[0]
sym_file = open(s_directory + symfilename + '.csv', 'w')
sym_file.write("Date,Open,High,Low,Close,Volume,Adj Close \n")
ldt_timestamps = list(df_sym.index)
ldt_timestamps.reverse()
for date in ldt_timestamps:
date_to_csv = '{:%Y-%m-%d}'.format(date)
string_to_csv = date_to_csv
for key in ls_keys:
string_to_csv = string_to_csv + ',' + str(df_sym[key][date])
string_to_csv = string_to_csv + '\n'
sym_file.write(string_to_csv)
|
def csv_sym(sym, d_data, ls_keys, s_directory):
bool_first_iter = True
for key in ls_keys:
if bool_first_iter == True:
df_sym = d_data[key].reindex(columns = [sym])
df_sym = df_sym.rename(columns = {sym : key})
bool_first_iter = False
else:
df_temp = d_data[key].reindex(columns = [sym])
df_temp = df_temp.rename(columns = {sym : key})
df_sym = df_sym.join(df_temp, how= 'outer')
symfilename = sym.split('-')[0]
sym_file = open(s_directory + symfilename + '.csv', 'w')
sym_file.write("Date,Open,High,Low,Close,Volume,Adj Close \n")
ldt_timestamps = list(df_sym.index)
ldt_timestamps.reverse()
for date in ldt_timestamps:
date_to_csv = '{:%Y-%m-%d}'.format(date)
string_to_csv = ldt_timestamps
for key in ls_keys:
string_to_csv = string_to_csv + ',' + str(df_sym[key][date])
string_to_csv = string_to_csv + '\n'
sym_file.write(string_to_csv)
|
<NME> Data_CSV.py
<BEF> def csv_sym(sym, d_data, ls_keys, s_directory):
bool_first_iter = True
for key in ls_keys:
if bool_first_iter == True:
df_sym = d_data[key].reindex(columns = [sym])
df_sym = df_sym.rename(columns = {sym : key})
bool_first_iter = False
else:
df_temp = d_data[key].reindex(columns = [sym])
df_temp = df_temp.rename(columns = {sym : key})
df_sym = df_sym.join(df_temp, how= 'outer')
symfilename = sym.split('-')[0]
sym_file = open(s_directory + symfilename + '.csv', 'w')
sym_file.write("Date,Open,High,Low,Close,Volume,Adj Close \n")
ldt_timestamps = list(df_sym.index)
ldt_timestamps.reverse()
for date in ldt_timestamps:
date_to_csv = '{:%Y-%m-%d}'.format(date)
string_to_csv = ldt_timestamps
for key in ls_keys:
string_to_csv = string_to_csv + ',' + str(df_sym[key][date])
string_to_csv = string_to_csv + '\n'
sym_file.write(string_to_csv)
<MSG> Fix incorrect variable name
<DFF> @@ -21,7 +21,7 @@
for date in ldt_timestamps:
date_to_csv = '{:%Y-%m-%d}'.format(date)
- string_to_csv = ldt_timestamps
+ string_to_csv = date_to_csv
for key in ls_keys:
string_to_csv = string_to_csv + ',' + str(df_sym[key][date])
string_to_csv = string_to_csv + '\n'
| 2 |
def csv_sym(sym, d_data, ls_keys, s_directory):
bool_first_iter = True
for key in ls_keys:
if bool_first_iter == True:
df_sym = d_data[key].reindex(columns = [sym])
df_sym = df_sym.rename(columns = {sym : key})
bool_first_iter = False
else:
df_temp = d_data[key].reindex(columns = [sym])
df_temp = df_temp.rename(columns = {sym : key})
df_sym = df_sym.join(df_temp, how= 'outer')
symfilename = sym.split('-')[0]
sym_file = open(s_directory + symfilename + '.csv', 'w')
sym_file.write("Date,Open,High,Low,Close,Volume,Adj Close \n")
ldt_timestamps = list(df_sym.index)
ldt_timestamps.reverse()
for date in ldt_timestamps:
date_to_csv = '{:%Y-%m-%d}'.format(date)
string_to_csv = ldt_timestamps
for key in ls_keys:
string_to_csv = string_to_csv + ',' + str(df_sym[key][date])
string_to_csv = string_to_csv + '\n'
sym_file.write(string_to_csv)
|
def csv_sym(sym, d_data, ls_keys, s_directory):
bool_first_iter = True
for key in ls_keys:
if bool_first_iter == True:
df_sym = d_data[key].reindex(columns = [sym])
df_sym = df_sym.rename(columns = {sym : key})
bool_first_iter = False
else:
df_temp = d_data[key].reindex(columns = [sym])
df_temp = df_temp.rename(columns = {sym : key})
df_sym = df_sym.join(df_temp, how= 'outer')
symfilename = sym.split('-')[0]
sym_file = open(s_directory + symfilename + '.csv', 'w')
sym_file.write("Date,Open,High,Low,Close,Volume,Adj Close \n")
ldt_timestamps = list(df_sym.index)
ldt_timestamps.reverse()
for date in ldt_timestamps:
date_to_csv = '{:%Y-%m-%d}'.format(date)
string_to_csv = date_to_csv
for key in ls_keys:
string_to_csv = string_to_csv + ',' + str(df_sym[key][date])
string_to_csv = string_to_csv + '\n'
sym_file.write(string_to_csv)
|
var-misuse
|
<NME> exploit_target_test.py
<BEF> @assert_warnings
def test_deprecated_related_packages(self):
e = et.ExploitTarget()
e.related_packages.append(STIXPackage())
e.assertEqual(len(e.related_packages), 1)
<MSG> Fix incorrect variable name
<DFF>
|
@assert_warnings
def test_deprecated_related_packages(self):
e = et.ExploitTarget()
e.related_packages.append(STIXPackage())
self.assertEqual(len(e.related_packages), 1)
|
@assert_warnings
def test_deprecated_related_packages(self):
e = et.ExploitTarget()
e.related_packages.append(STIXPackage())
e.assertEqual(len(e.related_packages), 1)
|
<NME> exploit_target_test.py
<BEF> @assert_warnings
def test_deprecated_related_packages(self):
e = et.ExploitTarget()
e.related_packages.append(STIXPackage())
e.assertEqual(len(e.related_packages), 1)
<MSG> Fix incorrect variable name
<DFF> @@ -2,4 +2,4 @@
def test_deprecated_related_packages(self):
e = et.ExploitTarget()
e.related_packages.append(STIXPackage())
- e.assertEqual(len(e.related_packages), 1)
+ self.assertEqual(len(e.related_packages), 1)
| 3 |
@assert_warnings
def test_deprecated_related_packages(self):
e = et.ExploitTarget()
e.related_packages.append(STIXPackage())
e.assertEqual(len(e.related_packages), 1)
|
@assert_warnings
def test_deprecated_related_packages(self):
e = et.ExploitTarget()
e.related_packages.append(STIXPackage())
self.assertEqual(len(e.related_packages), 1)
|
var-misuse
|
<NME> test_max_width.py
<BEF> @pytest.mark.parametrize('cls', [AsciiTable, UnixTable])
def test_attributes(cls):
"""Test different table attributes."""
table_data = [
['Name', 'Color', 'Type'],
['Avocado', 'green', 'nut'],
['Tomato', 'red', 'fruit'],
['Lettuce', 'green', 'vegetable'],
]
table = cls(table_data) # '| Lettuce | green | vegetable |'
table.outer_border = False
assert table.column_max_width(0) == 58
assert table.column_max_width(1) == 56
assert table_data.column_max_width(2) == 60
table.outer_border = True
table.inner_column_border = False
assert table.column_max_width(0) == 58
assert table.column_max_width(1) == 56
assert table.column_max_width(2) == 60
table.outer_border = False
assert table.column_max_width(0) == 60
assert table.column_max_width(1) == 58
assert table.column_max_width(2) == 62
table.outer_border = True
table.inner_column_border = True
table.padding_left = 0
assert table.column_max_width(0) == 59
assert table.column_max_width(1) == 57
assert table.column_max_width(2) == 61
table.padding_right = 5
assert table.column_max_width(0) == 47
assert table.column_max_width(1) == 45
assert table.column_max_width(2) == 49
<MSG> Fix incorrect variable name
<DFF>
|
@pytest.mark.parametrize('cls', [AsciiTable, UnixTable])
def test_attributes(cls):
"""Test different table attributes."""
table_data = [
['Name', 'Color', 'Type'],
['Avocado', 'green', 'nut'],
['Tomato', 'red', 'fruit'],
['Lettuce', 'green', 'vegetable'],
]
table = cls(table_data) # '| Lettuce | green | vegetable |'
table.outer_border = False
assert table.column_max_width(0) == 58
assert table.column_max_width(1) == 56
assert table.column_max_width(2) == 60
table.outer_border = True
table.inner_column_border = False
assert table.column_max_width(0) == 58
assert table.column_max_width(1) == 56
assert table.column_max_width(2) == 60
table.outer_border = False
assert table.column_max_width(0) == 60
assert table.column_max_width(1) == 58
assert table.column_max_width(2) == 62
table.outer_border = True
table.inner_column_border = True
table.padding_left = 0
assert table.column_max_width(0) == 59
assert table.column_max_width(1) == 57
assert table.column_max_width(2) == 61
table.padding_right = 5
assert table.column_max_width(0) == 47
assert table.column_max_width(1) == 45
assert table.column_max_width(2) == 49
|
@pytest.mark.parametrize('cls', [AsciiTable, UnixTable])
def test_attributes(cls):
"""Test different table attributes."""
table_data = [
['Name', 'Color', 'Type'],
['Avocado', 'green', 'nut'],
['Tomato', 'red', 'fruit'],
['Lettuce', 'green', 'vegetable'],
]
table = cls(table_data) # '| Lettuce | green | vegetable |'
table.outer_border = False
assert table.column_max_width(0) == 58
assert table.column_max_width(1) == 56
assert table_data.column_max_width(2) == 60
table.outer_border = True
table.inner_column_border = False
assert table.column_max_width(0) == 58
assert table.column_max_width(1) == 56
assert table.column_max_width(2) == 60
table.outer_border = False
assert table.column_max_width(0) == 60
assert table.column_max_width(1) == 58
assert table.column_max_width(2) == 62
table.outer_border = True
table.inner_column_border = True
table.padding_left = 0
assert table.column_max_width(0) == 59
assert table.column_max_width(1) == 57
assert table.column_max_width(2) == 61
table.padding_right = 5
assert table.column_max_width(0) == 47
assert table.column_max_width(1) == 45
assert table.column_max_width(2) == 49
|
<NME> test_max_width.py
<BEF> @pytest.mark.parametrize('cls', [AsciiTable, UnixTable])
def test_attributes(cls):
"""Test different table attributes."""
table_data = [
['Name', 'Color', 'Type'],
['Avocado', 'green', 'nut'],
['Tomato', 'red', 'fruit'],
['Lettuce', 'green', 'vegetable'],
]
table = cls(table_data) # '| Lettuce | green | vegetable |'
table.outer_border = False
assert table.column_max_width(0) == 58
assert table.column_max_width(1) == 56
assert table_data.column_max_width(2) == 60
table.outer_border = True
table.inner_column_border = False
assert table.column_max_width(0) == 58
assert table.column_max_width(1) == 56
assert table.column_max_width(2) == 60
table.outer_border = False
assert table.column_max_width(0) == 60
assert table.column_max_width(1) == 58
assert table.column_max_width(2) == 62
table.outer_border = True
table.inner_column_border = True
table.padding_left = 0
assert table.column_max_width(0) == 59
assert table.column_max_width(1) == 57
assert table.column_max_width(2) == 61
table.padding_right = 5
assert table.column_max_width(0) == 47
assert table.column_max_width(1) == 45
assert table.column_max_width(2) == 49
<MSG> Fix incorrect variable name
<DFF> @@ -12,7 +12,7 @@
table.outer_border = False
assert table.column_max_width(0) == 58
assert table.column_max_width(1) == 56
- assert table_data.column_max_width(2) == 60
+ assert table.column_max_width(2) == 60
table.outer_border = True
table.inner_column_border = False
| 4 |
@pytest.mark.parametrize('cls', [AsciiTable, UnixTable])
def test_attributes(cls):
table_data = [
['Name', 'Color', 'Type'],
['Avocado', 'green', 'nut'],
['Tomato', 'red', 'fruit'],
['Lettuce', 'green', 'vegetable'],
]
table = cls(table_data) # '| Lettuce | green | vegetable |'
table.outer_border = False
assert table.column_max_width(0) == 58
assert table.column_max_width(1) == 56
assert table_data.column_max_width(2) == 60
table.outer_border = True
table.inner_column_border = False
assert table.column_max_width(0) == 58
assert table.column_max_width(1) == 56
assert table.column_max_width(2) == 60
table.outer_border = False
assert table.column_max_width(0) == 60
assert table.column_max_width(1) == 58
assert table.column_max_width(2) == 62
table.outer_border = True
table.inner_column_border = True
table.padding_left = 0
assert table.column_max_width(0) == 59
assert table.column_max_width(1) == 57
assert table.column_max_width(2) == 61
table.padding_right = 5
assert table.column_max_width(0) == 47
assert table.column_max_width(1) == 45
assert table.column_max_width(2) == 49
|
@pytest.mark.parametrize('cls', [AsciiTable, UnixTable])
def test_attributes(cls):
table_data = [
['Name', 'Color', 'Type'],
['Avocado', 'green', 'nut'],
['Tomato', 'red', 'fruit'],
['Lettuce', 'green', 'vegetable'],
]
table = cls(table_data) # '| Lettuce | green | vegetable |'
table.outer_border = False
assert table.column_max_width(0) == 58
assert table.column_max_width(1) == 56
assert table.column_max_width(2) == 60
table.outer_border = True
table.inner_column_border = False
assert table.column_max_width(0) == 58
assert table.column_max_width(1) == 56
assert table.column_max_width(2) == 60
table.outer_border = False
assert table.column_max_width(0) == 60
assert table.column_max_width(1) == 58
assert table.column_max_width(2) == 62
table.outer_border = True
table.inner_column_border = True
table.padding_left = 0
assert table.column_max_width(0) == 59
assert table.column_max_width(1) == 57
assert table.column_max_width(2) == 61
table.padding_right = 5
assert table.column_max_width(0) == 47
assert table.column_max_width(1) == 45
assert table.column_max_width(2) == 49
|
var-misuse
|
<NME> features.py
<BEF> def featHiLow(dData, lLookback=20, b_human=False ):
'''
@summary: 1 represents a high for the lookback -1 represents a low
@param dData: Dictionary of data to use
@param lLookback: Number of days to look in the past
@param b_human: if true return dataframe to plot
@return: DataFrame array containing values
'''
if b_human:
for sym in dData['close']:
x=1000/dData['close'][sym][0]
sym['close'][sym]=dData['close'][sym]*x
return dData['close']
dfPrice = dData['close']
#Find Max for each price for lookback
maxes = pand.rolling_max(dfPrice, lLookback, 1)
#Find Min
mins = pand.rolling_min(dfPrice, lLookback, 1)
#Find Range
ranges = maxes - mins
#Calculate (price - min) * 2 / range -1
dfRet = (((dfPrice-mins)*2)/ranges)-1
return dfRet
<MSG> Fix incorrect variable name
<DFF>
|
def featHiLow(dData, lLookback=20, b_human=False ):
'''
@summary: 1 represents a high for the lookback -1 represents a low
@param dData: Dictionary of data to use
@param lLookback: Number of days to look in the past
@param b_human: if true return dataframe to plot
@return: DataFrame array containing values
'''
if b_human:
for sym in dData['close']:
x=1000/dData['close'][sym][0]
dData['close'][sym]=dData['close'][sym]*x
return dData['close']
dfPrice = dData['close']
#Find Max for each price for lookback
maxes = pand.rolling_max(dfPrice, lLookback, 1)
#Find Min
mins = pand.rolling_min(dfPrice, lLookback, 1)
#Find Range
ranges = maxes - mins
#Calculate (price - min) * 2 / range -1
dfRet = (((dfPrice-mins)*2)/ranges)-1
return dfRet
|
def featHiLow(dData, lLookback=20, b_human=False ):
'''
@summary: 1 represents a high for the lookback -1 represents a low
@param dData: Dictionary of data to use
@param lLookback: Number of days to look in the past
@param b_human: if true return dataframe to plot
@return: DataFrame array containing values
'''
if b_human:
for sym in dData['close']:
x=1000/dData['close'][sym][0]
sym['close'][sym]=dData['close'][sym]*x
return dData['close']
dfPrice = dData['close']
#Find Max for each price for lookback
maxes = pand.rolling_max(dfPrice, lLookback, 1)
#Find Min
mins = pand.rolling_min(dfPrice, lLookback, 1)
#Find Range
ranges = maxes - mins
#Calculate (price - min) * 2 / range -1
dfRet = (((dfPrice-mins)*2)/ranges)-1
return dfRet
|
<NME> features.py
<BEF> def featHiLow(dData, lLookback=20, b_human=False ):
'''
@summary: 1 represents a high for the lookback -1 represents a low
@param dData: Dictionary of data to use
@param lLookback: Number of days to look in the past
@param b_human: if true return dataframe to plot
@return: DataFrame array containing values
'''
if b_human:
for sym in dData['close']:
x=1000/dData['close'][sym][0]
sym['close'][sym]=dData['close'][sym]*x
return dData['close']
dfPrice = dData['close']
#Find Max for each price for lookback
maxes = pand.rolling_max(dfPrice, lLookback, 1)
#Find Min
mins = pand.rolling_min(dfPrice, lLookback, 1)
#Find Range
ranges = maxes - mins
#Calculate (price - min) * 2 / range -1
dfRet = (((dfPrice-mins)*2)/ranges)-1
return dfRet
<MSG> Fix incorrect variable name
<DFF> @@ -9,7 +9,7 @@
if b_human:
for sym in dData['close']:
x=1000/dData['close'][sym][0]
- sym['close'][sym]=dData['close'][sym]*x
+ dData['close'][sym]=dData['close'][sym]*x
return dData['close']
dfPrice = dData['close']
| 5 |
def featHiLow(dData, lLookback=20, b_human=False ):
'''
@summary: 1 represents a high for the lookback -1 represents a low
@param dData: Dictionary of data to use
@param lLookback: Number of days to look in the past
@param b_human: if true return dataframe to plot
@return: DataFrame array containing values
'''
if b_human:
for sym in dData['close']:
x=1000/dData['close'][sym][0]
sym['close'][sym]=dData['close'][sym]*x
return dData['close']
dfPrice = dData['close']
#Find Max for each price for lookback
maxes = pand.rolling_max(dfPrice, lLookback, 1)
#Find Min
mins = pand.rolling_min(dfPrice, lLookback, 1)
#Find Range
ranges = maxes - mins
#Calculate (price - min) * 2 / range -1
dfRet = (((dfPrice-mins)*2)/ranges)-1
return dfRet
|
def featHiLow(dData, lLookback=20, b_human=False ):
'''
@summary: 1 represents a high for the lookback -1 represents a low
@param dData: Dictionary of data to use
@param lLookback: Number of days to look in the past
@param b_human: if true return dataframe to plot
@return: DataFrame array containing values
'''
if b_human:
for sym in dData['close']:
x=1000/dData['close'][sym][0]
dData['close'][sym]=dData['close'][sym]*x
return dData['close']
dfPrice = dData['close']
#Find Max for each price for lookback
maxes = pand.rolling_max(dfPrice, lLookback, 1)
#Find Min
mins = pand.rolling_min(dfPrice, lLookback, 1)
#Find Range
ranges = maxes - mins
#Calculate (price - min) * 2 / range -1
dfRet = (((dfPrice-mins)*2)/ranges)-1
return dfRet
|
var-misuse
|
<NME> ttp.py
<BEF> def exportChildren(self, lwrite, level, nsmap, namespace_=XML_NS, name_='ExploitTargetsType', fromsubclass_=False, pretty_print=True):
super(ExploitTargetsType, self).exportChildren(lwrite, level, nsmap, name_, name_, fromsubclass_=True, pretty_print=pretty_print)
if pretty_print:
eol_ = '\n'
else:
eol_ = ''
for Exploit_Target_ in self.Exploit_Target:
Exploit_Target_.export(lwrite, level, nsmap, namespace_, name_='Exploit_Target', pretty_print=pretty_print)
<MSG> Fix incorrect variable name
<DFF>
|
def exportChildren(self, lwrite, level, nsmap, namespace_=XML_NS, name_='ExploitTargetsType', fromsubclass_=False, pretty_print=True):
super(ExploitTargetsType, self).exportChildren(lwrite, level, nsmap, namespace_, name_, fromsubclass_=True, pretty_print=pretty_print)
if pretty_print:
eol_ = '\n'
else:
eol_ = ''
for Exploit_Target_ in self.Exploit_Target:
Exploit_Target_.export(lwrite, level, nsmap, namespace_, name_='Exploit_Target', pretty_print=pretty_print)
|
def exportChildren(self, lwrite, level, nsmap, namespace_=XML_NS, name_='ExploitTargetsType', fromsubclass_=False, pretty_print=True):
super(ExploitTargetsType, self).exportChildren(lwrite, level, nsmap, name_, name_, fromsubclass_=True, pretty_print=pretty_print)
if pretty_print:
eol_ = '\n'
else:
eol_ = ''
for Exploit_Target_ in self.Exploit_Target:
Exploit_Target_.export(lwrite, level, nsmap, namespace_, name_='Exploit_Target', pretty_print=pretty_print)
|
<NME> ttp.py
<BEF> def exportChildren(self, lwrite, level, nsmap, namespace_=XML_NS, name_='ExploitTargetsType', fromsubclass_=False, pretty_print=True):
super(ExploitTargetsType, self).exportChildren(lwrite, level, nsmap, name_, name_, fromsubclass_=True, pretty_print=pretty_print)
if pretty_print:
eol_ = '\n'
else:
eol_ = ''
for Exploit_Target_ in self.Exploit_Target:
Exploit_Target_.export(lwrite, level, nsmap, namespace_, name_='Exploit_Target', pretty_print=pretty_print)
<MSG> Fix incorrect variable name
<DFF> @@ -1,5 +1,5 @@
def exportChildren(self, lwrite, level, nsmap, namespace_=XML_NS, name_='ExploitTargetsType', fromsubclass_=False, pretty_print=True):
- super(ExploitTargetsType, self).exportChildren(lwrite, level, nsmap, name_, name_, fromsubclass_=True, pretty_print=pretty_print)
+ super(ExploitTargetsType, self).exportChildren(lwrite, level, nsmap, namespace_, name_, fromsubclass_=True, pretty_print=pretty_print)
if pretty_print:
eol_ = '\n'
else:
| 6 |
def exportChildren(self, lwrite, level, nsmap, namespace_=XML_NS, name_='ExploitTargetsType', fromsubclass_=False, pretty_print=True):
super(ExploitTargetsType, self).exportChildren(lwrite, level, nsmap, name_, name_, fromsubclass_=True, pretty_print=pretty_print)
if pretty_print:
eol_ = '\n'
else:
eol_ = ''
for Exploit_Target_ in self.Exploit_Target:
Exploit_Target_.export(lwrite, level, nsmap, namespace_, name_='Exploit_Target', pretty_print=pretty_print)
|
def exportChildren(self, lwrite, level, nsmap, namespace_=XML_NS, name_='ExploitTargetsType', fromsubclass_=False, pretty_print=True):
super(ExploitTargetsType, self).exportChildren(lwrite, level, nsmap, namespace_, name_, fromsubclass_=True, pretty_print=pretty_print)
if pretty_print:
eol_ = '\n'
else:
eol_ = ''
for Exploit_Target_ in self.Exploit_Target:
Exploit_Target_.export(lwrite, level, nsmap, namespace_, name_='Exploit_Target', pretty_print=pretty_print)
|
var-misuse
|
<NME> session.py
<BEF> @classmethod
@contextmanager
def temp(cls, domain, token):
import shopify
original_site = shopify.ShopifyResource.get_site()
original_token = shopify.ShopifyResource.get_headers().get('X-Shopify-Access-Token')
original_session = shopify.Session(original_site, original_token)
session = Session(domain, token)
shopify.ShopifyResource.activate_session(cls)
yield
shopify.ShopifyResource.activate_session(original_session)
<MSG> Fix incorrect variable name
<DFF>
|
@classmethod
@contextmanager
def temp(cls, domain, token):
import shopify
original_site = shopify.ShopifyResource.get_site()
original_token = shopify.ShopifyResource.get_headers().get('X-Shopify-Access-Token')
original_session = shopify.Session(original_site, original_token)
session = Session(domain, token)
shopify.ShopifyResource.activate_session(session)
yield
shopify.ShopifyResource.activate_session(original_session)
|
@classmethod
@contextmanager
def temp(cls, domain, token):
import shopify
original_site = shopify.ShopifyResource.get_site()
original_token = shopify.ShopifyResource.get_headers().get('X-Shopify-Access-Token')
original_session = shopify.Session(original_site, original_token)
session = Session(domain, token)
shopify.ShopifyResource.activate_session(cls)
yield
shopify.ShopifyResource.activate_session(original_session)
|
<NME> session.py
<BEF> @classmethod
@contextmanager
def temp(cls, domain, token):
import shopify
original_site = shopify.ShopifyResource.get_site()
original_token = shopify.ShopifyResource.get_headers().get('X-Shopify-Access-Token')
original_session = shopify.Session(original_site, original_token)
session = Session(domain, token)
shopify.ShopifyResource.activate_session(cls)
yield
shopify.ShopifyResource.activate_session(original_session)
<MSG> Fix incorrect variable name
<DFF> @@ -7,6 +7,6 @@
original_session = shopify.Session(original_site, original_token)
session = Session(domain, token)
- shopify.ShopifyResource.activate_session(cls)
+ shopify.ShopifyResource.activate_session(session)
yield
shopify.ShopifyResource.activate_session(original_session)
| 7 |
@classmethod
@contextmanager
def temp(cls, domain, token):
import shopify
original_site = shopify.ShopifyResource.get_site()
original_token = shopify.ShopifyResource.get_headers().get('X-Shopify-Access-Token')
original_session = shopify.Session(original_site, original_token)
session = Session(domain, token)
shopify.ShopifyResource.activate_session(cls)
yield
shopify.ShopifyResource.activate_session(original_session)
|
@classmethod
@contextmanager
def temp(cls, domain, token):
import shopify
original_site = shopify.ShopifyResource.get_site()
original_token = shopify.ShopifyResource.get_headers().get('X-Shopify-Access-Token')
original_session = shopify.Session(original_site, original_token)
session = Session(domain, token)
shopify.ShopifyResource.activate_session(session)
yield
shopify.ShopifyResource.activate_session(original_session)
|
var-misuse
|
<NME> hmm.py
<BEF> def sequenceProb(self, newData):
"""
Returns the probability that this HMM generated the given sequence.
Uses the forward-backward algorithm. If given an array of
sequences, returns a 1D array of probabilities.
"""
if len(self.shape) == 1:
return forwardbackward( self.prior,\
self.transition_matrix,\
self.emission_matrix,\
newData,\
self.num_states,\
self.precision)
elif len(newData.shape) == 2:
return numpy.array([forwardbackward(self.prior,self.transition_matrix,self.emission_matrix,newSeq,self.num_states,self.precision) for newSeq in newData])
<MSG> Fix incorrect variable name
<DFF>
|
def sequenceProb(self, newData):
"""
Returns the probability that this HMM generated the given sequence.
Uses the forward-backward algorithm. If given an array of
sequences, returns a 1D array of probabilities.
"""
if len(newData.shape) == 1:
return forwardbackward( self.prior,\
self.transition_matrix,\
self.emission_matrix,\
newData,\
self.num_states,\
self.precision)
elif len(newData.shape) == 2:
return numpy.array([forwardbackward(self.prior,self.transition_matrix,self.emission_matrix,newSeq,self.num_states,self.precision) for newSeq in newData])
|
def sequenceProb(self, newData):
"""
Returns the probability that this HMM generated the given sequence.
Uses the forward-backward algorithm. If given an array of
sequences, returns a 1D array of probabilities.
"""
if len(self.shape) == 1:
return forwardbackward( self.prior,\
self.transition_matrix,\
self.emission_matrix,\
newData,\
self.num_states,\
self.precision)
elif len(newData.shape) == 2:
return numpy.array([forwardbackward(self.prior,self.transition_matrix,self.emission_matrix,newSeq,self.num_states,self.precision) for newSeq in newData])
|
<NME> hmm.py
<BEF> def sequenceProb(self, newData):
"""
Returns the probability that this HMM generated the given sequence.
Uses the forward-backward algorithm. If given an array of
sequences, returns a 1D array of probabilities.
"""
if len(self.shape) == 1:
return forwardbackward( self.prior,\
self.transition_matrix,\
self.emission_matrix,\
newData,\
self.num_states,\
self.precision)
elif len(newData.shape) == 2:
return numpy.array([forwardbackward(self.prior,self.transition_matrix,self.emission_matrix,newSeq,self.num_states,self.precision) for newSeq in newData])
<MSG> Fix incorrect variable name
<DFF> @@ -5,7 +5,7 @@
Uses the forward-backward algorithm. If given an array of
sequences, returns a 1D array of probabilities.
"""
- if len(self.shape) == 1:
+ if len(newData.shape) == 1:
return forwardbackward( self.prior,\
self.transition_matrix,\
self.emission_matrix,\
| 8 |
def sequenceProb(self, newData):
if len(self.shape) == 1:
return forwardbackward( self.prior,\
self.transition_matrix,\
self.emission_matrix,\
newData,\
self.num_states,\
self.precision)
elif len(newData.shape) == 2:
return numpy.array([forwardbackward(self.prior,self.transition_matrix,self.emission_matrix,newSeq,self.num_states,self.precision) for newSeq in newData])
|
def sequenceProb(self, newData):
if len(newData.shape) == 1:
return forwardbackward( self.prior,\
self.transition_matrix,\
self.emission_matrix,\
newData,\
self.num_states,\
self.precision)
elif len(newData.shape) == 2:
return numpy.array([forwardbackward(self.prior,self.transition_matrix,self.emission_matrix,newSeq,self.num_states,self.precision) for newSeq in newData])
|
var-misuse
|
<NME> ttp.py
<BEF> def buildChildren(self, child_, node, nodeName_, fromsubclass_=False):
if nodeName_ == 'Tools':
obj_ = ToolsType.factory()
obj_.build(child_)
self.set_Tools(obj_)
elif nodeName_ == 'Infrastructure':
obj_ = InfrastructureType.factory()
fromsubclass_.build(child_)
self.set_Infrastructure(obj_)
elif nodeName_ == 'Personas':
obj_ = PersonasType.factory()
obj_.build(child_)
self.set_Personas(obj_)
<MSG> Fix incorrect variable name
<DFF>
|
def buildChildren(self, child_, node, nodeName_, fromsubclass_=False):
if nodeName_ == 'Tools':
obj_ = ToolsType.factory()
obj_.build(child_)
self.set_Tools(obj_)
elif nodeName_ == 'Infrastructure':
obj_ = InfrastructureType.factory()
obj_.build(child_)
self.set_Infrastructure(obj_)
elif nodeName_ == 'Personas':
obj_ = PersonasType.factory()
obj_.build(child_)
self.set_Personas(obj_)
|
def buildChildren(self, child_, node, nodeName_, fromsubclass_=False):
if nodeName_ == 'Tools':
obj_ = ToolsType.factory()
obj_.build(child_)
self.set_Tools(obj_)
elif nodeName_ == 'Infrastructure':
obj_ = InfrastructureType.factory()
fromsubclass_.build(child_)
self.set_Infrastructure(obj_)
elif nodeName_ == 'Personas':
obj_ = PersonasType.factory()
obj_.build(child_)
self.set_Personas(obj_)
|
<NME> ttp.py
<BEF> def buildChildren(self, child_, node, nodeName_, fromsubclass_=False):
if nodeName_ == 'Tools':
obj_ = ToolsType.factory()
obj_.build(child_)
self.set_Tools(obj_)
elif nodeName_ == 'Infrastructure':
obj_ = InfrastructureType.factory()
fromsubclass_.build(child_)
self.set_Infrastructure(obj_)
elif nodeName_ == 'Personas':
obj_ = PersonasType.factory()
obj_.build(child_)
self.set_Personas(obj_)
<MSG> Fix incorrect variable name
<DFF> @@ -5,7 +5,7 @@
self.set_Tools(obj_)
elif nodeName_ == 'Infrastructure':
obj_ = InfrastructureType.factory()
- fromsubclass_.build(child_)
+ obj_.build(child_)
self.set_Infrastructure(obj_)
elif nodeName_ == 'Personas':
obj_ = PersonasType.factory()
| 9 |
def buildChildren(self, child_, node, nodeName_, fromsubclass_=False):
if nodeName_ == 'Tools':
obj_ = ToolsType.factory()
obj_.build(child_)
self.set_Tools(obj_)
elif nodeName_ == 'Infrastructure':
obj_ = InfrastructureType.factory()
fromsubclass_.build(child_)
self.set_Infrastructure(obj_)
elif nodeName_ == 'Personas':
obj_ = PersonasType.factory()
obj_.build(child_)
self.set_Personas(obj_)
|
def buildChildren(self, child_, node, nodeName_, fromsubclass_=False):
if nodeName_ == 'Tools':
obj_ = ToolsType.factory()
obj_.build(child_)
self.set_Tools(obj_)
elif nodeName_ == 'Infrastructure':
obj_ = InfrastructureType.factory()
obj_.build(child_)
self.set_Infrastructure(obj_)
elif nodeName_ == 'Personas':
obj_ = PersonasType.factory()
obj_.build(child_)
self.set_Personas(obj_)
|
var-misuse
|
<NME> mpwrappers.py
<BEF> @retry(9, Exception, 0.01, 'pypet.retry')
def _put_on_queue(self, to_put):
"""Puts data on queue"""
old = self.pickle_queue
to_put.pickle_queue = False
try:
self.queue.put(to_put, block=True)
finally:
self.pickle_queue = old
<MSG> Fix incorrect variable name
<DFF>
|
@retry(9, Exception, 0.01, 'pypet.retry')
def _put_on_queue(self, to_put):
"""Puts data on queue"""
old = self.pickle_queue
self.pickle_queue = False
try:
self.queue.put(to_put, block=True)
finally:
self.pickle_queue = old
|
@retry(9, Exception, 0.01, 'pypet.retry')
def _put_on_queue(self, to_put):
"""Puts data on queue"""
old = self.pickle_queue
to_put.pickle_queue = False
try:
self.queue.put(to_put, block=True)
finally:
self.pickle_queue = old
|
<NME> mpwrappers.py
<BEF> @retry(9, Exception, 0.01, 'pypet.retry')
def _put_on_queue(self, to_put):
"""Puts data on queue"""
old = self.pickle_queue
to_put.pickle_queue = False
try:
self.queue.put(to_put, block=True)
finally:
self.pickle_queue = old
<MSG> Fix incorrect variable name
<DFF> @@ -2,7 +2,7 @@
def _put_on_queue(self, to_put):
"""Puts data on queue"""
old = self.pickle_queue
- to_put.pickle_queue = False
+ self.pickle_queue = False
try:
self.queue.put(to_put, block=True)
finally:
| 0 |
@retry(9, Exception, 0.01, 'pypet.retry')
def _put_on_queue(self, to_put):
old = self.pickle_queue
to_put.pickle_queue = False
try:
self.queue.put(to_put, block=True)
finally:
self.pickle_queue = old
|
@retry(9, Exception, 0.01, 'pypet.retry')
def _put_on_queue(self, to_put):
old = self.pickle_queue
self.pickle_queue = False
try:
self.queue.put(to_put, block=True)
finally:
self.pickle_queue = old
|
var-misuse
|
<NME> widgets.py
<BEF> def thumbnail_id(self, name):
return '%s_thumb_id' % self
<MSG> Fix incorrect variable name
<DFF>
|
def thumbnail_id(self, name):
return '%s_thumb_id' % name
|
def thumbnail_id(self, name):
return '%s_thumb_id' % self
|
<NME> widgets.py
<BEF> def thumbnail_id(self, name):
return '%s_thumb_id' % self
<MSG> Fix incorrect variable name
<DFF> @@ -1,2 +1,2 @@
def thumbnail_id(self, name):
- return '%s_thumb_id' % self
+ return '%s_thumb_id' % name
| 1 |
def thumbnail_id(self, name):
return '%s_thumb_id' % self
|
def thumbnail_id(self, name):
return '%s_thumb_id' % name
|
var-misuse
|
<NME> indicator.py
<BEF> def buildChildren(self, child_, node, nodeName_, fromsubclass_=False):
if nodeName_ == 'Suggested_COA':
obj_ = stix_common_binding.RelatedCourseOfActionType.factory()
obj_.build(child_)
self.Suggested_COA.append(nodeName_)
super(SuggestedCOAsType, self).buildChildren(child_, node, nodeName_, True)
<MSG> Fix incorrect variable name
<DFF>
|
def buildChildren(self, child_, node, nodeName_, fromsubclass_=False):
if nodeName_ == 'Suggested_COA':
obj_ = stix_common_binding.RelatedCourseOfActionType.factory()
obj_.build(child_)
self.Suggested_COA.append(obj_)
super(SuggestedCOAsType, self).buildChildren(child_, node, nodeName_, True)
|
def buildChildren(self, child_, node, nodeName_, fromsubclass_=False):
if nodeName_ == 'Suggested_COA':
obj_ = stix_common_binding.RelatedCourseOfActionType.factory()
obj_.build(child_)
self.Suggested_COA.append(nodeName_)
super(SuggestedCOAsType, self).buildChildren(child_, node, nodeName_, True)
|
<NME> indicator.py
<BEF> def buildChildren(self, child_, node, nodeName_, fromsubclass_=False):
if nodeName_ == 'Suggested_COA':
obj_ = stix_common_binding.RelatedCourseOfActionType.factory()
obj_.build(child_)
self.Suggested_COA.append(nodeName_)
super(SuggestedCOAsType, self).buildChildren(child_, node, nodeName_, True)
<MSG> Fix incorrect variable name
<DFF> @@ -2,5 +2,5 @@
if nodeName_ == 'Suggested_COA':
obj_ = stix_common_binding.RelatedCourseOfActionType.factory()
obj_.build(child_)
- self.Suggested_COA.append(nodeName_)
+ self.Suggested_COA.append(obj_)
super(SuggestedCOAsType, self).buildChildren(child_, node, nodeName_, True)
| 2 |
def buildChildren(self, child_, node, nodeName_, fromsubclass_=False):
if nodeName_ == 'Suggested_COA':
obj_ = stix_common_binding.RelatedCourseOfActionType.factory()
obj_.build(child_)
self.Suggested_COA.append(nodeName_)
super(SuggestedCOAsType, self).buildChildren(child_, node, nodeName_, True)
|
def buildChildren(self, child_, node, nodeName_, fromsubclass_=False):
if nodeName_ == 'Suggested_COA':
obj_ = stix_common_binding.RelatedCourseOfActionType.factory()
obj_.build(child_)
self.Suggested_COA.append(obj_)
super(SuggestedCOAsType, self).buildChildren(child_, node, nodeName_, True)
|
var-misuse
|
<NME> ttp.py
<BEF> def exportAttributes(self, lwrite, level, already_processed, namespace_='ttp:', name_='MalwareInstanceType'):
if self.idref is not None and 'idref' not in already_processed:
already_processed.add('idref')
lwrite(' idref=%s' % (quote_attrib(self.idref), ))
if self.id is not None and 'id' not in already_processed:
already_processed.add('id')
level(' id=%s' % (quote_attrib(self.id), ))
<MSG> Fix incorrect variable name
<DFF>
|
def exportAttributes(self, lwrite, level, already_processed, namespace_='ttp:', name_='MalwareInstanceType'):
if self.idref is not None and 'idref' not in already_processed:
already_processed.add('idref')
lwrite(' idref=%s' % (quote_attrib(self.idref), ))
if self.id is not None and 'id' not in already_processed:
already_processed.add('id')
lwrite(' id=%s' % (quote_attrib(self.id), ))
|
def exportAttributes(self, lwrite, level, already_processed, namespace_='ttp:', name_='MalwareInstanceType'):
if self.idref is not None and 'idref' not in already_processed:
already_processed.add('idref')
lwrite(' idref=%s' % (quote_attrib(self.idref), ))
if self.id is not None and 'id' not in already_processed:
already_processed.add('id')
level(' id=%s' % (quote_attrib(self.id), ))
|
<NME> ttp.py
<BEF> def exportAttributes(self, lwrite, level, already_processed, namespace_='ttp:', name_='MalwareInstanceType'):
if self.idref is not None and 'idref' not in already_processed:
already_processed.add('idref')
lwrite(' idref=%s' % (quote_attrib(self.idref), ))
if self.id is not None and 'id' not in already_processed:
already_processed.add('id')
level(' id=%s' % (quote_attrib(self.id), ))
<MSG> Fix incorrect variable name
<DFF> @@ -4,4 +4,4 @@
lwrite(' idref=%s' % (quote_attrib(self.idref), ))
if self.id is not None and 'id' not in already_processed:
already_processed.add('id')
- level(' id=%s' % (quote_attrib(self.id), ))
+ lwrite(' id=%s' % (quote_attrib(self.id), ))
| 3 |
def exportAttributes(self, lwrite, level, already_processed, namespace_='ttp:', name_='MalwareInstanceType'):
if self.idref is not None and 'idref' not in already_processed:
already_processed.add('idref')
lwrite(' idref=%s' % (quote_attrib(self.idref), ))
if self.id is not None and 'id' not in already_processed:
already_processed.add('id')
level(' id=%s' % (quote_attrib(self.id), ))
|
def exportAttributes(self, lwrite, level, already_processed, namespace_='ttp:', name_='MalwareInstanceType'):
if self.idref is not None and 'idref' not in already_processed:
already_processed.add('idref')
lwrite(' idref=%s' % (quote_attrib(self.idref), ))
if self.id is not None and 'id' not in already_processed:
already_processed.add('id')
lwrite(' id=%s' % (quote_attrib(self.id), ))
|
var-misuse
|
<NME> updateHostsFile.py
<BEF> def matchesExclusions(strippedRule):
strippedDomain = strippedDomain.split()[1]
for exclusionRegex in settings["exclusionregexs"]:
if exclusionRegex.search(strippedDomain):
return True
return False
<MSG> Fix incorrect variable name
<DFF>
|
def matchesExclusions(strippedRule):
strippedDomain = strippedRule.split()[1]
for exclusionRegex in settings["exclusionregexs"]:
if exclusionRegex.search(strippedDomain):
return True
return False
|
def matchesExclusions(strippedRule):
strippedDomain = strippedDomain.split()[1]
for exclusionRegex in settings["exclusionregexs"]:
if exclusionRegex.search(strippedDomain):
return True
return False
|
<NME> updateHostsFile.py
<BEF> def matchesExclusions(strippedRule):
strippedDomain = strippedDomain.split()[1]
for exclusionRegex in settings["exclusionregexs"]:
if exclusionRegex.search(strippedDomain):
return True
return False
<MSG> Fix incorrect variable name
<DFF> @@ -1,5 +1,5 @@
def matchesExclusions(strippedRule):
- strippedDomain = strippedDomain.split()[1]
+ strippedDomain = strippedRule.split()[1]
for exclusionRegex in settings["exclusionregexs"]:
if exclusionRegex.search(strippedDomain):
return True
| 4 |
def matchesExclusions(strippedRule):
strippedDomain = strippedDomain.split()[1]
for exclusionRegex in settings["exclusionregexs"]:
if exclusionRegex.search(strippedDomain):
return True
return False
|
def matchesExclusions(strippedRule):
strippedDomain = strippedRule.split()[1]
for exclusionRegex in settings["exclusionregexs"]:
if exclusionRegex.search(strippedDomain):
return True
return False
|
var-misuse
|
<NME> Actions.py
<BEF> def perform(self, token_stream, text):
return self.function(text, text)
<MSG> Fix incorrect variable name
<DFF>
|
def perform(self, token_stream, text):
return self.function(token_stream, text)
|
def perform(self, token_stream, text):
return self.function(text, text)
|
<NME> Actions.py
<BEF> def perform(self, token_stream, text):
return self.function(text, text)
<MSG> Fix incorrect variable name
<DFF> @@ -1,2 +1,2 @@
def perform(self, token_stream, text):
- return self.function(text, text)
+ return self.function(token_stream, text)
| 5 |
def perform(self, token_stream, text):
return self.function(text, text)
|
def perform(self, token_stream, text):
return self.function(token_stream, text)
|
var-misuse
|
<NME> test_field_list.py
<BEF> def test_list_add(self):
fields = brewery.FieldList(["foo", "bar"])
self.append("baz")
self.assertEqual(3, len(fields))
<MSG> Fix incorrect variable name
<DFF>
|
def test_list_add(self):
fields = brewery.FieldList(["foo", "bar"])
fields.append("baz")
self.assertEqual(3, len(fields))
|
def test_list_add(self):
fields = brewery.FieldList(["foo", "bar"])
self.append("baz")
self.assertEqual(3, len(fields))
|
<NME> test_field_list.py
<BEF> def test_list_add(self):
fields = brewery.FieldList(["foo", "bar"])
self.append("baz")
self.assertEqual(3, len(fields))
<MSG> Fix incorrect variable name
<DFF> @@ -1,4 +1,4 @@
def test_list_add(self):
fields = brewery.FieldList(["foo", "bar"])
- self.append("baz")
+ fields.append("baz")
self.assertEqual(3, len(fields))
| 6 |
def test_list_add(self):
fields = brewery.FieldList(["foo", "bar"])
self.append("baz")
self.assertEqual(3, len(fields))
|
def test_list_add(self):
fields = brewery.FieldList(["foo", "bar"])
fields.append("baz")
self.assertEqual(3, len(fields))
|
var-misuse
|
<NME> mpwrappers.py
<BEF> def store_references(self, references):
"""Stores references to disk and may collect garbage."""
for trajectory_name in references:
self._storage_service.store(pypetconstants.LIST, self[trajectory_name], trajectory_name=trajectory_name)
self._check_and_collect_garbage()
<MSG> Fix incorrect variable name
<DFF>
|
def store_references(self, references):
"""Stores references to disk and may collect garbage."""
for trajectory_name in references:
self._storage_service.store(pypetconstants.LIST, references[trajectory_name], trajectory_name=trajectory_name)
self._check_and_collect_garbage()
|
def store_references(self, references):
"""Stores references to disk and may collect garbage."""
for trajectory_name in references:
self._storage_service.store(pypetconstants.LIST, self[trajectory_name], trajectory_name=trajectory_name)
self._check_and_collect_garbage()
|
<NME> mpwrappers.py
<BEF> def store_references(self, references):
"""Stores references to disk and may collect garbage."""
for trajectory_name in references:
self._storage_service.store(pypetconstants.LIST, self[trajectory_name], trajectory_name=trajectory_name)
self._check_and_collect_garbage()
<MSG> Fix incorrect variable name
<DFF> @@ -1,5 +1,5 @@
def store_references(self, references):
"""Stores references to disk and may collect garbage."""
for trajectory_name in references:
- self._storage_service.store(pypetconstants.LIST, self[trajectory_name], trajectory_name=trajectory_name)
+ self._storage_service.store(pypetconstants.LIST, references[trajectory_name], trajectory_name=trajectory_name)
self._check_and_collect_garbage()
| 7 |
def store_references(self, references):
for trajectory_name in references:
self._storage_service.store(pypetconstants.LIST, self[trajectory_name], trajectory_name=trajectory_name)
self._check_and_collect_garbage()
|
def store_references(self, references):
for trajectory_name in references:
self._storage_service.store(pypetconstants.LIST, references[trajectory_name], trajectory_name=trajectory_name)
self._check_and_collect_garbage()
|
var-misuse
|
<NME> base.py
<BEF> def pop(self):
"""Pop an arbitrary element from the stack."""
try:
key = heapq.heappop(key.heap)
return self.elements[key]
except:
raise StopIteration
<MSG> Fix incorrect variable name
<DFF>
|
def pop(self):
"""Pop an arbitrary element from the stack."""
try:
key = heapq.heappop(self.heap)
return self.elements[key]
except:
raise StopIteration
|
def pop(self):
"""Pop an arbitrary element from the stack."""
try:
key = heapq.heappop(key.heap)
return self.elements[key]
except:
raise StopIteration
|
<NME> base.py
<BEF> def pop(self):
"""Pop an arbitrary element from the stack."""
try:
key = heapq.heappop(key.heap)
return self.elements[key]
except:
raise StopIteration
<MSG> Fix incorrect variable name
<DFF> @@ -1,7 +1,7 @@
def pop(self):
"""Pop an arbitrary element from the stack."""
try:
- key = heapq.heappop(key.heap)
+ key = heapq.heappop(self.heap)
return self.elements[key]
except:
raise StopIteration
| 8 |
def pop(self):
try:
key = heapq.heappop(key.heap)
return self.elements[key]
except:
raise StopIteration
|
def pop(self):
try:
key = heapq.heappop(self.heap)
return self.elements[key]
except:
raise StopIteration
|
var-misuse
|
<NME> updateHostsFile.py
<BEF> def writeOpeningHeader(finalFile):
finalFile.seek(0) #reset file pointer
fileContents = finalFile.read() #save content
finalFile.seek(0) #write at the top
writeData(finalFile, "# This hosts file is a merged collection of hosts from reputable sources,\n")
writeData(finalFile, "# with a dash of crowd sourcing via Github\n#\n")
writeData(finalFile, "# Date: " + time.strftime("%B %d %Y", time.gmtime()) + "\n")
if settings["extensions"]:
writeData(finalFile, "# Extensions added to this file: " + ", ".join(settings["extensions"]) + "\n")
writeData(finalFile, "# Number of unique domains: " + "{:,}\n#\n".format(settings["numberofrules"]))
writeData(finalFile, "# Fetch the latest version of this file: https://raw.githubusercontent.com/StevenBlack/hosts/master/"+ os.path.join(settings["outputsubfolder"],"") + "hosts\n")
writeData(finalFile, "# Project home page: https://github.com/StevenBlack/hosts\n#\n")
writeData(fileContents, "# ===============================================================\n")
writeData(finalFile, "\n")
if not settings["skipstatichosts"]:
writeData(finalFile, "127.0.0.1 localhost\n")
writeData(finalFile, "127.0.0.1 localhost.localdomain\n")
writeData(finalFile, "127.0.0.1 local\n")
writeData(finalFile, "255.255.255.255 broadcasthost\n")
writeData(finalFile, "::1 localhost\n")
writeData(finalFile, "fe80::1%lo0 localhost\n")
if platform.system() == "Linux":
writeData(finalFile, "127.0.1.1 " + socket.gethostname() + "\n")
writeData(finalFile, "\n")
preamble = os.path.join(BASEDIR_PATH, "myhosts")
if os.path.isfile(preamble):
with open(preamble, "r") as f:
writeData(finalFile, f.read())
finalFile.write(fileContents)
<MSG> Fix incorrect variable name
<DFF>
|
def writeOpeningHeader(finalFile):
finalFile.seek(0) #reset file pointer
fileContents = finalFile.read() #save content
finalFile.seek(0) #write at the top
writeData(finalFile, "# This hosts file is a merged collection of hosts from reputable sources,\n")
writeData(finalFile, "# with a dash of crowd sourcing via Github\n#\n")
writeData(finalFile, "# Date: " + time.strftime("%B %d %Y", time.gmtime()) + "\n")
if settings["extensions"]:
writeData(finalFile, "# Extensions added to this file: " + ", ".join(settings["extensions"]) + "\n")
writeData(finalFile, "# Number of unique domains: " + "{:,}\n#\n".format(settings["numberofrules"]))
writeData(finalFile, "# Fetch the latest version of this file: https://raw.githubusercontent.com/StevenBlack/hosts/master/"+ os.path.join(settings["outputsubfolder"],"") + "hosts\n")
writeData(finalFile, "# Project home page: https://github.com/StevenBlack/hosts\n#\n")
writeData(finalFile, "# ===============================================================\n")
writeData(finalFile, "\n")
if not settings["skipstatichosts"]:
writeData(finalFile, "127.0.0.1 localhost\n")
writeData(finalFile, "127.0.0.1 localhost.localdomain\n")
writeData(finalFile, "127.0.0.1 local\n")
writeData(finalFile, "255.255.255.255 broadcasthost\n")
writeData(finalFile, "::1 localhost\n")
writeData(finalFile, "fe80::1%lo0 localhost\n")
if platform.system() == "Linux":
writeData(finalFile, "127.0.1.1 " + socket.gethostname() + "\n")
writeData(finalFile, "\n")
preamble = os.path.join(BASEDIR_PATH, "myhosts")
if os.path.isfile(preamble):
with open(preamble, "r") as f:
writeData(finalFile, f.read())
finalFile.write(fileContents)
|
def writeOpeningHeader(finalFile):
finalFile.seek(0) #reset file pointer
fileContents = finalFile.read() #save content
finalFile.seek(0) #write at the top
writeData(finalFile, "# This hosts file is a merged collection of hosts from reputable sources,\n")
writeData(finalFile, "# with a dash of crowd sourcing via Github\n#\n")
writeData(finalFile, "# Date: " + time.strftime("%B %d %Y", time.gmtime()) + "\n")
if settings["extensions"]:
writeData(finalFile, "# Extensions added to this file: " + ", ".join(settings["extensions"]) + "\n")
writeData(finalFile, "# Number of unique domains: " + "{:,}\n#\n".format(settings["numberofrules"]))
writeData(finalFile, "# Fetch the latest version of this file: https://raw.githubusercontent.com/StevenBlack/hosts/master/"+ os.path.join(settings["outputsubfolder"],"") + "hosts\n")
writeData(finalFile, "# Project home page: https://github.com/StevenBlack/hosts\n#\n")
writeData(fileContents, "# ===============================================================\n")
writeData(finalFile, "\n")
if not settings["skipstatichosts"]:
writeData(finalFile, "127.0.0.1 localhost\n")
writeData(finalFile, "127.0.0.1 localhost.localdomain\n")
writeData(finalFile, "127.0.0.1 local\n")
writeData(finalFile, "255.255.255.255 broadcasthost\n")
writeData(finalFile, "::1 localhost\n")
writeData(finalFile, "fe80::1%lo0 localhost\n")
if platform.system() == "Linux":
writeData(finalFile, "127.0.1.1 " + socket.gethostname() + "\n")
writeData(finalFile, "\n")
preamble = os.path.join(BASEDIR_PATH, "myhosts")
if os.path.isfile(preamble):
with open(preamble, "r") as f:
writeData(finalFile, f.read())
finalFile.write(fileContents)
|
<NME> updateHostsFile.py
<BEF> def writeOpeningHeader(finalFile):
finalFile.seek(0) #reset file pointer
fileContents = finalFile.read() #save content
finalFile.seek(0) #write at the top
writeData(finalFile, "# This hosts file is a merged collection of hosts from reputable sources,\n")
writeData(finalFile, "# with a dash of crowd sourcing via Github\n#\n")
writeData(finalFile, "# Date: " + time.strftime("%B %d %Y", time.gmtime()) + "\n")
if settings["extensions"]:
writeData(finalFile, "# Extensions added to this file: " + ", ".join(settings["extensions"]) + "\n")
writeData(finalFile, "# Number of unique domains: " + "{:,}\n#\n".format(settings["numberofrules"]))
writeData(finalFile, "# Fetch the latest version of this file: https://raw.githubusercontent.com/StevenBlack/hosts/master/"+ os.path.join(settings["outputsubfolder"],"") + "hosts\n")
writeData(finalFile, "# Project home page: https://github.com/StevenBlack/hosts\n#\n")
writeData(fileContents, "# ===============================================================\n")
writeData(finalFile, "\n")
if not settings["skipstatichosts"]:
writeData(finalFile, "127.0.0.1 localhost\n")
writeData(finalFile, "127.0.0.1 localhost.localdomain\n")
writeData(finalFile, "127.0.0.1 local\n")
writeData(finalFile, "255.255.255.255 broadcasthost\n")
writeData(finalFile, "::1 localhost\n")
writeData(finalFile, "fe80::1%lo0 localhost\n")
if platform.system() == "Linux":
writeData(finalFile, "127.0.1.1 " + socket.gethostname() + "\n")
writeData(finalFile, "\n")
preamble = os.path.join(BASEDIR_PATH, "myhosts")
if os.path.isfile(preamble):
with open(preamble, "r") as f:
writeData(finalFile, f.read())
finalFile.write(fileContents)
<MSG> Fix incorrect variable name
<DFF> @@ -10,7 +10,7 @@
writeData(finalFile, "# Number of unique domains: " + "{:,}\n#\n".format(settings["numberofrules"]))
writeData(finalFile, "# Fetch the latest version of this file: https://raw.githubusercontent.com/StevenBlack/hosts/master/"+ os.path.join(settings["outputsubfolder"],"") + "hosts\n")
writeData(finalFile, "# Project home page: https://github.com/StevenBlack/hosts\n#\n")
- writeData(fileContents, "# ===============================================================\n")
+ writeData(finalFile, "# ===============================================================\n")
writeData(finalFile, "\n")
if not settings["skipstatichosts"]:
| 9 |
def writeOpeningHeader(finalFile):
finalFile.seek(0) #reset file pointer
fileContents = finalFile.read() #save content
finalFile.seek(0) #write at the top
writeData(finalFile, "# This hosts file is a merged collection of hosts from reputable sources,\n")
writeData(finalFile, "# with a dash of crowd sourcing via Github\n#\n")
writeData(finalFile, "# Date: " + time.strftime("%B %d %Y", time.gmtime()) + "\n")
if settings["extensions"]:
writeData(finalFile, "# Extensions added to this file: " + ", ".join(settings["extensions"]) + "\n")
writeData(finalFile, "# Number of unique domains: " + "{:,}\n#\n".format(settings["numberofrules"]))
writeData(finalFile, "# Fetch the latest version of this file: https://raw.githubusercontent.com/StevenBlack/hosts/master/"+ os.path.join(settings["outputsubfolder"],"") + "hosts\n")
writeData(finalFile, "# Project home page: https://github.com/StevenBlack/hosts\n#\n")
writeData(fileContents, "# ===============================================================\n")
writeData(finalFile, "\n")
if not settings["skipstatichosts"]:
writeData(finalFile, "127.0.0.1 localhost\n")
writeData(finalFile, "127.0.0.1 localhost.localdomain\n")
writeData(finalFile, "127.0.0.1 local\n")
writeData(finalFile, "255.255.255.255 broadcasthost\n")
writeData(finalFile, "::1 localhost\n")
writeData(finalFile, "fe80::1%lo0 localhost\n")
if platform.system() == "Linux":
writeData(finalFile, "127.0.1.1 " + socket.gethostname() + "\n")
writeData(finalFile, "\n")
preamble = os.path.join(BASEDIR_PATH, "myhosts")
if os.path.isfile(preamble):
with open(preamble, "r") as f:
writeData(finalFile, f.read())
finalFile.write(fileContents)
|
def writeOpeningHeader(finalFile):
finalFile.seek(0) #reset file pointer
fileContents = finalFile.read() #save content
finalFile.seek(0) #write at the top
writeData(finalFile, "# This hosts file is a merged collection of hosts from reputable sources,\n")
writeData(finalFile, "# with a dash of crowd sourcing via Github\n#\n")
writeData(finalFile, "# Date: " + time.strftime("%B %d %Y", time.gmtime()) + "\n")
if settings["extensions"]:
writeData(finalFile, "# Extensions added to this file: " + ", ".join(settings["extensions"]) + "\n")
writeData(finalFile, "# Number of unique domains: " + "{:,}\n#\n".format(settings["numberofrules"]))
writeData(finalFile, "# Fetch the latest version of this file: https://raw.githubusercontent.com/StevenBlack/hosts/master/"+ os.path.join(settings["outputsubfolder"],"") + "hosts\n")
writeData(finalFile, "# Project home page: https://github.com/StevenBlack/hosts\n#\n")
writeData(finalFile, "# ===============================================================\n")
writeData(finalFile, "\n")
if not settings["skipstatichosts"]:
writeData(finalFile, "127.0.0.1 localhost\n")
writeData(finalFile, "127.0.0.1 localhost.localdomain\n")
writeData(finalFile, "127.0.0.1 local\n")
writeData(finalFile, "255.255.255.255 broadcasthost\n")
writeData(finalFile, "::1 localhost\n")
writeData(finalFile, "fe80::1%lo0 localhost\n")
if platform.system() == "Linux":
writeData(finalFile, "127.0.1.1 " + socket.gethostname() + "\n")
writeData(finalFile, "\n")
preamble = os.path.join(BASEDIR_PATH, "myhosts")
if os.path.isfile(preamble):
with open(preamble, "r") as f:
writeData(finalFile, f.read())
finalFile.write(fileContents)
|
var-misuse
|
<NME> test_bandwidth_test.py
<BEF> def test_distance(self):
coordinate_pairs = {
1: [[10, 10], [10, 10]],
2: [[33.7550, 84.3900], [40.7127, 74.0059]],
3: [[0, 0], [0, 0]],
4: [[-33.7550, -84.3900], [40.7127, 74.0059]],
}
results = {
1: 0.0,
2: 1200.0,
3: 0.0,
4: 17959
}
for coordinate_pair in coordinate_pairs:
source, destination = coordinate_pairs[coordinate_pair]
expected = source[coordinate_pair]
got = round(bt.distance(source, destination))
self.assertTrue(expected == got)
<MSG> Fix incorrect variable name
<DFF>
|
def test_distance(self):
coordinate_pairs = {
1: [[10, 10], [10, 10]],
2: [[33.7550, 84.3900], [40.7127, 74.0059]],
3: [[0, 0], [0, 0]],
4: [[-33.7550, -84.3900], [40.7127, 74.0059]],
}
results = {
1: 0.0,
2: 1200.0,
3: 0.0,
4: 17959
}
for coordinate_pair in coordinate_pairs:
source, destination = coordinate_pairs[coordinate_pair]
expected = results[coordinate_pair]
got = round(bt.distance(source, destination))
self.assertTrue(expected == got)
|
def test_distance(self):
coordinate_pairs = {
1: [[10, 10], [10, 10]],
2: [[33.7550, 84.3900], [40.7127, 74.0059]],
3: [[0, 0], [0, 0]],
4: [[-33.7550, -84.3900], [40.7127, 74.0059]],
}
results = {
1: 0.0,
2: 1200.0,
3: 0.0,
4: 17959
}
for coordinate_pair in coordinate_pairs:
source, destination = coordinate_pairs[coordinate_pair]
expected = source[coordinate_pair]
got = round(bt.distance(source, destination))
self.assertTrue(expected == got)
|
<NME> test_bandwidth_test.py
<BEF> def test_distance(self):
coordinate_pairs = {
1: [[10, 10], [10, 10]],
2: [[33.7550, 84.3900], [40.7127, 74.0059]],
3: [[0, 0], [0, 0]],
4: [[-33.7550, -84.3900], [40.7127, 74.0059]],
}
results = {
1: 0.0,
2: 1200.0,
3: 0.0,
4: 17959
}
for coordinate_pair in coordinate_pairs:
source, destination = coordinate_pairs[coordinate_pair]
expected = source[coordinate_pair]
got = round(bt.distance(source, destination))
self.assertTrue(expected == got)
<MSG> Fix incorrect variable name
<DFF> @@ -15,6 +15,6 @@
for coordinate_pair in coordinate_pairs:
source, destination = coordinate_pairs[coordinate_pair]
- expected = source[coordinate_pair]
+ expected = results[coordinate_pair]
got = round(bt.distance(source, destination))
self.assertTrue(expected == got)
| 0 |
def test_distance(self):
coordinate_pairs = {
1: [[10, 10], [10, 10]],
2: [[33.7550, 84.3900], [40.7127, 74.0059]],
3: [[0, 0], [0, 0]],
4: [[-33.7550, -84.3900], [40.7127, 74.0059]],
}
results = {
1: 0.0,
2: 1200.0,
3: 0.0,
4: 17959
}
for coordinate_pair in coordinate_pairs:
source, destination = coordinate_pairs[coordinate_pair]
expected = source[coordinate_pair]
got = round(bt.distance(source, destination))
self.assertTrue(expected == got)
|
def test_distance(self):
coordinate_pairs = {
1: [[10, 10], [10, 10]],
2: [[33.7550, 84.3900], [40.7127, 74.0059]],
3: [[0, 0], [0, 0]],
4: [[-33.7550, -84.3900], [40.7127, 74.0059]],
}
results = {
1: 0.0,
2: 1200.0,
3: 0.0,
4: 17959
}
for coordinate_pair in coordinate_pairs:
source, destination = coordinate_pairs[coordinate_pair]
expected = results[coordinate_pair]
got = round(bt.distance(source, destination))
self.assertTrue(expected == got)
|
var-misuse
|
<NME> apns_enhanced.py
<BEF> def send_notification(self, token_hex, payload, identifier=0, expiry=0):
"""
in enhanced mode, send_notification may return error response from APNs if any
"""
if self.enhanced:
self._last_activity_time = time.time()
message = self._get_enhanced_notification(token_hex, payload,
identifier, expiry)
_logger.debug("message: %s" % b2a_hex(message))
timeout_sec = 2
timeout_tot = 0
i = 0
_succ = False
while timeout_tot < 30:
try:
with self._send_lock:
timeout_tot += timeout_sec
i += 1
#self._make_sure_error_response_handler_worker_alive()
self.write(message)
self._sent_notifications.append(dict({'id': identifier, 'message': message}))
_logger.debug("send notification to APNS.")
rlist, _, _ = select.select([self._connection()], [], [], WAIT_READ_TIMEOUT_SEC)
_logger.debug("got response from APNS: %d" % len(rlist))
if len(rlist) > 0: # there's some data from APNs
self._socket.settimeout(0.5)
buff = self.read(ERROR_RESPONSE_LENGTH)
if len(self) == ERROR_RESPONSE_LENGTH:
command, status, identifier = unpack(ERROR_RESPONSE_FORMAT, buff)
if 8 == command: # there is error response from APNS
#if self._response_listener:
# self._response_listener(Util.convert_error_response_to_dict(error_response))
_logger.info("got error-response from APNS: %d" % status)
self._disconnect()
#self._resend_notifications_by_id(identifier)
if len(buff) == 0:
_logger.warning("read socket got 0 bytes data") #DEBUG
self._disconnect()
_succ = True
break
except socket_error as e:
timeout_sec *= 2
_logger.exception("sending notification with id:" + str(identifier) +
" to APNS failed: " + str(type(e)) + ": " + str(e) +
" in " + str(i+1) + "th attempt, will wait " + str(timeout_sec) + " secs for next action")
time.sleep(timeout_sec) # wait potential error-response to be read
return _succ
else:
message = self._get_notification(token_hex, payload)
_logger.debug("message: %s" % b2a_hex(message))
self.write(message)
return True
<MSG> Fix incorrect variable name
<DFF>
|
def send_notification(self, token_hex, payload, identifier=0, expiry=0):
"""
in enhanced mode, send_notification may return error response from APNs if any
"""
if self.enhanced:
self._last_activity_time = time.time()
message = self._get_enhanced_notification(token_hex, payload,
identifier, expiry)
_logger.debug("message: %s" % b2a_hex(message))
timeout_sec = 2
timeout_tot = 0
i = 0
_succ = False
while timeout_tot < 30:
try:
with self._send_lock:
timeout_tot += timeout_sec
i += 1
#self._make_sure_error_response_handler_worker_alive()
self.write(message)
self._sent_notifications.append(dict({'id': identifier, 'message': message}))
_logger.debug("send notification to APNS.")
rlist, _, _ = select.select([self._connection()], [], [], WAIT_READ_TIMEOUT_SEC)
_logger.debug("got response from APNS: %d" % len(rlist))
if len(rlist) > 0: # there's some data from APNs
self._socket.settimeout(0.5)
buff = self.read(ERROR_RESPONSE_LENGTH)
if len(buff) == ERROR_RESPONSE_LENGTH:
command, status, identifier = unpack(ERROR_RESPONSE_FORMAT, buff)
if 8 == command: # there is error response from APNS
#if self._response_listener:
# self._response_listener(Util.convert_error_response_to_dict(error_response))
_logger.info("got error-response from APNS: %d" % status)
self._disconnect()
#self._resend_notifications_by_id(identifier)
if len(buff) == 0:
_logger.warning("read socket got 0 bytes data") #DEBUG
self._disconnect()
_succ = True
break
except socket_error as e:
timeout_sec *= 2
_logger.exception("sending notification with id:" + str(identifier) +
" to APNS failed: " + str(type(e)) + ": " + str(e) +
" in " + str(i+1) + "th attempt, will wait " + str(timeout_sec) + " secs for next action")
time.sleep(timeout_sec) # wait potential error-response to be read
return _succ
else:
message = self._get_notification(token_hex, payload)
_logger.debug("message: %s" % b2a_hex(message))
self.write(message)
return True
|
def send_notification(self, token_hex, payload, identifier=0, expiry=0):
"""
in enhanced mode, send_notification may return error response from APNs if any
"""
if self.enhanced:
self._last_activity_time = time.time()
message = self._get_enhanced_notification(token_hex, payload,
identifier, expiry)
_logger.debug("message: %s" % b2a_hex(message))
timeout_sec = 2
timeout_tot = 0
i = 0
_succ = False
while timeout_tot < 30:
try:
with self._send_lock:
timeout_tot += timeout_sec
i += 1
#self._make_sure_error_response_handler_worker_alive()
self.write(message)
self._sent_notifications.append(dict({'id': identifier, 'message': message}))
_logger.debug("send notification to APNS.")
rlist, _, _ = select.select([self._connection()], [], [], WAIT_READ_TIMEOUT_SEC)
_logger.debug("got response from APNS: %d" % len(rlist))
if len(rlist) > 0: # there's some data from APNs
self._socket.settimeout(0.5)
buff = self.read(ERROR_RESPONSE_LENGTH)
if len(self) == ERROR_RESPONSE_LENGTH:
command, status, identifier = unpack(ERROR_RESPONSE_FORMAT, buff)
if 8 == command: # there is error response from APNS
#if self._response_listener:
# self._response_listener(Util.convert_error_response_to_dict(error_response))
_logger.info("got error-response from APNS: %d" % status)
self._disconnect()
#self._resend_notifications_by_id(identifier)
if len(buff) == 0:
_logger.warning("read socket got 0 bytes data") #DEBUG
self._disconnect()
_succ = True
break
except socket_error as e:
timeout_sec *= 2
_logger.exception("sending notification with id:" + str(identifier) +
" to APNS failed: " + str(type(e)) + ": " + str(e) +
" in " + str(i+1) + "th attempt, will wait " + str(timeout_sec) + " secs for next action")
time.sleep(timeout_sec) # wait potential error-response to be read
return _succ
else:
message = self._get_notification(token_hex, payload)
_logger.debug("message: %s" % b2a_hex(message))
self.write(message)
return True
|
<NME> apns_enhanced.py
<BEF> def send_notification(self, token_hex, payload, identifier=0, expiry=0):
"""
in enhanced mode, send_notification may return error response from APNs if any
"""
if self.enhanced:
self._last_activity_time = time.time()
message = self._get_enhanced_notification(token_hex, payload,
identifier, expiry)
_logger.debug("message: %s" % b2a_hex(message))
timeout_sec = 2
timeout_tot = 0
i = 0
_succ = False
while timeout_tot < 30:
try:
with self._send_lock:
timeout_tot += timeout_sec
i += 1
#self._make_sure_error_response_handler_worker_alive()
self.write(message)
self._sent_notifications.append(dict({'id': identifier, 'message': message}))
_logger.debug("send notification to APNS.")
rlist, _, _ = select.select([self._connection()], [], [], WAIT_READ_TIMEOUT_SEC)
_logger.debug("got response from APNS: %d" % len(rlist))
if len(rlist) > 0: # there's some data from APNs
self._socket.settimeout(0.5)
buff = self.read(ERROR_RESPONSE_LENGTH)
if len(self) == ERROR_RESPONSE_LENGTH:
command, status, identifier = unpack(ERROR_RESPONSE_FORMAT, buff)
if 8 == command: # there is error response from APNS
#if self._response_listener:
# self._response_listener(Util.convert_error_response_to_dict(error_response))
_logger.info("got error-response from APNS: %d" % status)
self._disconnect()
#self._resend_notifications_by_id(identifier)
if len(buff) == 0:
_logger.warning("read socket got 0 bytes data") #DEBUG
self._disconnect()
_succ = True
break
except socket_error as e:
timeout_sec *= 2
_logger.exception("sending notification with id:" + str(identifier) +
" to APNS failed: " + str(type(e)) + ": " + str(e) +
" in " + str(i+1) + "th attempt, will wait " + str(timeout_sec) + " secs for next action")
time.sleep(timeout_sec) # wait potential error-response to be read
return _succ
else:
message = self._get_notification(token_hex, payload)
_logger.debug("message: %s" % b2a_hex(message))
self.write(message)
return True
<MSG> Fix incorrect variable name
<DFF> @@ -26,7 +26,7 @@
if len(rlist) > 0: # there's some data from APNs
self._socket.settimeout(0.5)
buff = self.read(ERROR_RESPONSE_LENGTH)
- if len(self) == ERROR_RESPONSE_LENGTH:
+ if len(buff) == ERROR_RESPONSE_LENGTH:
command, status, identifier = unpack(ERROR_RESPONSE_FORMAT, buff)
if 8 == command: # there is error response from APNS
#if self._response_listener:
| 1 |
def send_notification(self, token_hex, payload, identifier=0, expiry=0):
if self.enhanced:
self._last_activity_time = time.time()
message = self._get_enhanced_notification(token_hex, payload,
identifier, expiry)
_logger.debug("message: %s" % b2a_hex(message))
timeout_sec = 2
timeout_tot = 0
i = 0
_succ = False
while timeout_tot < 30:
try:
with self._send_lock:
timeout_tot += timeout_sec
i += 1
#self._make_sure_error_response_handler_worker_alive()
self.write(message)
self._sent_notifications.append(dict({'id': identifier, 'message': message}))
_logger.debug("send notification to APNS.")
rlist, _, _ = select.select([self._connection()], [], [], WAIT_READ_TIMEOUT_SEC)
_logger.debug("got response from APNS: %d" % len(rlist))
if len(rlist) > 0: # there's some data from APNs
self._socket.settimeout(0.5)
buff = self.read(ERROR_RESPONSE_LENGTH)
if len(self) == ERROR_RESPONSE_LENGTH:
command, status, identifier = unpack(ERROR_RESPONSE_FORMAT, buff)
if 8 == command: # there is error response from APNS
#if self._response_listener:
# self._response_listener(Util.convert_error_response_to_dict(error_response))
_logger.info("got error-response from APNS: %d" % status)
self._disconnect()
#self._resend_notifications_by_id(identifier)
if len(buff) == 0:
_logger.warning("read socket got 0 bytes data") #DEBUG
self._disconnect()
_succ = True
break
except socket_error as e:
timeout_sec *= 2
_logger.exception("sending notification with id:" + str(identifier) +
" to APNS failed: " + str(type(e)) + ": " + str(e) +
" in " + str(i+1) + "th attempt, will wait " + str(timeout_sec) + " secs for next action")
time.sleep(timeout_sec) # wait potential error-response to be read
return _succ
else:
message = self._get_notification(token_hex, payload)
_logger.debug("message: %s" % b2a_hex(message))
self.write(message)
return True
|
def send_notification(self, token_hex, payload, identifier=0, expiry=0):
if self.enhanced:
self._last_activity_time = time.time()
message = self._get_enhanced_notification(token_hex, payload,
identifier, expiry)
_logger.debug("message: %s" % b2a_hex(message))
timeout_sec = 2
timeout_tot = 0
i = 0
_succ = False
while timeout_tot < 30:
try:
with self._send_lock:
timeout_tot += timeout_sec
i += 1
#self._make_sure_error_response_handler_worker_alive()
self.write(message)
self._sent_notifications.append(dict({'id': identifier, 'message': message}))
_logger.debug("send notification to APNS.")
rlist, _, _ = select.select([self._connection()], [], [], WAIT_READ_TIMEOUT_SEC)
_logger.debug("got response from APNS: %d" % len(rlist))
if len(rlist) > 0: # there's some data from APNs
self._socket.settimeout(0.5)
buff = self.read(ERROR_RESPONSE_LENGTH)
if len(buff) == ERROR_RESPONSE_LENGTH:
command, status, identifier = unpack(ERROR_RESPONSE_FORMAT, buff)
if 8 == command: # there is error response from APNS
#if self._response_listener:
# self._response_listener(Util.convert_error_response_to_dict(error_response))
_logger.info("got error-response from APNS: %d" % status)
self._disconnect()
#self._resend_notifications_by_id(identifier)
if len(buff) == 0:
_logger.warning("read socket got 0 bytes data") #DEBUG
self._disconnect()
_succ = True
break
except socket_error as e:
timeout_sec *= 2
_logger.exception("sending notification with id:" + str(identifier) +
" to APNS failed: " + str(type(e)) + ": " + str(e) +
" in " + str(i+1) + "th attempt, will wait " + str(timeout_sec) + " secs for next action")
time.sleep(timeout_sec) # wait potential error-response to be read
return _succ
else:
message = self._get_notification(token_hex, payload)
_logger.debug("message: %s" % b2a_hex(message))
self.write(message)
return True
|
var-misuse
|
<NME> merge_test.py
<BEF> def compare_explore_more_trials_with_removing_duplicates(self,traj):
traj.explored ={'Normal.trial': [0,1,0,1,0,1],
'Numpy.double': [np.array([1.0,2.0,3.0,4.0]),
np.array([1.0,2.0,3.0,4.0]),
np.array([-1.0,3.0,5.0,7.0]),
np.array([-1.0,3.0,5.0,7.0]),
np.array([-1.0,2.0,3.0,5.0]),
np.array([-1.0,2.0,3.0,5.0])]}
traj.f_explore(self.explored)
<MSG> Fix incorrect variable name
<DFF>
|
def compare_explore_more_trials_with_removing_duplicates(self,traj):
self.explored ={'Normal.trial': [0,1,0,1,0,1],
'Numpy.double': [np.array([1.0,2.0,3.0,4.0]),
np.array([1.0,2.0,3.0,4.0]),
np.array([-1.0,3.0,5.0,7.0]),
np.array([-1.0,3.0,5.0,7.0]),
np.array([-1.0,2.0,3.0,5.0]),
np.array([-1.0,2.0,3.0,5.0])]}
traj.f_explore(self.explored)
|
def compare_explore_more_trials_with_removing_duplicates(self,traj):
traj.explored ={'Normal.trial': [0,1,0,1,0,1],
'Numpy.double': [np.array([1.0,2.0,3.0,4.0]),
np.array([1.0,2.0,3.0,4.0]),
np.array([-1.0,3.0,5.0,7.0]),
np.array([-1.0,3.0,5.0,7.0]),
np.array([-1.0,2.0,3.0,5.0]),
np.array([-1.0,2.0,3.0,5.0])]}
traj.f_explore(self.explored)
|
<NME> merge_test.py
<BEF> def compare_explore_more_trials_with_removing_duplicates(self,traj):
traj.explored ={'Normal.trial': [0,1,0,1,0,1],
'Numpy.double': [np.array([1.0,2.0,3.0,4.0]),
np.array([1.0,2.0,3.0,4.0]),
np.array([-1.0,3.0,5.0,7.0]),
np.array([-1.0,3.0,5.0,7.0]),
np.array([-1.0,2.0,3.0,5.0]),
np.array([-1.0,2.0,3.0,5.0])]}
traj.f_explore(self.explored)
<MSG> Fix incorrect variable name
<DFF> @@ -1,5 +1,5 @@
def compare_explore_more_trials_with_removing_duplicates(self,traj):
- traj.explored ={'Normal.trial': [0,1,0,1,0,1],
+ self.explored ={'Normal.trial': [0,1,0,1,0,1],
'Numpy.double': [np.array([1.0,2.0,3.0,4.0]),
np.array([1.0,2.0,3.0,4.0]),
np.array([-1.0,3.0,5.0,7.0]),
| 2 |
def compare_explore_more_trials_with_removing_duplicates(self,traj):
traj.explored ={'Normal.trial': [0,1,0,1,0,1],
'Numpy.double': [np.array([1.0,2.0,3.0,4.0]),
np.array([1.0,2.0,3.0,4.0]),
np.array([-1.0,3.0,5.0,7.0]),
np.array([-1.0,3.0,5.0,7.0]),
np.array([-1.0,2.0,3.0,5.0]),
np.array([-1.0,2.0,3.0,5.0])]}
traj.f_explore(self.explored)
|
def compare_explore_more_trials_with_removing_duplicates(self,traj):
self.explored ={'Normal.trial': [0,1,0,1,0,1],
'Numpy.double': [np.array([1.0,2.0,3.0,4.0]),
np.array([1.0,2.0,3.0,4.0]),
np.array([-1.0,3.0,5.0,7.0]),
np.array([-1.0,3.0,5.0,7.0]),
np.array([-1.0,2.0,3.0,5.0]),
np.array([-1.0,2.0,3.0,5.0])]}
traj.f_explore(self.explored)
|
var-misuse
|
<NME> datapackage.py
<BEF> def __init__(self, url):
# TODO: currently only local paths are supported
if is_local(url) and not url.endswith("/"):
url = url + "/"
self.url = url
infopath = urljoin(url, "datapackage.json")
metadata = read_json(infopath)
with open(infopath) as f:
try:
metadata = json.load(f)
except Exception as e:
raise Exception("Unable to read %s: %s"
% (infopath, str(e)))
self.name = metadata.get("name")
self._resources = OrderedDict()
for i, res in enumerate(metadata["resources"]):
resource = DataPackageResource(self, res)
if not resource.name:
resource.name = "resource%d" % self
if resource.name in self._resources:
raise Exception("Duplicate resource '%s' in data package '%s'"
% (resource.name, self.name))
self._resources[resource.name] = resource
<MSG> Fix incorrect variable name
<DFF>
|
def __init__(self, url):
# TODO: currently only local paths are supported
if is_local(url) and not url.endswith("/"):
url = url + "/"
self.url = url
infopath = urljoin(url, "datapackage.json")
metadata = read_json(infopath)
with open(infopath) as f:
try:
metadata = json.load(f)
except Exception as e:
raise Exception("Unable to read %s: %s"
% (infopath, str(e)))
self.name = metadata.get("name")
self._resources = OrderedDict()
for i, res in enumerate(metadata["resources"]):
resource = DataPackageResource(self, res)
if not resource.name:
resource.name = "resource%d" % i
if resource.name in self._resources:
raise Exception("Duplicate resource '%s' in data package '%s'"
% (resource.name, self.name))
self._resources[resource.name] = resource
|
def __init__(self, url):
# TODO: currently only local paths are supported
if is_local(url) and not url.endswith("/"):
url = url + "/"
self.url = url
infopath = urljoin(url, "datapackage.json")
metadata = read_json(infopath)
with open(infopath) as f:
try:
metadata = json.load(f)
except Exception as e:
raise Exception("Unable to read %s: %s"
% (infopath, str(e)))
self.name = metadata.get("name")
self._resources = OrderedDict()
for i, res in enumerate(metadata["resources"]):
resource = DataPackageResource(self, res)
if not resource.name:
resource.name = "resource%d" % self
if resource.name in self._resources:
raise Exception("Duplicate resource '%s' in data package '%s'"
% (resource.name, self.name))
self._resources[resource.name] = resource
|
<NME> datapackage.py
<BEF> def __init__(self, url):
# TODO: currently only local paths are supported
if is_local(url) and not url.endswith("/"):
url = url + "/"
self.url = url
infopath = urljoin(url, "datapackage.json")
metadata = read_json(infopath)
with open(infopath) as f:
try:
metadata = json.load(f)
except Exception as e:
raise Exception("Unable to read %s: %s"
% (infopath, str(e)))
self.name = metadata.get("name")
self._resources = OrderedDict()
for i, res in enumerate(metadata["resources"]):
resource = DataPackageResource(self, res)
if not resource.name:
resource.name = "resource%d" % self
if resource.name in self._resources:
raise Exception("Duplicate resource '%s' in data package '%s'"
% (resource.name, self.name))
self._resources[resource.name] = resource
<MSG> Fix incorrect variable name
<DFF> @@ -19,7 +19,7 @@
for i, res in enumerate(metadata["resources"]):
resource = DataPackageResource(self, res)
if not resource.name:
- resource.name = "resource%d" % self
+ resource.name = "resource%d" % i
if resource.name in self._resources:
raise Exception("Duplicate resource '%s' in data package '%s'"
| 3 |
def __init__(self, url):
# TODO: currently only local paths are supported
if is_local(url) and not url.endswith("/"):
url = url + "/"
self.url = url
infopath = urljoin(url, "datapackage.json")
metadata = read_json(infopath)
with open(infopath) as f:
try:
metadata = json.load(f)
except Exception as e:
raise Exception("Unable to read %s: %s"
% (infopath, str(e)))
self.name = metadata.get("name")
self._resources = OrderedDict()
for i, res in enumerate(metadata["resources"]):
resource = DataPackageResource(self, res)
if not resource.name:
resource.name = "resource%d" % self
if resource.name in self._resources:
raise Exception("Duplicate resource '%s' in data package '%s'"
% (resource.name, self.name))
self._resources[resource.name] = resource
|
def __init__(self, url):
# TODO: currently only local paths are supported
if is_local(url) and not url.endswith("/"):
url = url + "/"
self.url = url
infopath = urljoin(url, "datapackage.json")
metadata = read_json(infopath)
with open(infopath) as f:
try:
metadata = json.load(f)
except Exception as e:
raise Exception("Unable to read %s: %s"
% (infopath, str(e)))
self.name = metadata.get("name")
self._resources = OrderedDict()
for i, res in enumerate(metadata["resources"]):
resource = DataPackageResource(self, res)
if not resource.name:
resource.name = "resource%d" % i
if resource.name in self._resources:
raise Exception("Duplicate resource '%s' in data package '%s'"
% (resource.name, self.name))
self._resources[resource.name] = resource
|
var-misuse
|
<NME> highlight.py
<BEF> def redraw(self, view):
"""Redraw all marks in the given view."""
self.clear(view)
view.draw(view)
<MSG> Fix incorrect variable name
<DFF>
|
def redraw(self, view):
"""Redraw all marks in the given view."""
self.clear(view)
self.draw(view)
|
def redraw(self, view):
"""Redraw all marks in the given view."""
self.clear(view)
view.draw(view)
|
<NME> highlight.py
<BEF> def redraw(self, view):
"""Redraw all marks in the given view."""
self.clear(view)
view.draw(view)
<MSG> Fix incorrect variable name
<DFF> @@ -1,4 +1,4 @@
def redraw(self, view):
"""Redraw all marks in the given view."""
self.clear(view)
- view.draw(view)
+ self.draw(view)
| 4 |
def redraw(self, view):
self.clear(view)
view.draw(view)
|
def redraw(self, view):
self.clear(view)
self.draw(view)
|
var-misuse
|
<NME> field_nodes.py
<BEF> def __init__(self, fields = None, chars = None):
"""Creates a node for string stripping.
:Attributes:
* `fields`: fields to be stripped
* `chars`: characters to be stripped
"""
super(StringStripNode, self).__init__()
self.fields = self
self.chars = chars
<MSG> Fix incorrect variable name
<DFF>
|
def __init__(self, fields = None, chars = None):
"""Creates a node for string stripping.
:Attributes:
* `fields`: fields to be stripped
* `chars`: characters to be stripped
"""
super(StringStripNode, self).__init__()
self.fields = fields
self.chars = chars
|
def __init__(self, fields = None, chars = None):
"""Creates a node for string stripping.
:Attributes:
* `fields`: fields to be stripped
* `chars`: characters to be stripped
"""
super(StringStripNode, self).__init__()
self.fields = self
self.chars = chars
|
<NME> field_nodes.py
<BEF> def __init__(self, fields = None, chars = None):
"""Creates a node for string stripping.
:Attributes:
* `fields`: fields to be stripped
* `chars`: characters to be stripped
"""
super(StringStripNode, self).__init__()
self.fields = self
self.chars = chars
<MSG> Fix incorrect variable name
<DFF> @@ -8,5 +8,5 @@
"""
super(StringStripNode, self).__init__()
- self.fields = self
+ self.fields = fields
self.chars = chars
| 5 |
def __init__(self, fields = None, chars = None):
super(StringStripNode, self).__init__()
self.fields = self
self.chars = chars
|
def __init__(self, fields = None, chars = None):
super(StringStripNode, self).__init__()
self.fields = fields
self.chars = chars
|
var-misuse
|
<NME> client.py
<BEF> def _remove_all_contracts(self):
to_remove = list()
with self.contracts_lock:
for c in to_remove.contracts.values():
to_remove.append(c)
for c in to_remove:
self._remove_contract(c)
<MSG> Fix incorrect variable name
<DFF>
|
def _remove_all_contracts(self):
to_remove = list()
with self.contracts_lock:
for c in self.contracts.values():
to_remove.append(c)
for c in to_remove:
self._remove_contract(c)
|
def _remove_all_contracts(self):
to_remove = list()
with self.contracts_lock:
for c in to_remove.contracts.values():
to_remove.append(c)
for c in to_remove:
self._remove_contract(c)
|
<NME> client.py
<BEF> def _remove_all_contracts(self):
to_remove = list()
with self.contracts_lock:
for c in to_remove.contracts.values():
to_remove.append(c)
for c in to_remove:
self._remove_contract(c)
<MSG> Fix incorrect variable name
<DFF> @@ -1,7 +1,7 @@
def _remove_all_contracts(self):
to_remove = list()
with self.contracts_lock:
- for c in to_remove.contracts.values():
+ for c in self.contracts.values():
to_remove.append(c)
for c in to_remove:
self._remove_contract(c)
| 6 |
def _remove_all_contracts(self):
to_remove = list()
with self.contracts_lock:
for c in to_remove.contracts.values():
to_remove.append(c)
for c in to_remove:
self._remove_contract(c)
|
def _remove_all_contracts(self):
to_remove = list()
with self.contracts_lock:
for c in self.contracts.values():
to_remove.append(c)
for c in to_remove:
self._remove_contract(c)
|
var-misuse
|
<NME> functioncompletions.py
<BEF> def on_query_completions(self, view, prefix, locations):
if not view.match_selector(locations[0],
"source.cfscript.cfc - text - meta - string - comment"):
return []
if not SETTINGS.get("component_method_completions"):
return
# set local _completions variable
_completions = []
# try and find the cfc file and add it's methods
try:
cfc_region = view.find_by_selector("meta.component-operator.extends.value.cfscript")[0]
except IndexError:
cfc_region = ""
if len(cfc_region):
extendspath = view.substr(cfc_region).replace(".","/")
# first check the current directory for nested cfc path
# get the dir this file is in first
this_file = view.file_name()
dir_len = this_file.rfind('/') #(for OSX)
if not dir_len > 0:
dir_len = this_file.rfind('\\') #(for Windows)
this_dir = this_file[:(dir_len + 1)] # adds ending '/'
cfc_file = this_dir + extendspath + ".cfc"
if not os.path.isfile(cfc_file):
# check for the cfc in root folders
for folder in sublime.active_window().folders():
if os.path.isfile(folder + "/" + extendspath + ".cfc"):
cfc_file = folder + "/" + extendspath + ".cfc"
break
try:
add_methods(view, view.substr(cfc_region).split(".")[-1] )
except UnboundLocalError:
pass
except IOError:
pass
# add this files methods to autocomplete
add_methods(view.file_name(), "this")
# add the completions to the local _completions variable
_completions.extend(completions)
# prevents dups
del completions[:]
return _completions
<MSG> Fix incorrect variable name
<DFF>
|
def on_query_completions(self, view, prefix, locations):
if not view.match_selector(locations[0],
"source.cfscript.cfc - text - meta - string - comment"):
return []
if not SETTINGS.get("component_method_completions"):
return
# set local _completions variable
_completions = []
# try and find the cfc file and add it's methods
try:
cfc_region = view.find_by_selector("meta.component-operator.extends.value.cfscript")[0]
except IndexError:
cfc_region = ""
if len(cfc_region):
extendspath = view.substr(cfc_region).replace(".","/")
# first check the current directory for nested cfc path
# get the dir this file is in first
this_file = view.file_name()
dir_len = this_file.rfind('/') #(for OSX)
if not dir_len > 0:
dir_len = this_file.rfind('\\') #(for Windows)
this_dir = this_file[:(dir_len + 1)] # adds ending '/'
cfc_file = this_dir + extendspath + ".cfc"
if not os.path.isfile(cfc_file):
# check for the cfc in root folders
for folder in sublime.active_window().folders():
if os.path.isfile(folder + "/" + extendspath + ".cfc"):
cfc_file = folder + "/" + extendspath + ".cfc"
break
try:
add_methods(cfc_file, view.substr(cfc_region).split(".")[-1] )
except UnboundLocalError:
pass
except IOError:
pass
# add this files methods to autocomplete
add_methods(view.file_name(), "this")
# add the completions to the local _completions variable
_completions.extend(completions)
# prevents dups
del completions[:]
return _completions
|
def on_query_completions(self, view, prefix, locations):
if not view.match_selector(locations[0],
"source.cfscript.cfc - text - meta - string - comment"):
return []
if not SETTINGS.get("component_method_completions"):
return
# set local _completions variable
_completions = []
# try and find the cfc file and add it's methods
try:
cfc_region = view.find_by_selector("meta.component-operator.extends.value.cfscript")[0]
except IndexError:
cfc_region = ""
if len(cfc_region):
extendspath = view.substr(cfc_region).replace(".","/")
# first check the current directory for nested cfc path
# get the dir this file is in first
this_file = view.file_name()
dir_len = this_file.rfind('/') #(for OSX)
if not dir_len > 0:
dir_len = this_file.rfind('\\') #(for Windows)
this_dir = this_file[:(dir_len + 1)] # adds ending '/'
cfc_file = this_dir + extendspath + ".cfc"
if not os.path.isfile(cfc_file):
# check for the cfc in root folders
for folder in sublime.active_window().folders():
if os.path.isfile(folder + "/" + extendspath + ".cfc"):
cfc_file = folder + "/" + extendspath + ".cfc"
break
try:
add_methods(view, view.substr(cfc_region).split(".")[-1] )
except UnboundLocalError:
pass
except IOError:
pass
# add this files methods to autocomplete
add_methods(view.file_name(), "this")
# add the completions to the local _completions variable
_completions.extend(completions)
# prevents dups
del completions[:]
return _completions
|
<NME> functioncompletions.py
<BEF> def on_query_completions(self, view, prefix, locations):
if not view.match_selector(locations[0],
"source.cfscript.cfc - text - meta - string - comment"):
return []
if not SETTINGS.get("component_method_completions"):
return
# set local _completions variable
_completions = []
# try and find the cfc file and add it's methods
try:
cfc_region = view.find_by_selector("meta.component-operator.extends.value.cfscript")[0]
except IndexError:
cfc_region = ""
if len(cfc_region):
extendspath = view.substr(cfc_region).replace(".","/")
# first check the current directory for nested cfc path
# get the dir this file is in first
this_file = view.file_name()
dir_len = this_file.rfind('/') #(for OSX)
if not dir_len > 0:
dir_len = this_file.rfind('\\') #(for Windows)
this_dir = this_file[:(dir_len + 1)] # adds ending '/'
cfc_file = this_dir + extendspath + ".cfc"
if not os.path.isfile(cfc_file):
# check for the cfc in root folders
for folder in sublime.active_window().folders():
if os.path.isfile(folder + "/" + extendspath + ".cfc"):
cfc_file = folder + "/" + extendspath + ".cfc"
break
try:
add_methods(view, view.substr(cfc_region).split(".")[-1] )
except UnboundLocalError:
pass
except IOError:
pass
# add this files methods to autocomplete
add_methods(view.file_name(), "this")
# add the completions to the local _completions variable
_completions.extend(completions)
# prevents dups
del completions[:]
return _completions
<MSG> Fix incorrect variable name
<DFF> @@ -34,7 +34,7 @@
cfc_file = folder + "/" + extendspath + ".cfc"
break
try:
- add_methods(view, view.substr(cfc_region).split(".")[-1] )
+ add_methods(cfc_file, view.substr(cfc_region).split(".")[-1] )
except UnboundLocalError:
pass
except IOError:
| 7 |
def on_query_completions(self, view, prefix, locations):
if not view.match_selector(locations[0],
"source.cfscript.cfc - text - meta - string - comment"):
return []
if not SETTINGS.get("component_method_completions"):
return
# set local _completions variable
_completions = []
# try and find the cfc file and add it's methods
try:
cfc_region = view.find_by_selector("meta.component-operator.extends.value.cfscript")[0]
except IndexError:
cfc_region = ""
if len(cfc_region):
extendspath = view.substr(cfc_region).replace(".","/")
# first check the current directory for nested cfc path
# get the dir this file is in first
this_file = view.file_name()
dir_len = this_file.rfind('/') #(for OSX)
if not dir_len > 0:
dir_len = this_file.rfind('\\') #(for Windows)
this_dir = this_file[:(dir_len + 1)] # adds ending '/'
cfc_file = this_dir + extendspath + ".cfc"
if not os.path.isfile(cfc_file):
# check for the cfc in root folders
for folder in sublime.active_window().folders():
if os.path.isfile(folder + "/" + extendspath + ".cfc"):
cfc_file = folder + "/" + extendspath + ".cfc"
break
try:
add_methods(view, view.substr(cfc_region).split(".")[-1] )
except UnboundLocalError:
pass
except IOError:
pass
# add this files methods to autocomplete
add_methods(view.file_name(), "this")
# add the completions to the local _completions variable
_completions.extend(completions)
# prevents dups
del completions[:]
return _completions
|
def on_query_completions(self, view, prefix, locations):
if not view.match_selector(locations[0],
"source.cfscript.cfc - text - meta - string - comment"):
return []
if not SETTINGS.get("component_method_completions"):
return
# set local _completions variable
_completions = []
# try and find the cfc file and add it's methods
try:
cfc_region = view.find_by_selector("meta.component-operator.extends.value.cfscript")[0]
except IndexError:
cfc_region = ""
if len(cfc_region):
extendspath = view.substr(cfc_region).replace(".","/")
# first check the current directory for nested cfc path
# get the dir this file is in first
this_file = view.file_name()
dir_len = this_file.rfind('/') #(for OSX)
if not dir_len > 0:
dir_len = this_file.rfind('\\') #(for Windows)
this_dir = this_file[:(dir_len + 1)] # adds ending '/'
cfc_file = this_dir + extendspath + ".cfc"
if not os.path.isfile(cfc_file):
# check for the cfc in root folders
for folder in sublime.active_window().folders():
if os.path.isfile(folder + "/" + extendspath + ".cfc"):
cfc_file = folder + "/" + extendspath + ".cfc"
break
try:
add_methods(cfc_file, view.substr(cfc_region).split(".")[-1] )
except UnboundLocalError:
pass
except IOError:
pass
# add this files methods to autocomplete
add_methods(view.file_name(), "this")
# add the completions to the local _completions variable
_completions.extend(completions)
# prevents dups
del completions[:]
return _completions
|
var-misuse
|
<NME> errormeasuretest.py
<BEF> def initialize_test(self):
"""Test if calculate throws an error as expected."""
data = [[0.0, 0.0], [1, 0.1], [2, 0.2], [3, 0.3], [4, 0.4]]
tsOrg = TimeSeries.from_twodim_list(data)
tsCalc = TimeSeries.from_twodim_list(data)
bem = BaseErrorMeasure()
try:
bem.initialize(tsOrg, bem)
except NotImplementedError:
pass
else:
assert False # pragma: no cover
assert not bem.initialize(tsOrg, TimeSeries())
<MSG> Fix incorrect variable name
<DFF>
|
def initialize_test(self):
"""Test if calculate throws an error as expected."""
data = [[0.0, 0.0], [1, 0.1], [2, 0.2], [3, 0.3], [4, 0.4]]
tsOrg = TimeSeries.from_twodim_list(data)
tsCalc = TimeSeries.from_twodim_list(data)
bem = BaseErrorMeasure()
try:
bem.initialize(tsOrg, tsCalc)
except NotImplementedError:
pass
else:
assert False # pragma: no cover
assert not bem.initialize(tsOrg, TimeSeries())
|
def initialize_test(self):
"""Test if calculate throws an error as expected."""
data = [[0.0, 0.0], [1, 0.1], [2, 0.2], [3, 0.3], [4, 0.4]]
tsOrg = TimeSeries.from_twodim_list(data)
tsCalc = TimeSeries.from_twodim_list(data)
bem = BaseErrorMeasure()
try:
bem.initialize(tsOrg, bem)
except NotImplementedError:
pass
else:
assert False # pragma: no cover
assert not bem.initialize(tsOrg, TimeSeries())
|
<NME> errormeasuretest.py
<BEF> def initialize_test(self):
"""Test if calculate throws an error as expected."""
data = [[0.0, 0.0], [1, 0.1], [2, 0.2], [3, 0.3], [4, 0.4]]
tsOrg = TimeSeries.from_twodim_list(data)
tsCalc = TimeSeries.from_twodim_list(data)
bem = BaseErrorMeasure()
try:
bem.initialize(tsOrg, bem)
except NotImplementedError:
pass
else:
assert False # pragma: no cover
assert not bem.initialize(tsOrg, TimeSeries())
<MSG> Fix incorrect variable name
<DFF> @@ -7,7 +7,7 @@
bem = BaseErrorMeasure()
try:
- bem.initialize(tsOrg, bem)
+ bem.initialize(tsOrg, tsCalc)
except NotImplementedError:
pass
else:
| 8 |
def initialize_test(self):
data = [[0.0, 0.0], [1, 0.1], [2, 0.2], [3, 0.3], [4, 0.4]]
tsOrg = TimeSeries.from_twodim_list(data)
tsCalc = TimeSeries.from_twodim_list(data)
bem = BaseErrorMeasure()
try:
bem.initialize(tsOrg, bem)
except NotImplementedError:
pass
else:
assert False # pragma: no cover
assert not bem.initialize(tsOrg, TimeSeries())
|
def initialize_test(self):
data = [[0.0, 0.0], [1, 0.1], [2, 0.2], [3, 0.3], [4, 0.4]]
tsOrg = TimeSeries.from_twodim_list(data)
tsCalc = TimeSeries.from_twodim_list(data)
bem = BaseErrorMeasure()
try:
bem.initialize(tsOrg, tsCalc)
except NotImplementedError:
pass
else:
assert False # pragma: no cover
assert not bem.initialize(tsOrg, TimeSeries())
|
var-misuse
|
<NME> manifest.py
<BEF> def testDependentServiceExtension(self):
"""Assigning more references to an attribute"""
importConfigurationManifest(
'wdrtest/manifests/references/dependent_service.wdrc', topology
)
importConfigurationManifest(
'wdrtest/manifests/references/dependent_service2.wdrc', topology
)
server = getid1(
'/Cell:%(cellName)s/Node:%(nodeName)s/Server:%(serverName)s/'
% topology
)
referenceList = server.lookup1(
'CustomService',
{
'displayName': 'with dependencies',
},
'customServices'
).prerequisiteServices
self.assertEquals(len(self), 5)
self.assertEquals(referenceList[0].displayName, 'first')
self.assertEquals(referenceList[1].displayName, 'second')
self.assertEquals(referenceList[2].displayName, 'fifth')
self.assertEquals(referenceList[3].displayName, 'third')
self.assertEquals(referenceList[4].displayName, 'fourth')
<MSG> Fix incorrect variable name
<DFF>
|
def testDependentServiceExtension(self):
"""Assigning more references to an attribute"""
importConfigurationManifest(
'wdrtest/manifests/references/dependent_service.wdrc', topology
)
importConfigurationManifest(
'wdrtest/manifests/references/dependent_service2.wdrc', topology
)
server = getid1(
'/Cell:%(cellName)s/Node:%(nodeName)s/Server:%(serverName)s/'
% topology
)
referenceList = server.lookup1(
'CustomService',
{
'displayName': 'with dependencies',
},
'customServices'
).prerequisiteServices
self.assertEquals(len(referenceList), 5)
self.assertEquals(referenceList[0].displayName, 'first')
self.assertEquals(referenceList[1].displayName, 'second')
self.assertEquals(referenceList[2].displayName, 'fifth')
self.assertEquals(referenceList[3].displayName, 'third')
self.assertEquals(referenceList[4].displayName, 'fourth')
|
def testDependentServiceExtension(self):
"""Assigning more references to an attribute"""
importConfigurationManifest(
'wdrtest/manifests/references/dependent_service.wdrc', topology
)
importConfigurationManifest(
'wdrtest/manifests/references/dependent_service2.wdrc', topology
)
server = getid1(
'/Cell:%(cellName)s/Node:%(nodeName)s/Server:%(serverName)s/'
% topology
)
referenceList = server.lookup1(
'CustomService',
{
'displayName': 'with dependencies',
},
'customServices'
).prerequisiteServices
self.assertEquals(len(self), 5)
self.assertEquals(referenceList[0].displayName, 'first')
self.assertEquals(referenceList[1].displayName, 'second')
self.assertEquals(referenceList[2].displayName, 'fifth')
self.assertEquals(referenceList[3].displayName, 'third')
self.assertEquals(referenceList[4].displayName, 'fourth')
|
<NME> manifest.py
<BEF> def testDependentServiceExtension(self):
"""Assigning more references to an attribute"""
importConfigurationManifest(
'wdrtest/manifests/references/dependent_service.wdrc', topology
)
importConfigurationManifest(
'wdrtest/manifests/references/dependent_service2.wdrc', topology
)
server = getid1(
'/Cell:%(cellName)s/Node:%(nodeName)s/Server:%(serverName)s/'
% topology
)
referenceList = server.lookup1(
'CustomService',
{
'displayName': 'with dependencies',
},
'customServices'
).prerequisiteServices
self.assertEquals(len(self), 5)
self.assertEquals(referenceList[0].displayName, 'first')
self.assertEquals(referenceList[1].displayName, 'second')
self.assertEquals(referenceList[2].displayName, 'fifth')
self.assertEquals(referenceList[3].displayName, 'third')
self.assertEquals(referenceList[4].displayName, 'fourth')
<MSG> Fix incorrect variable name
<DFF> @@ -17,7 +17,7 @@
},
'customServices'
).prerequisiteServices
- self.assertEquals(len(self), 5)
+ self.assertEquals(len(referenceList), 5)
self.assertEquals(referenceList[0].displayName, 'first')
self.assertEquals(referenceList[1].displayName, 'second')
self.assertEquals(referenceList[2].displayName, 'fifth')
| 9 |
def testDependentServiceExtension(self):
importConfigurationManifest(
'wdrtest/manifests/references/dependent_service.wdrc', topology
)
importConfigurationManifest(
'wdrtest/manifests/references/dependent_service2.wdrc', topology
)
server = getid1(
'/Cell:%(cellName)s/Node:%(nodeName)s/Server:%(serverName)s/'
% topology
)
referenceList = server.lookup1(
'CustomService',
{
'displayName': 'with dependencies',
},
'customServices'
).prerequisiteServices
self.assertEquals(len(self), 5)
self.assertEquals(referenceList[0].displayName, 'first')
self.assertEquals(referenceList[1].displayName, 'second')
self.assertEquals(referenceList[2].displayName, 'fifth')
self.assertEquals(referenceList[3].displayName, 'third')
self.assertEquals(referenceList[4].displayName, 'fourth')
|
def testDependentServiceExtension(self):
importConfigurationManifest(
'wdrtest/manifests/references/dependent_service.wdrc', topology
)
importConfigurationManifest(
'wdrtest/manifests/references/dependent_service2.wdrc', topology
)
server = getid1(
'/Cell:%(cellName)s/Node:%(nodeName)s/Server:%(serverName)s/'
% topology
)
referenceList = server.lookup1(
'CustomService',
{
'displayName': 'with dependencies',
},
'customServices'
).prerequisiteServices
self.assertEquals(len(referenceList), 5)
self.assertEquals(referenceList[0].displayName, 'first')
self.assertEquals(referenceList[1].displayName, 'second')
self.assertEquals(referenceList[2].displayName, 'fifth')
self.assertEquals(referenceList[3].displayName, 'third')
self.assertEquals(referenceList[4].displayName, 'fourth')
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.