id stringlengths 20 20 | title stringclasses 1
value | text stringlengths 8 768k |
|---|---|---|
ff54d21ed98c3fc44f51 | def is_connected(self):
return self._bluetooth.is_connected() | |
ff550cbf1f3e313d181c | def _set_key_id(self, v, load=False):
if hasattr(v, "_utype"):
v = v._utype(v)
try:
t = YANGDynClass(v,base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..65535']},int_size=16), is_leaf=True, yang_name="key-id", parent=self, path_helper=self._path_helper, extmethods=self._extmeth... | |
ff550d7ed7257060a5d1 | def table(self):
return _generate_validated_table(self) | |
ff55405ec7622214cbf1 | def execute_and_display (command):
proc = subprocess.Popen(command, stdout=subprocess.PIPE)
(out, err) = proc.communicate()
return out.strip() | |
ff5553a740956d480994 | def update(self, delta_time):
pass | |
ff5565d162ce937c5e6d | def genSirTrace(self,G,startnodes,evol,modelparams=None):
if evol == "static":
allnodes = G.nodes()
elif evol == "dynamic":
self.MAXSPREADTIME = max(G.keys()) + 1
allnodes = set([node for time in G.keys() for node in G[time].nodes()])
nons2ipertime = {(node1,node2)... | |
ff557077836e84279341 | def iter(self, value):
self._iter = value | |
ff55769708dcc3cb8bde | def HandleJump(self):
self.__jump_affect.play()
if self.__player.getFacing() == "right":
self.__player.JumpNorthEast(self.__board)
self.HandleJumpUpdate()
self.__player.JumpNorthEast(self.__board)
self.HandleJumpUpdate()
self.__player.JumpSout... | |
ff5589e12b1ba09fd97a | def construct_search_space():
activation = hp.choice('activation', ['sigmoid', 'relu', 'hard_sigmoid'])
random_state = np.random.randint(500)
contamination = hp.choice('contamination', [0.5, 0.4, 0.3])
space_config = hp.choice('classifier_type', [
{
'type': 'iforest', 'contamination... | |
ff558c43e7bef8059642 | def find(self,selectors):
querySet = QuerySet()
for item in self:
querySet.append(item.find(selectors))
return querySet | |
ff558cd8dd983c77c937 | def output_json(ratings, filename):
with open(filename, 'w') as f:
json.dump(ratings, f, indent=4)
f.write('\n') | |
ff55af5fa4ecf2d10572 | def add_get_config(f):
def wrapper(*args, **kwargs):
signatures = list(inspect.signature(f).parameters.keys())
argdict = {sig: arg for sig, arg in zip(signatures[1:], args[1:])}
argdict.update(kwargs)
object.__setattr__(args[0], 'argdict', argdict)
f(*args, **kwargs)
... | |
ff55b7e20393aee7a33f | def get_expire_delta(self):
return (self.expires - timezone.now()).seconds | |
ff55c1ee8c77ac8f9a21 | def defineModel():
model = Sequential()
model.add(Conv2D(32, (3, 3), activation='relu', kernel_initializer='he_uniform', input_shape=(28, 28, 1)))
model.add(BatchNormalization())
model.add(MaxPooling2D((2, 2)))
model.add(Conv2D(64, (3, 3), activation='relu', kernel_initi... | |
ff55c21171e464c791b4 | def evaluate_policies(all_weights, no_weights, no_episodes, algorithm, representation):
# extract the value function type from the algorithm string
val_fun_type = algorithm.split("_")
if len(val_fun_type) == 2:
if val_fun_type[1] == "v" or val_fun_type[1] == "q":
val_fun_type = val_fun_t... | |
ff55d1ba3e1aa8166d30 | def test_tox_environments_includes_python_versions():
tox_environments = set(
itertools.chain.from_iterable(
e.split("-")
for e in subprocess.check_output(["tox", "-l"]).decode().splitlines()
)
)
pyenv_versions = [
"py{}{}".format(*v.split(".")[0:2])
... | |
ff55ddffc0aa3f4732c6 | def save(self):
if self.id:
database.data_query("UPDATE Tasks SET `name` = ?, done = ? WHERE id = ?", (self.name, self.done, self.id))
else:
database.data_query("INSERT INTO Tasks (`name`, done) VALUES (?, ?)", (self.name, self.done)) | |
ff56017e4b04676cda49 | def is_palindrome(data: str or int) -> str:
if type(data) is not str and type(data) is not int:
return "ERROR: Input value is not 'int' or 'str', but '{}'".format(
type(data))
data = str(data).lower().replace(' ', '')
if len(data) == 1:
return 'YES'
res = lambda d: [d[i] == d... | |
ff5614be2e9324339ed8 | def model(self) -> 'Model':
from prescience_client.bean.model import Model
return Model(json=self.initial_payload.get('model'), prescience=self.prescience) | |
ff562aa53d77b331fca4 | def initial_setup(self):
if self.renv_path.exists():
self.logger.error("The renv path you have set already exists: %s" % self.renv_path)
elif not self.renv_path.exists():
self.logger.info("Initializing renv for the first time...")
init_cookie = self.cookie_jar / Path(... | |
ff56315494d83a78933a | def _get_inner_items(self) -> Iterable:
return self.iterable_object | |
ff56337e0fc262f659c6 | def test_root_request(client):
rv = client.get('/')
assert 301 == rv.status_code
assert 'https://www.suse.com/solutions/public-cloud/' == rv.location | |
ff5676d41d54a8ad4e2e | def ptax():
# Confirm value is a number that is between 1e3 and 1e12
# In the future, make this handle dollar signs and commas and anything else MLS throws our way.
value = request.query.value
if not value:
response.status = 400
return {"error": "No value provided"}
try:
va... | |
ff568f26c44377032fd4 | def __gettablename__(self):
return "Se_Ofrece" | |
ff56b2f1240965b02033 | def _configure_logging(level, filename):
try:
os.makedirs(os.path.dirname(PATHS.LOG_FILE))
except OSError as e:
if e.errno != errno.EEXIST:
raise
logging.basicConfig(filename=filename,
format=DEFAULT_LOG_FORMAT,
level=level)
glo... | |
ff56dbc66ca4c8f7698d | def make_trust_anchor(self, name, https=False):
subj_str_to_use = self.subj_str
if https:
subj_str_to_use = self.https_subj_str
cmd = ["openssl", "req", "-new", "-x509", "-nodes",
"-keyout", "{0}/{1}_key.pem".format(self.keys_d... | |
ff56feebe4d236768505 | def __getitem__(self, key):
return self.root[key].content[0] | |
ff573660f6e7474d4364 | def train(self):
self._create_dirs()
self._save_model_metadata()
self.model.fit_generator(self.feeder.yield_batches(self.batch_size, "train"),
steps_per_epoch=self.feeder.get_steps_per_epoch(self.batch_size, "train"),
nb_epoch=se... | |
ff5739638f72b00cf27d | def __density(self, x):
f = np.power(1 - self.p, x - 1) * self.p
return f | |
ff573af2f246bf8e9e20 | def _test_delete_environment(self):
runner = CliRunner()
LOG.info("Deleting Environment {}".format(ENV_2_NAME))
result = runner.invoke(
cli, ["delete", "environment", ENV_2_NAME, "--project", self.project_name]
)
if result.exit_code:
cli_res_dict = {"Out... | |
ff5785239e36c1f751c2 | def reduce_repetitions(word: str, atoms):
tmp = word
for el in atoms:
tmp = tmp.replace(el + el, '')
while tmp != word:
word = tmp
for el in atoms:
tmp = tmp.replace(el + el, '')
return tmp | |
ff57a30d8598bc6359c4 | def list_names(self):
return list(chain.from_iterable(self.names.values())) | |
ff57c305b1f36bfdc1fe | def should_validate(self, value):
return bool(value) | |
ff57c41a475bc2ec134f | def readSerial(self,):
msg = self.ser.read(2)
return msg | |
ff580ed3a29fd47e8399 | def test_delete_unknown_item(self):
resp = self.app.delete(
"/api{0}/{1}".format(BASE_URL, -111), # -111 is a fake id
content_type=CONTENT_TYPE_JSON,
)
self.assertEqual(resp.status_code, status.HTTP_204_NO_CONTENT) | |
ff580ee4018e731b95be | def lower(self):
dlb, _ = self.domain.bounds()
if self._lb is None:
return dlb
elif dlb is None:
return self._lb
# _process_bound() guarantees _lb is not potentially variable
return NPV_MaxExpression((self._lb, dlb)) | |
ff5876ebdd3acf418d42 | def connect():
conn = None
try:
# read connection parameters
# connect to the PostgreSQL server
# local
# params = {'database': bot_conf.TELEGA_DB_NAME,
# 'user': bot_conf.TELEGA_DB_USER,
# 'password': bot_conf... | |
ff5896ef0423d92ef044 | def test_revision_metadata_update_on_update(self):
client = TurboTestClient(revisions_enabled=True, servers={"default": self.server})
client2 = TurboTestClient(revisions_enabled=True, servers={"default": self.server})
pref1 = client.create(self.ref)
client.upload_all(self.ref)
... | |
ff5899346bf5daa93bf4 | def is_link(path, use_sudo=False):
func = use_sudo and run_as_root or run
with settings(hide('running', 'warnings'), warn_only=True):
return func('[ -L "%(path)s" ]' % locals()).succeeded | |
ff58aeaafc163a482ef7 | def onHelp(self, event=None):
self.app.followLink(url=self.helpUrl) | |
ff58c92103610a5ee0ea | def _ParseLogLine(self, parser_mediator, structure):
event_data = IISEventData()
event_data.cs_cookie = self._GetValueFromStructure(structure, 'cs_cookie')
event_data.cs_host = self._GetValueFromStructure(structure, 'cs_host')
event_data.cs_referrer = self._GetValueFromStructure(
structure, 'cs_... | |
ff58d16f41fed386e13e | def pick_frames(video): | |
ff58d3eec329b2e0e922 | def new_env_name():
while True:
name = input("New Envelope Name: ")
if name is not '' and not None:
if len(name) > 20:
print("That name is too long, please use another name.")
else:
return name
else:
print("You didn't enter ... | |
ff58f32fd7fcba5064fd | def _load(self, DataControl):
self._unload()
self.datacontainer = DataControl()
# get node mapping data from service
rootnode = self.datacontainer.gather()
if not rootnode:
return
self._map_treeitems(rootnode) | |
ff5902858cd5451e7271 | def gen_array(draw: Any) -> Dict[str, JSONType]:
min_size = draw(st.none() | st.integers(0, 5))
max_size = draw(st.none() | st.integers(2, 5))
if min_size is not None and max_size is not None and min_size > max_size:
min_size, max_size = max_size, min_size
items = draw(
... | |
ff590ee35aadc8e484c3 | def tokenize(text):
text = text.lower()
text = re.sub('[' + string.punctuation + '0-9\\r\\t\\n]', ' ', text)
tokens = nltk.word_tokenize(text)
tokens = [w for w in tokens if len(w) > 2] # ignore a, an, to, at, be, ...
... | |
ff59173c0b566526bac9 | async def gather_all_information(self) -> list:
vehicles = []
cars = await self.api.get_vehicles_endpoint()
if cars:
for car in cars:
vehicle = await self.get_vehicle_information(car)
vehicles.append(vehicle)
return vehicles | |
ff59173e2176e8a6c15d | def decode(self):
binzip = base64.b64decode(self.data)
self.data = None
binpack = zlib.decompress(binzip)
del binzip
_count = self.size.voxelCount
bindata = struct.unpack("{}{}{}".format(ENDIANNESS[self.endianness], _count, FORMAT_CHARS[self.mode]), binpack)
del b... | |
ff5926c178aa2c41344b | def model_fields(self):
return [field for field in self if
not (field.name.startswith('_') or field.name in ['select_across', 'action'])] | |
ff5939c5b47ab895b5c1 | def is_repo_clean(self):
pass | |
ff594072aa7d0aef3438 | def stash_config(dct):
with open('h5config.json', 'w') as f:
json.dump(dct, f) | |
ff594ce800a0fffc6ab7 | def __str__(self) -> str:
return str(self.header) | |
ff595a4ef5622d176743 | def get(self, key):
if key is not None and key in self.cache_data:
return self.cache_data[key]
return None | |
ff5963fe7b826761ee32 | def rm_file_duplicates( self ):
# regenerate files list
new_files = []
for f in self.files:
if f not in new_files:
new_files.append(f)
self.files = new_files
# reload objects
self.load_file_objects(Identifier, File) | |
ff5983b9e195eb45586e | def sentence_score(log_probs,sentence):
scores=word_scores(log_probs,sentence)
score=reduce(add,scores)
return score | |
ff5994f84ee1e0348d0c | def data(self, new_data):
pass # pragma: no cover | |
ff59acf102e1ecf0b62c | def __init__(self):
self.__node = None | |
ff59b02e9fb65569589f | def go_user(self, event):
self.show_frame(PageOne) | |
ff59b94f0ec18cdb3110 | def displayAll(self):
any = 0
for dp in Display.displayList:
if not any:
print """Auto-display expressions now in effect:
Num Enb Expression"""
any = 1
dp.params()
return any | |
ff59c92aea5e12a1ed7e | def num_players(self):
return lib.NumPlayers(self._game) | |
ff59cef1cb1978ebfa7c | def _gaussian(self, x, mu, covar):
if isinstance(mu, np.ndarray) or isinstance(mu, list):
n = len(mu)
x = np.reshape(x, (-1))
mu = np.reshape(mu, (-1))
covar_inv = np.linalg.inv(covar)
cst = 1 / ((2*np.pi)**n * np.linalg.norm(covar)) ** .5
... | |
ff5a3b26f252b9cfd69d | def win_loss_ratio(self):
logging.info("BaseAgent:win_loss_ratio:%s", self.id)
logging.debug("BaseAgent:win_loss_ratio:Wins %s", self.num_wins)
logging.debug("BaseAgent:win_loss_ratio:Losses %s", self.num_losses)
if self.num_losses == 0:
return None
ratio = self.num_w... | |
ff5a487a5e29ab93ab85 | def __init__(self,
hyperparams,
proto_handler,
data_handler,
fl_model=None,
**kwargs):
if fl_model is None:
spec = data_handler.get_dataset_info()
fl_model = DTFLModel(None, spec)
super().__init_... | |
ff5a7b76d99e52b73485 | def get_bounds(self):
return bounds_of_points([node.pos for node in self.nodelist]) | |
ff5a88d5f52e305ba768 | def _weak_decorator(func):
def decorator(cls, *args, **kwargs):
result = func(cls, *args, **kwargs)
if isinstance(result, weakref.ref):
return result()
instanceID = result._instanceID
if getattr(result, 'reapable', False):
namespace['entities'].get(
... | |
ff5a94cfa3ebbd30305a | def close(self):
try:
# Byte1('X') - Identifies the message as a terminate message.
# Int32(4) - Message length, including self.
self._write(TERMINATE_MSG)
self._flush()
self._sock.close()
except AttributeError:
raise ConnectionClos... | |
ff5aa0611f4fee19068a | def get_gpg_homedir_and_context(passphrase, algorithm="rsa2048"):
with get_temporary_directory() as gpg_home_dir:
# gpg_home_dir is now fsync'ed
with gpg.Context(
home_dir=gpg_home_dir,
armor=True,
offline=True,
pinentry_mode=gpg.constants.PINENTRY_MOD... | |
ff5ad3c84bdcd791cdc6 | def create_rank(stats):
rank = rank_obj()
if stats.TotalGameCount > 0:
rank.damage_score = damage_score(stats.AverageDamageDealt)
rank.kill_score = kill_score(stats.AverageKills)
rank.distance_score = distance_score(stats.AverageWalkDistance)
rank.supply_score = stats.AverageSupplyScore
rank.survival_score ... | |
ff5ad56a667b7fa6508b | def get_container_dic(self):
if self.__is_container():
return self.__container_dic | |
ff5b1e5eaf0ee715ffa3 | def itergroup(iterable, size):
group = []
for item in iterable:
group.append(item)
if len(group) == size:
yield group
group = []
if group:
yield group | |
ff5b31b35e596ff21307 | def last_updated(self, last_updated):
self._last_updated = last_updated | |
ff5b376092240820c377 | def root_volume_size_gib(self) -> Optional[int]:
return pulumi.get(self, "root_volume_size_gib") | |
ff5b399880273f19b980 | def test_lineendings(): | |
ff5b5db5036f560889e0 | def all_for_user(self, user):
try:
follow = Follower.objects.get(user=user)
except Follower.DoesNotExist:
follow = None
own_feed = self.filter(sender_object_id=user.id)
if follow and follow.following.count() > 0:
following_feed = self.filter(
... | |
ff5b70295a7f42744081 | def test_transformation(self):
file = os.path.join('tests', 'data', 'positionfixes.csv')
pfs = ti.read_positionfixes_csv(file, sep=';', crs='EPSG:4326', index_col=None)
pfs_2056 = pfs.to_crs("EPSG:2056")
pfs_4326 = ti.visualization.util.transform_gdf_to_wgs84(pfs_2056)
assert_ge... | |
ff5b7e1f32dd745c7cbc | def numUpdate(self, numArray):
for iSpecies in range(self.NSpecies):
self.SpeciesList[iSpecies].SetN(numArray[iSpecies]) | |
ff5b864662a4bd459c86 | def execute_cl_tool():
# parse command line arguments
args = ehyd_arg_parser()
# convert argparse object to dict
args_dict = vars(args).copy()
args_dict['id_'] = args.id
del args_dict['id']
args_dict['input_'] = args.input
del args_dict['input']
run_script(**args_dict) | |
ff5b8cb28fb53b4e054a | def dict2str(arg_dict):
arg_str = ''
for key, value in list(arg_dict.items()):
if value != '':
arg_str += '{}="{}",'.format(key, value)
if arg_str:
return arg_str[:-1] # remove last comma
else:
return '' | |
ff5ba4672a471a55b4fa | def evaluate_coco(model, dataset, coco, eval_type="bbox", limit=0, image_ids=None):
# Pick COCO images from the dataset
#image_ids = image_ids or dataset.image_ids
#image_ids = dataset_train.image_ids
image_ids = dataset.image_ids
# Limit to a subset
if limit:
image_ids = imag... | |
ff5bab4fe3aa21296e07 | def _key_to_str(self, key):
if isinstance(key, (tuple, list)):
key = str(tuple(key))
else:
key = str(key)
return self._join_path(self.fs, [self.root, key]) if self.root else key | |
ff5bae319f406b79455b | def organization(self):
return self._get_field("organization") | |
ff5bc5a4e5abaabb2f72 | def save(self, *args, **kwargs):
if not self.slug:
self.slug = re.sub('[^\w]+', '-', self.title.lower()).strip('-')
ret = super(Entry, self).save(*args, **kwargs)
# Store search content.
self.update_search_index()
return ret | |
ff5bc7d6f747161ae556 | def i_did_something(cls):
cls.last_dtime_i_did_something = datetime.datetime.now() | |
ff5bdb495cd65d26c723 | def push(self, obj):
self.__list.append(obj)
self._count += 1 | |
ff5bf9e81666de9a2fc6 | def getvalue(value, path, default=None):
paths = path.split(".")
return get_nested(value, *paths, default=default) | |
ff5c0ba2d7c791b24130 | def ignore(function):
function.no_log = True
return function | |
ff5c203241d414b2534c | def filter_by_dur(master_array, dur_thresh):
cur_state = master_array[0, 6]
last_count, count = 0, 0
bouts_dropped_locs = set()
for row, state in enumerate(master_array[:, 6]):
if state == cur_state:
count += 1
elif count >= dur_thresh:
last_count = count
count = 0
cur_state = state
e... | |
ff5c31bd8cd381ada1f3 | def verify(self):
try:
self.image_corners()
self.corner_distances()
self.dimensions()
self.fov()
self.processing()
except KeyError:
raise ManifestError("Invalid manifest structure") | |
ff5c4281ab599cc9ee5c | def create_comp_session(session_user, session_password, session_alias='bscs'):
auth = (session_user, session_password)
session_create = RequestsLibrary.RequestsLibrary()
return session_create.create_session(session_alias, variables.RESTURL, auth=auth) | |
ff5c8d8eb30fbeebdbc6 | def build_update(self):
to_build = self.get_outdated_docs()
if isinstance(to_build, str):
self.build(['__all__'], to_build)
else:
to_build = list(to_build)
self.build(to_build,
summary='targets for %d source files that are '
... | |
ff5c9805b9a9d1ba9a70 | def is_within_range_of(self,x,y):
if self.square_of_range_difference_from(x,y) <= self.rangesqrd:
return True
else:
return False | |
ff5cecd5dfca5c53ab6b | def svn_fs_make_file(svn_fs_root_t_root, char_path, apr_pool_t_pool): # real signature unknown; restored from __doc__
pass | |
ff5cf609a1d066e0467e | def get_elevation(self):
#check if it is a slope or not to make sure we are accessing
#an element that exists for the instance
if not self.slope:
return [self.highest_elevation]
else:
return [self.highest_elevation,self.lowest_elevation] | |
ff5d2fae448a0c259a69 | def getNamespace(self):
pass; | |
ff5d4157aa95bc7fcc83 | async def choose(self, ctx, *, msg: str):
choices = msg.split(',')
c = randint(0, len(choices)-1)
return await ctx.send(str(choices[c])) | |
ff5d444a7f97c2c81322 | def set_header(self, name, value):
self._headers.replace(name, value) | |
ff5d53aff0c800528b1c | def order_codecs_in_codeclist(self, codeclist, codecs_to_set, **kwargs):
codec_lists = self.get_all_codeclists()
codecs = self.get_all_codecs()
cl_id = None
for cl in codec_lists['rows']:
if codeclist == cl['cell'][0]:
cl_id = cl['id']
break
... | |
ff5d6db06eadb7190385 | def reset_graph(graph):
for node in graph._nodes:
node._traceback_arc = None
node._settled = False
node._distance = -1 | |
ff5d771d78c9b2d420ff | def test_jira_configurations_list(self):
pass | |
ff5d9ad7ea19ef0a3eff | def put(self,request,pk=None):
return Response({'method':'PUT'}) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.