name stringclasses 844
values | input_types listlengths 0 100 | output_type stringlengths 1 419 | code stringlengths 34 233k | dependencies listlengths 0 6 | lib_used listlengths 0 11 | imports listlengths 0 66 | line_count int64 3 199 | full_code stringlengths 39 1.01M | input_type_defs listlengths 1 12 ⌀ |
|---|---|---|---|---|---|---|---|---|---|
v0 | [
"Any",
"Any"
] | torch.Tensor | def v0(self, v1, v2) -> torch.Tensor:
v3 = v2.shape[0]
v4 = v1.shape[0]
v5 = self.model.covar_module(v1, v2).evaluate()
v6 = self.model.covar_module.base_kernel.lengthscale.detach()
return -torch.eye(self.model.D, device=v2.device) / v6 @ ((v1.view(v4, 1, self.model.D) - v2.view(1, v3, self.model.D)... | [] | [
"torch"
] | [
"import torch"
] | 6 | from typing import Tuple
import torch
import gpytorch
import botorch
from src.cholesky import one_step_cholesky
class GradientInformation(botorch.acquisition.AnalyticAcquisitionFunction):
'''Acquisition function to sample points for gradient information.
Attributes:
model: Gaussian process model th... | null |
v0 | [
"xr.Dataset",
"xr.Dataset"
] | Any | def v0(v1: xr.Dataset, v2: xr.Dataset):
v3 = v2['dxu']
v4 = v2['dyu']
v5 = v1.diff(dim='xu_ocean') / v3
v6 = v1.diff(dim='yu_ocean') / v4
v7 = dict(xu_ocean=v1.coords['xu_ocean'], yu_ocean=v1.coords['yu_ocean'])
v5 = v5.interp(v7)
v6 = v6.interp(v7)
(v8, v9) = (v1['usurf'], v1['vsurf'])
... | [] | [
"xarray"
] | [
"import xarray as xr"
] | 13 | #!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Wed Feb 19 12:15:35 2020
@author: arthur
"""
import xarray as xr
from scipy.ndimage import gaussian_filter
import numpy as np
import logging
def advections(u_v_field: xr.Dataset, grid_data: xr.Dataset):
"""
Return the advection terms correspondin... | null |
v0 | [
"np.ndarray",
"float"
] | Any | def v0(v1: np.ndarray, v2: float):
v3 = np.zeros_like(v1)
for v4 in range(v1.shape[0]):
v5 = v1[v4, ...]
v6 = gaussian_filter(v5, v2, mode='constant')
v3[v4, ...] = v6
return v3 | [] | [
"numpy",
"scipy"
] | [
"from scipy.ndimage import gaussian_filter",
"import numpy as np"
] | 7 | #!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Wed Feb 19 12:15:35 2020
@author: arthur
"""
import xarray as xr
from scipy.ndimage import gaussian_filter
import numpy as np
import logging
def advections(u_v_field: xr.Dataset, grid_data: xr.Dataset):
"""
Return the advection terms correspondin... | null |
v27 | [
"xr.Dataset",
"xr.Dataset",
"int",
"str",
"str",
"str",
"Any"
] | xr.Dataset | def v27(v28: xr.Dataset, v29: xr.Dataset, v30: int, v31: str='mean', v32: str='zero', v33: str='factor', v34=False) -> xr.Dataset:
if v32 == 'zero':
v28 = v28.fillna(0.0)
if v33 == 'factor':
print('Using factor mode')
v35 = v30
v36 = v30
v37 = (v35 / 2, v36 / 2)
v38 = v0(... | [
{
"name": "v0",
"input_types": [
"xr.Dataset",
"xr.Dataset"
],
"output_type": "Any",
"code": "def v0(v1: xr.Dataset, v2: xr.Dataset):\n v3 = v2['dxu']\n v4 = v2['dyu']\n v5 = v1.diff(dim='xu_ocean') / v3\n v6 = v1.diff(dim='yu_ocean') / v4\n v7 = dict(xu_ocean=v1.coord... | [
"logging",
"numpy",
"scipy",
"xarray"
] | [
"import xarray as xr",
"from scipy.ndimage import gaussian_filter",
"import numpy as np",
"import logging"
] | 32 | #!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Wed Feb 19 12:15:35 2020
@author: arthur
"""
import xarray as xr
from scipy.ndimage import gaussian_filter
import numpy as np
import logging
def advections(u_v_field: xr.Dataset, grid_data: xr.Dataset):
"""
Return the advection terms correspondin... | null |
v0 | [
"str"
] | Any | def v0(self, v1: str, **v2):
self.policy_network = tf.keras.models.load_model(v1, compile=False)
self.target_network = tf.keras.models.clone_model(self.policy_network)
self.target_network.trainable = False | [] | [
"tensorflow"
] | [
"import tensorflow as tf"
] | 4 | # Copyright 2020 The TensorTrade Authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to... | null |
v0 | [
"str"
] | Any | def v0(self, v1: str, **v2):
v3: int = v2.get('episode', None)
if v3:
v4 = self.id[:7] + '__' + datetime.now().strftime('%Y%m%d_%H%M%S') + '.hdf5'
v5 = 'actor_network__' + v4
v6 = 'critic_network__' + v4
else:
v5 = 'actor_network__' + self.id[:7] + '__' + datetime.now().strft... | [] | [
"datetime"
] | [
"from datetime import datetime"
] | 11 | # Copyright 2019 The TensorTrade Authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to... | null |
v0 | [
"np.ndarray"
] | int | def v0(self, v1: np.ndarray, **v2) -> int:
v3: float = v2.get('threshold', 0)
v4 = random.random()
if v4 < v3:
return np.random.choice(self.n_actions)
else:
return np.argmax(self.policy_network(np.expand_dims(v1, 0))) | [] | [
"numpy",
"random"
] | [
"import random",
"import numpy as np"
] | 7 | # Copyright 2020 The iqt Authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writ... | null |
v0 | [
"Any",
"pd.DataFrame",
"Any"
] | Any | def v0(self, v1, v2: pd.DataFrame, v3=False):
self.reset(self.ivar)
self.test_mode = v3
pass
self.df = pd.DataFrame()
self.idx += len(v2) - 1
self.n_supports = []
self.avg_strength = []
self.started = True
self.time = datetime.now()
for v4 in range(max(0, len(v2) - self.lookback_... | [] | [
"datetime",
"pandas"
] | [
"from datetime import datetime",
"import pandas as pd"
] | 15 | import math
from datetime import datetime
import pandas as pd
from settings import IVarType
from util.langUtil import try_divide
class ClassicSupportFinder:
ARGS_DICT = {
'distinguishing_constant': {
'default': 10,
'range': [1, 30],
'step': 0.05,
'comment'... | null |
v0 | [
"str"
] | str | def v0(self, v1: str) -> str:
if not v1 and (not self.default_metric):
raise ValueError('No `metric` has been passed and `default_metric` has not been set. Please specify the `metric` parameter.')
return v1 or self.default_metric | [] | [] | [] | 4 | import json
import logging
import os
from numbers import Number
from typing import Any, Dict, List, Optional, Tuple
from ray.tune.utils import flatten_dict
from ray.tune.utils.serialization import TuneFunctionDecoder
from ray.tune.utils.util import is_nan_or_inf
try:
import pandas as pd
from pandas import Dat... | null |
v0 | [
"str"
] | str | def v0(self, v1: str) -> str:
if not v1 and (not self.default_mode):
raise ValueError('No `mode` has been passed and `default_mode` has not been set. Please specify the `mode` parameter.')
if v1 and v1 not in ['min', 'max']:
raise ValueError('If set, `mode` has to be one of [min, max]')
ret... | [] | [] | [] | 6 | import json
import logging
import os
from numbers import Number
from typing import Any, Dict, List, Optional, Tuple
from ray.tune.utils import flatten_dict
from ray.tune.utils.serialization import TuneFunctionDecoder
from ray.tune.utils.util import is_nan_or_inf
try:
import pandas as pd
from pandas import Dat... | null |
v0 | [
"Optional[str]",
"Optional[str]",
"str"
] | Optional[Dict] | def v0(self, v1: Optional[str]=None, v2: Optional[str]=None, v3: str='last') -> Optional[Dict]:
v4 = self.get_best_trial(v1, v2, v3)
return v4.config if v4 else None | [] | [] | [] | 3 | import json
import logging
import os
from numbers import Number
from typing import Any, Dict, List, Optional, Tuple
from ray.tune.utils import flatten_dict
from ray.tune.utils.serialization import TuneFunctionDecoder
from ray.tune.utils.util import is_nan_or_inf
try:
import pandas as pd
from pandas import Dat... | null |
v0 | [
"torch.Tensor"
] | None | def v0(self, v1: torch.Tensor) -> None:
if not torch.is_tensor(v1):
v1 = torch.as_tensor(v1).to(self.raw_offset)
self.initialize(raw_offset=self.raw_offset_constraint.inverse_transform(v1)) | [] | [
"torch"
] | [
"import torch"
] | 4 | #!/usr/bin/env python3
from typing import Optional
import torch
from ..constraints import Interval, Positive
from ..priors import Prior
from .kernel import Kernel
class PolynomialKernel(Kernel):
r"""
Computes a covariance matrix based on the Polynomial kernel
between inputs :math:`\mathbf{x_1}` and :ma... | null |
v0 | [
"Tensor",
"Tensor",
"bool"
] | Tensor | def v0(self, v1: Tensor, v2: Tensor, v3: bool=False, **v4) -> Tensor:
if v4.get('last_dim_is_batch', False):
raise NotImplementedError('last_dim_is_batch not yet supported by LinearTruncatedFidelityKernel')
v5 = self.power.view(*self.batch_shape, 1, 1)
v6 = [i for v7 in range(v1.size(-1)) if v7 not ... | [] | [
"torch"
] | [
"import torch",
"from torch import Tensor"
] | 32 | #!/usr/bin/env python3
# Copyright (c) Facebook, Inc. and its affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
from __future__ import annotations
from copy import deepcopy
from typing import Any, List, Optional
import torch
from... | null |
v0 | [] | None | def v0(self) -> None:
if os.path.exists(self.configuration_path):
os.remove(self.configuration_path) | [] | [
"os"
] | [
"import os"
] | 3 | import json
import os
class Configurator(object):
configuration_filename = 'container_configuration_local.json'
configuration_path = os.path.join(os.path.dirname(os.path.realpath(__file__)), configuration_filename)
def __init__(self) -> None:
# read information about containers from config.json
... | null |
v0 | [
"str",
"str",
"Any"
] | Any | def v0(self, v1: str, v2: str, v3):
if v1 in self._key_to_item_factory:
yield self._key_to_item_factory[v1](from_target=v2, **v3)
elif v1 in self._key_to_items_factory:
yield from self._key_to_items_factory[v1](from_target=v2, **v3)
else:
raise AssertionError(f'Unsupported item: {v1}... | [] | [] | [] | 7 | #!/usr/bin/env python3
# Copyright (c) Meta Platforms, Inc. and affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
"Makes Items from the JSON that was produced by a Buck `feature` target"
import json
from contextlib import ExitStack... | null |
v0 | [
"str",
"str",
"str"
] | str | def v0(v1: str, v2: str, v3: str=None) -> str:
v4 = f'import_name: {v1}, curator_email: {v2}'
if v3:
v4 += f', import_id: {v3}'
return v4 | [] | [] | [] | 5 | # Copyright 2020 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, ... | null |
v4 | [
"str",
"v0",
"dict",
"bool",
"float"
] | Dict | def v4(self, v5: str, v6: v0, v7: dict, v8: bool=False, v9: float=None) -> Dict:
if v6.cleaned_csv and v6.template_mcf:
return self.import_table(v5, v6, v7, v8, v9)
if v6.node_mcf and (not v6.cleaned_csv) and (not v6.template_mcf):
return self.import_node(v5, v6, v7, v8, v9)
raise ValueError... | [] | [] | [] | 6 | # Copyright 2020 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, ... | [
"@dataclasses.dataclass\nclass v0:\n v1: str = None\n v2: str = None\n v3: str = None"
] |
v5 | [
"str",
"dict"
] | None | def v5(self, v6: str, v7: dict) -> None:
v8 = v2(v6, v7['import_name'])
for v9 in (self.unresolved_bucket, self.resolved_bucket):
v10 = v9.list_blobs(prefix=os.path.join(self.importer_output_prefix, v8))
for v11 in v10:
v11.delete() | [
{
"name": "v0",
"input_types": [
"str"
],
"output_type": "str",
"code": "def v0(v1: str) -> str:\n return v1.replace(':', '_').replace('/', '_')",
"dependencies": []
},
{
"name": "v2",
"input_types": [
"str",
"str"
],
"output_type": "str",
"code":... | [
"os"
] | [
"import os"
] | 6 | # Copyright 2020 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, ... | null |
v0 | [] | None | def v0(self) -> None:
v1: str = 'waifus'
shutil.rmtree(v1, ignore_errors=True)
self.generatedProfiles.clear() | [] | [
"shutil"
] | [
"import shutil"
] | 4 | import waifulabs
import time
import os
import requests
import shutil
import json
import random
import psutil
from . import species
from PIL import Image
from typing import Dict, List
class Waifus:
def __init__(
self,
dataPath: str = "waifus/",
numberOfProfiles: int = 10,
verbose: b... | null |
v0 | [
"str",
"Any"
] | None | def v0(self, v1: str, v2) -> None:
if self.verbose:
if v1 == 'text':
print(v2, end='\n')
elif v1 == 'image':
v3 = Image.open(v2)
v3.show()
print('\n\n\n')
elif v1 == 'dictionary':
print(json.dumps(v2, indent=4, ensure_ascii=False))
... | [] | [
"PIL",
"json"
] | [
"import json",
"from PIL import Image"
] | 13 | import waifulabs
import time
import os
import requests
import shutil
import json
import random
import psutil
from . import species
from PIL import Image
from typing import Dict, List
class Waifus:
def __init__(
self,
dataPath: str = "waifus/",
numberOfProfiles: int = 10,
verbose: b... | null |
v0 | [
"str"
] | Any | def v0(self, v1: str):
v2: str = os.path.join(self.dataPath, 'profile.json')
v3: str = 'https://api.namefake.com'
if self.multiCultures:
v4: str = v3 + '/random/female'
else:
v4: str = v3 + '/japanese-japan/female'
v5 = requests.get(v4)
v6 = v5.json()
v7 = self.getRandomAge()... | [] | [
"os",
"requests"
] | [
"import os",
"import requests"
] | 14 | import waifulabs
import time
import os
import requests
import shutil
import json
import random
import psutil
from . import species
from PIL import Image
from typing import Dict, List
class Waifus:
def __init__(
self,
dataPath: str = "waifus/",
numberOfProfiles: int = 10,
verbose: b... | null |
v4 | [
"Optional[v0]"
] | List[List[int]] | def v4(self, v5: Optional[v0]) -> List[List[int]]:
(v6, v7) = ([], [v5] if v5 else None)
v8 = 0
while v7:
v9 = []
v6.append([node.val for v10 in v7[::-1 if v8 % 2 == 1 else 1]])
for v10 in v7:
if v10.left:
v9.append(v10.left)
if v10.right:
... | [] | [] | [] | 14 | from typing import List, Optional
# Definition for a binary tree node.
class TreeNode:
def __init__(self, val=0, left=None, right=None):
self.val = val
self.left = left
self.right = right
class Solution:
def zigzagLevelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
... | [
"class v0:\n\n def __init__(self, v1=0, v2=None, v3=None):\n self.val = v1\n self.left = v2\n self.right = v3"
] |
v0 | [
"Any",
"int"
] | Any | def v0(self, v1, v2: int):
v3 = []
v4 = self.weights[v1].sortedKeys()
for v5 in range(1, v2):
if type(v4[v5]) is tuple:
v3.append(v4[v5])
return v3 | [] | [] | [] | 7 | import random
import util
class PerceptronClassifier:
def __init__(self, legalLabels, maxIterations):
self.legalLabels = legalLabels
self.type = "perceptron"
self.maxIteration = maxIterations
self.weights = {}
for label in legalLabels:
self.weights[label] = util... | null |
v12 | [
"str"
] | Any | def v12(v13: str):
v14 = '011'
v15 = '1'
return v6(v0(v14, v13), v15) | [
{
"name": "v0",
"input_types": [
"str",
"str"
],
"output_type": "str",
"code": "def v0(v1: str, v2: str) -> str:\n v3 = len(v1)\n v4 = 0\n for v5 in range(v3):\n v4 += int(v1[v5]) * int(v2[v5])\n return str(v4 % 2)",
"dependencies": []
},
{
"name": "v6"... | [] | [] | 4 | # qubit number=3
# total number=64
import numpy as np
from qiskit import QuantumCircuit, execute, Aer, QuantumRegister, ClassicalRegister, transpile, BasicAer, IBMQ
from qiskit.visualization import plot_histogram
from typing import *
from pprint import pprint
from math import log2
from collections import Counter
from... | null |
v12 | [
"str"
] | Any | def v12(v13: str):
v14 = '000'
v15 = '0'
return v6(v0(v14, v13), v15) | [
{
"name": "v0",
"input_types": [
"str",
"str"
],
"output_type": "str",
"code": "def v0(v1: str, v2: str) -> str:\n v3 = len(v1)\n v4 = 0\n for v5 in range(v3):\n v4 += int(v1[v5]) * int(v2[v5])\n return str(v4 % 2)",
"dependencies": []
},
{
"name": "v6"... | [] | [] | 4 | # qubit number=3
# total number=64
import numpy as np
from qiskit import QuantumCircuit, execute, Aer, QuantumRegister, ClassicalRegister, transpile, BasicAer, IBMQ
from qiskit.visualization import plot_histogram
from typing import *
from pprint import pprint
from math import log2
from collections import Counter
from... | null |
v0 | [
"float"
] | Any | def v0(self, v1: float):
(v2, v3) = train_test_split(self.original_db.index, train_size=v1, random_state=self.seed)
self.train_db = self.original_db.loc[v2]
self.val_db = self.original_db.loc[v3]
self.train_idx = v2
self.val_idx = v3
self.split = True | [] | [
"sklearn"
] | [
"from sklearn.model_selection import train_test_split"
] | 7 | import os
from torch.utils.data import Dataset
import numpy as np
import pandas as pd
from PIL import Image, ImageEnhance
import torch
from sklearn.model_selection import train_test_split
from imageio import imread
from patch import PatchExtractor
from params import db_path
from skimage.restoration import denoise_wavel... | null |
v0 | [
"float"
] | Any | def v0(self, v1: float):
self.salary += v1
return self.salary | [] | [] | [] | 3 | class Employee:
def __init__(self, id: int, first_name: str, last_name: str, salary: float):
self.id = id
self.first_name = first_name
self.last_name = last_name
self.salary = salary
def get_full_name(self):
return self.first_name + ' ' + self.last_name
def get_annu... | null |
v2 | [
"str"
] | Iterable[str] | def v2(self, v3: str) -> Iterable[str]:
yield '#include "pw_rpc/nanopb/client_reader_writer.h"'
yield '#include "pw_rpc/nanopb/internal/method_union.h"'
yield '#include "pw_rpc/nanopb/server_reader_writer.h"'
v4 = v0(v3)
yield f'#include "{v4}"' | [
{
"name": "v0",
"input_types": [
"str"
],
"output_type": "str",
"code": "def v0(v1: str) -> str:\n return os.path.splitext(v1)[0] + NANOPB_H_EXTENSION",
"dependencies": []
}
] | [
"os"
] | [
"import os"
] | 6 | # Copyright 2021 The Pigweed Authors
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may not
# use this file except in compliance with the License. You may obtain a copy of
# the License at
#
# https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in ... | null |
v0 | [
"Optional[tf.distribute.InputContext]"
] | tf.data.Dataset | def v0(self, v1: Optional[tf.distribute.InputContext]=None) -> tf.data.Dataset:
v2 = {'tfds': self.load_tfds, 'records': self.load_records, 'synthetic': self.load_synthetic}
v3 = v2.get(self.config.builder, None)
if v3 is None:
raise ValueError('Unknown builder type {}'.format(self.config.builder))
... | [] | [] | [] | 9 | # Copyright 2021 The TensorFlow Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applica... | null |
v0 | [
"tf.Tensor"
] | Tuple[tf.Tensor, tf.Tensor] | def v0(self, v1: tf.Tensor) -> Tuple[tf.Tensor, tf.Tensor]:
v2 = {'image/encoded': tf.io.FixedLenFeature((), tf.string, ''), 'image/format': tf.io.FixedLenFeature((), tf.string, 'jpeg'), 'image/class/label': tf.io.FixedLenFeature([], tf.int64, -1), 'image/class/text': tf.io.FixedLenFeature([], tf.string, ''), 'imag... | [] | [
"tensorflow"
] | [
"import tensorflow as tf",
"from tensorflow import keras"
] | 9 | # Lint as: python3
# Copyright (c) 2021, NVIDIA CORPORATION. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless... | null |
v0 | [
"str",
"List[str]"
] | bool | def v0(self, v1: str, v2: List[str]) -> bool:
v3 = len(v1)
v4 = set(v2)
v5 = [True] + [False for v6 in range(v3)]
for v7 in range(1, v3 + 1):
for v8 in range(v7):
v9 = v1[v8:v7]
if v9 in v4 and v5[v8]:
v5[v7] = True
break
return v5[-1] | [] | [] | [] | 11 | from typing import List
class Solution:
def wordBreak(self, s: str, wordDict: List[str]) -> bool:
size = len(s)
word_set = set(wordDict)
# dp[i]：长度为 i 的 s 字符串经过空格分隔以后在 wordDict 中
# 需要长度为 0，因此前面加上一个 True
# 特例：整个字符串恰好就在 wordDict 中
dp = [True] + [False for _ in range(s... | null |
v0 | [] | None | def v0(self) -> None:
v1 = self.as_path()
(v2, v3) = os.path.splitext(v1)
if v3 != '':
v4 = os.path.dirname(v1)
if not os.path.exists(v4):
os.makedirs(v4)
elif not os.path.exists(v1):
os.makedirs(v1) | [] | [
"os"
] | [
"import os"
] | 9 | #!/usr/bin/python
# -*- coding: utf-8 -*-
import os
import re
import shutil
from collections import OrderedDict
from typing import Dict, Iterable, TypeVar, Union
import yaml
class RemoteOSPath(object):
# remote path: scheme://[host]:[port]/ or it could be scheme://user@host:port/
remote_path_reg = re.compi... | null |
v0 | [] | None | def v0(self) -> None:
v1 = self.as_path()
v2 = os.path.dirname(v1)
v3 = os.path.basename(v1)
if os.path.exists(v1):
v4 = re.compile('^-\\d+$')
v5 = [int(fname.replace(v3 + '-', '')) for v6 in os.listdir(v2) if v6.startswith(v3) and v4.match(v6.replace(v3, '')) is not None]
if len... | [] | [
"os",
"re",
"shutil"
] | [
"import os",
"import re",
"import shutil"
] | 13 | #!/usr/bin/python
# -*- coding: utf-8 -*-
import os
import re
import shutil
from collections import OrderedDict
from typing import Dict, Iterable, TypeVar, Union
import yaml
class RemoteOSPath(object):
# remote path: scheme://[host]:[port]/ or it could be scheme://user@host:port/
remote_path_reg = re.compi... | null |
v1 | [
"str"
] | Union[v0, 'Configuration'] | def v1(self, v2: str) -> Union[v0, 'Configuration']:
v3 = self
v4 = v2.split('.')
for v5 in v4[:-1]:
v3 = v3.__conf[v5]
return v3.__conf[v4[-1]] | [] | [] | [] | 6 | #!/usr/bin/python
# -*- coding: utf-8 -*-
import os
import re
import shutil
from collections import OrderedDict
from typing import Dict, Iterable, TypeVar, Union
import yaml
class RemoteOSPath(object):
# remote path: scheme://[host]:[port]/ or it could be scheme://user@host:port/
remote_path_reg = re.compi... | [
"v0 = TypeVar('PrimitiveType', int, float, StringConf)"
] |
v7 | [
"List[Union[dict, str]]"
] | str | def v7(v8: List[Union[dict, str]]) -> str:
def v9(v10: Union[dict, str]) -> str:
if type(v10) == dict:
v10 = v2(v10)
return v10
v11 = list(map(v9, v8))
return '\n---\n'.join(v11) | [
{
"name": "v0",
"input_types": [
"Union[dict, str]"
],
"output_type": "str",
"code": "def v0(v1: Union[dict, str]) -> str:\n if type(v1) == dict:\n v1 = dump(v1)\n return v1",
"dependencies": [
"v2"
]
},
{
"name": "v2",
"input_types": [
"dict",
... | [] | [] | 8 | from typing import List, Union
from ruamel.yaml import YAML
from ruamel.yaml.compat import StringIO
def combine_templates(templates: List[Union[dict, str]]) -> str:
def _get_template_string(template: Union[dict, str]) -> str:
if type(template) == dict:
template = dump(template)
return ... | null |
v5 | [
"Union[dict, str]"
] | str | def v5(v6: Union[dict, str]) -> str:
if type(v6) == dict:
v6 = v0(v6)
return v6 | [
{
"name": "v0",
"input_types": [
"dict",
"Any"
],
"output_type": "str",
"code": "def v0(v1: dict, v2=False) -> str:\n v3 = YAML()\n v3.default_flow_style = v2\n v4 = StringIO()\n v3.dump(v1, v4)\n return v4.getvalue()",
"dependencies": []
}
] | [] | [] | 4 | from typing import List, Union
from ruamel.yaml import YAML
from ruamel.yaml.compat import StringIO
def combine_templates(templates: List[Union[dict, str]]) -> str:
def _get_template_string(template: Union[dict, str]) -> str:
if type(template) == dict:
template = dump(template)
return ... | null |
v0 | [
"str"
] | str | def v0(self, v1: str) -> str:
v2 = os.path.join(self.db_dir, 'data', v1)
return v2 | [] | [
"os"
] | [
"import os"
] | 3 | # -*- coding: utf-8 -*-
"""
"""
import os
import json
from datetime import datetime
from typing import Union, Optional, Any, List, Tuple, Dict, Sequence, NoReturn
from numbers import Real
import numpy as np
np.set_printoptions(precision=5, suppress=True)
import pandas as pd
import wfdb
from easydict import EasyDict as... | null |
v0 | [
"str"
] | List[str] | def v0(self, v1: str) -> List[str]:
v2 = [v1]
v3 = 0
while v3 < len(v2):
v4 = v2[v3]
v5 = self._servers[v4]
v2.extend(v5.downlinks)
v3 += 1
v2.pop(0)
return v2 | [] | [] | [] | 10 | from collections import OrderedDict
from dataclasses import dataclass, field
from datetime import datetime
from re import compile as re_compile
from typing import Dict, List, Optional, Set
from typing import OrderedDict as TOrderedDict
from irctokens import build, Line
from ircrobots import Bot as BaseBot
from ircrobo... | null |
v0 | [
"Optional[Sequence[str]]",
"bool",
"bool"
] | List[str] | def v0(self, v1: Optional[Sequence[str]]=None, v2: bool=True, v3: bool=False) -> List[str]:
if v1 is None:
v4 = self.all_leads_lower
elif isinstance(v1, str):
v4 = [v1.lower()]
else:
v4 = [l.lower() for v5 in v1]
if v2:
v4 = [v5 for v5 in self.all_leads_lower if v5 in v4]... | [] | [] | [] | 13 | # -*- coding: utf-8 -*-
"""
"""
import os
import json
from datetime import datetime
from typing import Union, Optional, Any, List, Tuple, Dict, Sequence, NoReturn
from numbers import Real
import numpy as np
np.set_printoptions(precision=5, suppress=True)
import pandas as pd
import wfdb
from easydict import EasyDict as... | null |
v0 | [
"str",
"Optional[Union[str, Sequence[str]]]"
] | Union[dict, str] | def v0(self, v1: str, v2: Optional[Union[str, Sequence[str]]]=None) -> Union[dict, str]:
v3 = self._df_subject_info[self._df_subject_info.ID == v1]
if v3.empty:
return {}
v3 = v3.iloc[0]
v4 = v3.to_dict()
if v2 is not None:
assert v2 in self._df_subject_info.columns or set(v2).issubs... | [] | [] | [] | 13 | # -*- coding: utf-8 -*-
"""
"""
import os
import json
from datetime import datetime
from typing import Union, Optional, Any, List, Tuple, Dict, Sequence, NoReturn
from numbers import Real
import numpy as np
np.set_printoptions(precision=5, suppress=True)
import pandas as pd
import wfdb
from easydict import EasyDict as... | null |
v4 | [
"str",
"dict"
] | None | async def v4(self, v5: str, v6: dict) -> None:
async with self._session.get(url=v5, params=v6) as v7:
await v0(v7) | [
{
"name": "v0",
"input_types": [
"Any"
],
"output_type": "Any",
"code": "async def v0(v1):\n if v1.status != 200:\n raise ChClientError(await _read_error_body(v1))",
"dependencies": [
"v2"
]
},
{
"name": "v2",
"input_types": [
"Any"
],
"out... | [] | [] | 3 | from typing import Any, AsyncGenerator, Optional
from aiohttp import ClientSession
from aiochclient.exceptions import ChClientError
from aiochclient.http_clients.abc import HttpClientABC
class AiohttpHttpClient(HttpClientABC):
def __init__(self, session: Optional[ClientSession]):
if session:
... | null |
v4 | [
"str",
"dict",
"Any"
] | AsyncGenerator[bytes, None] | async def v4(self, v5: str, v6: dict, v7: Any) -> AsyncGenerator[bytes, None]:
v8 = await self._session.post(url=v5, params=v6, content=v7)
await v0(v8)
async for v9 in v8.aiter_lines():
yield v9.encode() | [
{
"name": "v0",
"input_types": [
"Any"
],
"output_type": "Any",
"code": "async def v0(v1):\n if v1.status_code != 200:\n raise ChClientError(await _read_error_body(v1))",
"dependencies": [
"v2"
]
},
{
"name": "v2",
"input_types": [
"Response"
]... | [] | [] | 5 | from typing import Any, AsyncGenerator, Optional
from httpx import AsyncClient, Response
from aiochclient.exceptions import ChClientError
from aiochclient.http_clients.abc import HttpClientABC
class HttpxHttpClient(HttpClientABC):
def __init__(self, session: Optional[AsyncClient]):
if session:
... | null |
v4 | [
"str",
"dict",
"Any"
] | None | async def v4(self, v5: str, v6: dict, v7: Any) -> None:
v8 = await self._session.post(url=v5, params=v6, content=v7)
await v0(v8) | [
{
"name": "v0",
"input_types": [
"Any"
],
"output_type": "Any",
"code": "async def v0(v1):\n if v1.status_code != 200:\n raise ChClientError(await _read_error_body(v1))",
"dependencies": [
"v2"
]
},
{
"name": "v2",
"input_types": [
"Response"
]... | [] | [] | 3 | from typing import Any, AsyncGenerator, Optional
from httpx import AsyncClient, Response
from aiochclient.exceptions import ChClientError
from aiochclient.http_clients.abc import HttpClientABC
class HttpxHttpClient(HttpClientABC):
def __init__(self, session: Optional[AsyncClient]):
if session:
... | null |
v0 | [
"int"
] | str | def v0(self, v1: int) -> str:
if v1 == 0:
return ''
if v1 == 1:
return '+ ' if self.ascii_only else '├─'
return ('| ' if self.ascii_only else '│ ') * (v1 - 1) + ('+ ' if self.ascii_only else '└─') | [] | [] | [] | 6 | from __future__ import annotations
import math
from typing import Any
from .enums import ColumnSettings, RowSettings, Verbosity
from .layer_info import LayerInfo
HEADER_TITLES = {
ColumnSettings.KERNEL_SIZE: "Kernel Shape",
ColumnSettings.INPUT_SIZE: "Input Shape",
ColumnSettings.OUTPUT_SIZE: "Output Sha... | null |
v0 | [
"'multiprocessing.Queue'"
] | Any | def v0(v1: 'multiprocessing.Queue'):
v2 = 0
v3 = []
while not v1.empty():
v3.append(v1.get())
v2 += 1
for v4 in v3:
v1.put_nowait(v4)
return v2 | [] | [] | [] | 9 | import asyncio
import json
import multiprocessing
from copy import copy
from multiprocessing import Process
from typing import List
import grpc
import pytest
from grpc import RpcError
from jina import Document, DocumentArray
from jina.clients.request import request_generator
from jina.enums import PollingType
from ji... | null |
v0 | [
"'multiprocessing.Manager().Queue'"
] | Any | def v0(v1: 'multiprocessing.Manager().Queue'):
v2 = copy(v1)
v3 = 0
while not v2.empty():
v2.get()
v3 += 1
return v3 | [] | [
"copy"
] | [
"from copy import copy"
] | 7 | import asyncio
import json
import multiprocessing
from copy import copy
from multiprocessing import Process
from typing import List
import grpc
import pytest
from grpc import RpcError
from jina import Document, DocumentArray
from jina.clients.request import request_generator
from jina.enums import PollingType
from ji... | null |
v0 | [] | dict | def v0(self) -> dict:
v1 = super()._get_default_auxiliary_params()
v2 = dict(drop_unique=False)
v1.update(v2)
return v1 | [] | [] | [] | 5 | import copy
import logging
import os
import time
from collections import Counter
from statistics import mean
import numpy as np
import pandas as pd
from .fold_fitting_strategy import AbstractFoldFittingStrategy, SequentialLocalFoldFittingStrategy
from ..abstract.abstract_model import AbstractModel
from ...constants i... | null |
v0 | [
"Tuple[Tensor, ...]"
] | List[bool] | def v0(v1: Tuple[Tensor, ...]) -> List[bool]:
assert isinstance(v1, tuple), 'Inputs should be wrapped in a tuple prior to preparing for gradients'
v2 = []
for (v3, v4) in enumerate(v1):
assert isinstance(v4, torch.Tensor), 'Given input is not a torch.Tensor'
v2.append(v4.requires_grad)
... | [] | [
"torch",
"warnings"
] | [
"import warnings",
"import torch",
"from torch import Tensor, device",
"from torch.nn import Module"
] | 17 | #!/usr/bin/env python3
import threading
import typing
import warnings
from collections import defaultdict
from typing import Any, Callable, Dict, List, Tuple, Union, cast
import torch
from torch import Tensor, device
from torch.nn import Module
from captum._utils.common import (
_reduce_list,
_run_forward,
... | null |
v0 | [
"Tuple[Tensor, ...]",
"List[bool]"
] | None | def v0(v1: Tuple[Tensor, ...], v2: List[bool]) -> None:
assert isinstance(v1, tuple), 'Inputs should be wrapped in a tuple prior to preparing for gradients.'
assert len(v1) == len(v2), 'Input tuple length should match gradient mask.'
for (v3, v4) in enumerate(v1):
assert isinstance(v4, torch.Tensor)... | [] | [
"torch"
] | [
"import torch",
"from torch import Tensor, device",
"from torch.nn import Module"
] | 10 | #!/usr/bin/env python3
import threading
import typing
import warnings
from typing import Any, Callable, Dict, List, Tuple, Union, cast
import torch
from torch import Tensor, device
from torch.nn import Module
from ..._utils.common import _run_forward, _verify_select_column
from ..._utils.typing import Literal, Target... | null |
v0 | [
"Callable",
"Dict[Module, Dict[device, Tuple[Tensor, ...]]]",
"Union[None, List[int]]"
] | Union[None, List[int]] | def v0(v1: Callable, v2: Dict[Module, Dict[device, Tuple[Tensor, ...]]], v3: Union[None, List[int]]) -> Union[None, List[int]]:
if max((len(v2[single_layer]) for v4 in v2)) > 1 and v3 is None:
if hasattr(v1, 'device_ids') and cast(Any, v1).device_ids is not None:
v3 = cast(Any, v1).device_ids
... | [] | [
"typing"
] | [
"import typing",
"from typing import Any, Callable, Dict, List, Tuple, Union, cast"
] | 7 | #!/usr/bin/env python3
import threading
import typing
import warnings
from collections import defaultdict
from typing import Any, Callable, Dict, List, Tuple, Union, cast
import torch
from torch import Tensor, device
from torch.nn import Module
from captum._utils.common import (
_reduce_list,
_run_forward,
... | null |
v2 | [
"Callable"
] | Callable | def v2(self, v3: Callable) -> Callable:
def v4(v5: jnp.DeviceArray) -> float:
return -v3(v5)
return v4 | [
{
"name": "v0",
"input_types": [
"jnp.DeviceArray"
],
"output_type": "float",
"code": "def v0(v1: jnp.DeviceArray) -> float:\n return -loglikelihood(v1)",
"dependencies": []
}
] | [] | [] | 5 | import warnings
from datetime import datetime
from typing import Callable, Dict, NamedTuple, Optional, Tuple
import jax
from jax import numpy as jnp
from tqdm import tqdm
from mcx.inference.adaptation import (
StanWarmupState,
stan_hmc_warmup,
stan_warmup_schedule,
)
from mcx.inference.integrators import ... | null |
v0 | [
"int"
] | int | def v0(v1: int) -> int:
if v1 >= 0:
return v1 * v1
return "i don't know the answer" | [] | [] | [] | 4 | class Airflow:
def talk(self):
print("I AM AIRFLOW")
@staticmethod
def return_favorite_number():
return 42
def calculate_square(number: int) -> int:
if number >= 0:
return number * number
return "i don't know the answer"
| null |
v0 | [
"int"
] | bool | def v0(self, v1: int) -> bool:
if v1 == 1:
return True
v2 = list(map(int, str(v1)))
v3 = set()
v3.add(v1)
while len(v2) > 0:
v4 = sum([x ** 2 for v5 in v2])
if v4 in v3:
return False
else:
v3.add(v4)
v2 = list(map(int, str(v4)))
... | [] | [] | [] | 16 | class Solution:
def isHappy(self, n: int) -> bool:
if n == 1:
return True
num = list(map(int, str(n)))
oc = set()
oc.add(n)
while len(num) > 0:
sq = sum([x**2 for x in num])
if sq in oc:
return False
else:
... | null |
v0 | [
"spikeglx.Reader",
"Any"
] | Any | def v0(v1: spikeglx.Reader, v2=None):
for v3 in range(v1.shape[0]):
yield v1._raw[v3][v2].squeeze()
return | [] | [] | [] | 4 | from datetime import datetime
from pathlib import PurePath
import warnings
import numpy as np
import pandas as pd
from tzlocal import get_localzone
from ibllib.io import spikeglx
from oneibl.one import OneAbstract, SessionDataInfo
def _iter_datasetview(reader: spikeglx.Reader, channel_ids=None):
"""
Generator... | null |
v0 | [
"str",
"str"
] | Any | def v0(self, v1: str, v2: str):
if not isinstance(v1, str):
return
if v1.split('.')[0] == 'ephysData' and (not self.save_raw):
return
if 'Camera.raw' in v1:
v3 = self.one_object.alyx.rest('sessions/' + self.eid, 'list')
v4 = [i for v5 in v3['data_dataset_session_related'] if ... | [] | [] | [] | 33 | from datetime import datetime
from pathlib import PurePath
import warnings
import numpy as np
import pandas as pd
from tzlocal import get_localzone
from ibllib.io import spikeglx
from oneibl.one import OneAbstract, SessionDataInfo
def _iter_datasetview(reader: spikeglx.Reader, channel_ids=None):
"""
Generator... | null |
v0 | [
"datetime.datetime",
"str"
] | str | def v0(v1: datetime.datetime, v2: str) -> str:
v3 = '%-d-%b-%Y'
if v2 == 'hour':
v3 += ' %H:%M'
return v1.strftime(v3) | [] | [] | [] | 5 | import base64
import dataclasses
import datetime
import datetime as dt
import gzip
import hashlib
import json
import os
import re
import shutil
import subprocess
import sys
import time
import uuid
from enum import Enum
from itertools import count
from typing import (
Any,
Dict,
Generator,
List,
Mapp... | null |
v0 | [] | Optional[str] | def v0() -> Optional[str]:
try:
return subprocess.check_output(['git', 'rev-parse', '--symbolic-full-name', '--abbrev-ref', 'HEAD']).decode('utf-8').strip()
except Exception:
return None | [] | [
"subprocess"
] | [
"import subprocess"
] | 5 | import base64
import dataclasses
import datetime
import datetime as dt
import gzip
import hashlib
import json
import os
import re
import shutil
import subprocess
import sys
import time
import uuid
from enum import Enum
from itertools import count
from typing import (
Any,
Dict,
Generator,
List,
Mapp... | null |
v0 | [
"float"
] | Any | def v0(v1: float):
(v2, v1) = divmod(v1, 60.0)
(v3, v2) = divmod(v2, 60.0)
return '{hours}{minutes}{seconds}'.format(hours='{h} hours '.format(h=int(v3)) if v3 > 0 else '', minutes='{m} minutes '.format(m=int(v2)) if v2 > 0 else '', seconds='{s} seconds'.format(s=int(v1)) if v1 > 0 or (v2 == 0 and v3 == 0) ... | [] | [] | [] | 4 | import base64
import datetime
import gzip
import hashlib
import json
import os
import re
import subprocess
import time
import uuid
from itertools import count
from typing import (
Any,
Dict,
Generator,
List,
Mapping,
Optional,
Tuple,
Union,
)
from urllib.parse import urljoin, urlparse
i... | null |
v4 | [
"List",
"Any",
"Any"
] | Dict[str, Any] | def v4(v5: List, v6=None, v7='sum') -> Dict[str, Any]:
v8: Dict[str, Any] = {}
v8['data'] = []
v8['labels'] = []
v8['days'] = []
v9 = '%Y-%m-%d'
if v6 == 'hour' or v6 == 'minute':
v9 += ' %H:%M:%S'
for v10 in v5:
v11 = v10[0]
v12 = v10[1]
v8['days'].append(v11... | [
{
"name": "v0",
"input_types": [
"datetime.datetime",
"str"
],
"output_type": "str",
"code": "def v0(v1: datetime.datetime, v2: str) -> str:\n v3 = '%a. {day} %B'\n if v2 == 'hour' or v2 == 'minute':\n v3 += ', %H:%M'\n return v1.strftime(v3.format(day=v1.day))",
... | [] | [] | 17 | import base64
import datetime
import gzip
import hashlib
import json
import os
import re
import subprocess
import time
import uuid
from itertools import count
from typing import (
Any,
Dict,
Generator,
List,
Mapping,
Optional,
Tuple,
Union,
)
from urllib.parse import urljoin, urlparse
i... | null |
v0 | [
"Union[str, bool, dict, list, int, Optional[str]]"
] | str | def v0(v1: Union[str, bool, dict, list, int, Optional[str]]) -> str:
if isinstance(v1, bool):
if v1 is True:
return 'true'
return 'false'
if isinstance(v1, dict) or isinstance(v1, list):
return json.dumps(v1, sort_keys=True)
return str(v1) | [] | [
"json"
] | [
"import json"
] | 8 | import base64
import dataclasses
import datetime
import datetime as dt
import gzip
import hashlib
import json
import os
import re
import shutil
import subprocess
import sys
import time
import uuid
from enum import Enum
from itertools import count
from typing import (
Any,
Dict,
Generator,
List,
Mapp... | null |
v0 | [
"datetime.datetime",
"datetime.datetime"
] | Tuple[datetime.datetime, datetime.datetime] | def v0(v1: datetime.datetime, v2: datetime.datetime) -> Tuple[datetime.datetime, datetime.datetime]:
v3 = v1
v4 = v2 - v1
v5 = v1 - v4
return (v5, v3) | [] | [] | [] | 5 | import base64
import dataclasses
import datetime
import datetime as dt
import gzip
import hashlib
import json
import os
import re
import shutil
import subprocess
import sys
import time
import uuid
from enum import Enum
from itertools import count
from typing import (
Any,
Dict,
Generator,
List,
Mapp... | null |
v0 | [
"Union[int, float]"
] | str | def v0(v1: Union[int, float]) -> str:
v1 = float('{:.3g}'.format(v1))
v2 = 0
while abs(v1) >= 1000:
v2 += 1
v1 /= 1000.0
return '{:f}'.format(v1).rstrip('0').rstrip('.') + ['', 'K', 'M', 'B', 'T', 'P', 'E', 'Z', 'Y'][v2] | [] | [] | [] | 7 | import base64
import datetime
import datetime as dt
import gzip
import hashlib
import json
import os
import re
import shutil
import subprocess
import sys
import time
import uuid
from itertools import count
from typing import (
Any,
Dict,
Generator,
List,
Mapping,
Optional,
Sequence,
Tupl... | null |
v0 | [] | bool | def v0(self) -> bool:
if self.test_mode:
try:
self.db.reset()
return True
except:
return False | [] | [] | [] | 7 | import os
import firebase_admin
from account_api.models.base import IModel
from firebase_admin import credentials, firestore
from mockfirestore import MockFirestore
if os.environ.get('ACCAPI_G_DEBUG') == 'true':
cred = credentials.Certificate(os.environ.get('ACCAPI_G_CERTIFICATE'))
else:
cred = credentials.A... | null |
v3 | [] | bool | def v3() -> bool:
try:
return v0() != 'offline'
except BaseException:
return False | [
{
"name": "v0",
"input_types": [],
"output_type": "Union[str, int]",
"code": "def v0() -> Union[str, int]:\n v1 = get_client().get('POSTHOG_HEARTBEAT')\n v2 = int(time.time()) - int(v1) if v1 else -1\n if 0 <= v2 < 300:\n return v2\n return 'offline'",
"dependencies": []
}
] | [] | [] | 5 | import base64
import dataclasses
import datetime
import datetime as dt
import gzip
import hashlib
import json
import os
import re
import shutil
import subprocess
import sys
import time
import uuid
from enum import Enum
from itertools import count
from typing import (
Any,
Dict,
Generator,
List,
Mapp... | null |
v0 | [
"str"
] | str | def v0(v1: str) -> str:
v2 = v1.find('@')
if v2 == -1:
raise ValueError('Please provide a valid email address.')
if v2 == 1:
return f'*{v1[v2:]}'
return f"{v1[0]}{'*' * (v2 - 2)}{v1[v2 - 1:]}" | [] | [] | [] | 7 | import base64
import dataclasses
import datetime
import datetime as dt
import gzip
import hashlib
import json
import os
import re
import shutil
import subprocess
import sys
import time
import uuid
from enum import Enum
from itertools import count
from typing import (
Any,
Dict,
Generator,
List,
Mapp... | null |
v0 | [
"Any"
] | bool | def v0(v1: Any) -> bool:
if not v1:
return False
return str(v1).lower() in ('y', 'yes', 't', 'true', 'on', '1') | [] | [] | [] | 4 | import base64
import dataclasses
import datetime
import datetime as dt
import gzip
import hashlib
import json
import os
import re
import shutil
import subprocess
import sys
import time
import uuid
from enum import Enum
from itertools import count
from typing import (
Any,
Dict,
Generator,
List,
Mapp... | null |
v0 | [
"Sequence[str]"
] | Any | def v0(v1: Sequence[str]):
v2 = min(max(map(len, v1)) // 2, shutil.get_terminal_size().columns)
print('\n'.join(('', '🔻' * v2, *v1, '🔺' * v2, '')), file=sys.stderr) | [] | [
"shutil",
"sys"
] | [
"import shutil",
"import sys"
] | 3 | import base64
import dataclasses
import datetime
import datetime as dt
import gzip
import hashlib
import json
import os
import re
import shutil
import subprocess
import sys
import time
import uuid
from enum import Enum
from itertools import count
from typing import (
Any,
Dict,
Generator,
List,
Mapp... | null |
v0 | [] | dict | def v0() -> dict:
try:
return json.loads(os.getenv('HELM_INSTALL_INFO', '{}'))
except Exception:
return {} | [] | [
"json",
"os"
] | [
"import json",
"import os"
] | 5 | import base64
import dataclasses
import datetime
import datetime as dt
import gzip
import hashlib
import json
import os
import re
import shutil
import subprocess
import sys
import time
import uuid
from enum import Enum
from itertools import count
from typing import (
Any,
Dict,
Generator,
List,
Mapp... | null |
v0 | [
"str"
] | bool | def v0(self, v1: str) -> bool:
v2 = v1.find('@')
if v2 == -1:
return False
return self.emails.get(v1[v2 + 1:], False) | [] | [] | [] | 5 | import base64
import dataclasses
import datetime
import datetime as dt
import gzip
import hashlib
import json
import os
import re
import shutil
import subprocess
import sys
import time
import uuid
from enum import Enum
from itertools import count
from typing import (
Any,
Dict,
Generator,
List,
Mapp... | null |
v20 | [
"v0",
"torch.utils.data.DataLoader",
"int",
"int",
"int",
"str",
"bool",
"float",
"int",
"torch.device",
"float"
] | Any | def v20(v21: v0, v22: torch.utils.data.DataLoader, v23: int, v24: int=None, v25: int=30, v26: str=None, v27: bool=False, v28: float=None, v29: int=1, v30: torch.device=torch.device('cpu'), v31: float=None):
if v31:
v32 = torch.optim.Adam(v21.parameters(), lr=v31)
v33 = torch.optim.lr_scheduler.StepL... | [] | [
"os",
"torch",
"tqdm"
] | [
"import os",
"import torch",
"from tqdm import tqdm"
] | 31 | import os
import torch
import taylor_expansion
from tqdm import tqdm
class RNNModel(torch.nn.Module):
def __init__(self, input_channels: int, hidden_channels: int, output_channels: int, non_linearity: str = 'tanh',
device=torch.device("cpu")):
"""Feedforward RNN, that can be penalized ... | [
"class v0(torch.nn.Module):\n\n def __init__(self, v1: int, v2: int, v3: int, v4: str='tanh', v5=torch.device('cpu')):\n \"\"\"Feedforward RNN, that can be penalized with its RKHS norm.\n\n :param input_channels: dimension of the data\n :param hidden_channels: size of the hidden state\n ... |
v0 | [
"str"
] | bool | def v0(v1: str) -> bool:
try:
socket.getaddrinfo(v1, None, socket.AF_UNSPEC)
return True
except socket.gaierror:
return False | [] | [
"socket"
] | [
"import socket"
] | 6 | import errno
import logging
import os
import platform
import socket
import sys
import warnings
from importlib.abc import Loader, MetaPathFinder
from types import ModuleType, TracebackType
from typing import (
TYPE_CHECKING,
Any,
Callable,
Dict,
List,
Optional,
Sequence,
Type,
TypeVar... | null |
v0 | [] | None | def v0(cls: Type[Warning]=HTTPWarning) -> None:
v1 = []
for v2 in warnings.filters:
if issubclass(v2[2], cls):
continue
v1.append(v2)
warnings.filters[:] = v1 | [] | [
"warnings"
] | [
"import warnings"
] | 7 | import errno
import logging
import os
import platform
import socket
import sys
import warnings
from importlib.abc import Loader, MetaPathFinder
from types import ModuleType, TracebackType
from typing import (
TYPE_CHECKING,
Any,
Callable,
Dict,
List,
Optional,
Sequence,
Type,
TypeVar... | null |
v0 | [] | None | def v0(self) -> None:
if self.namespace in self.modules:
self._data[self.namespace] = self.modules.pop(self.namespace)
for v1 in list(self.modules.keys()):
if v1.startswith(self.namespace + '.'):
self._data[v1] = self.modules.pop(v1) | [] | [] | [] | 6 | import errno
import logging
import os
import platform
import socket
import sys
import warnings
from importlib.abc import Loader, MetaPathFinder
from types import ModuleType, TracebackType
from typing import (
TYPE_CHECKING,
Any,
Callable,
Dict,
List,
Optional,
Sequence,
Type,
TypeVar... | null |
v0 | [] | None | def v0() -> None:
v1 = gc.get_threshold()
v2 = gc.get_count()
for v3 in reversed(range(len(v1))):
if v1[v3] < v2[v3]:
gc.collect(v3) | [] | [
"gc"
] | [
"import gc"
] | 6 | # Copyright 2014 OpenMarket Ltd
# Copyright 2018 New Vector Ltd
# Copyright 2019 The Matrix.org Foundation C.I.C.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org... | null |
v0 | [
"Optional[str]",
"str"
] | str | def v0(self, v1: Optional[str], v2: str) -> str:
if v1:
if v1 not in self.config.general.valid_brands:
v1 = None
if not v1:
v1 = self.config.general.default_brand
v3 = self.config.general.templates_path
if os.path.exists(os.path.join(v3, v1, v2 + '.j2')):
return os.pa... | [] | [
"os"
] | [
"import os"
] | 11 | # Copyright 2014 OpenMarket Ltd
# Copyright 2018 New Vector Ltd
# Copyright 2019 The Matrix.org Foundation C.I.C.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org... | null |
v0 | [
"testing.FlaskClient"
] | Any | def v0(v1: testing.FlaskClient):
v2 = v1.get('/swagger.json')
assert v2.status_code == 200 | [] | [] | [] | 3 | from flask import testing
def test_swagger_endpoint(app_client: testing.FlaskClient):
"""
Test /health endpoint
"""
response = app_client.get("/swagger")
assert response.status_code == 200
def test_swagger_json_endpoint(app_client: testing.FlaskClient):
"""
Test /health endpoint
"""
... | null |
v44 | [
"Any"
] | Tuple[str, Dict, List] | def v44(v45) -> Tuple[str, Dict, List]:
v46 = {}
v47 = []
v48 = []
for v49 in v45:
if v49.HasField('udf'):
(v50, v51, v52) = v21(v49.udf)
v48.append(v50)
v46.update(v51)
v47.extend(v52)
elif v49.HasField('inputOffset'):
v48.appe... | [
{
"name": "v0",
"input_types": [],
"output_type": "Any",
"code": "def v0():\n global _constant_num\n v1 = v1 + 1\n return v1",
"dependencies": []
},
{
"name": "v2",
"input_types": [],
"output_type": "Any",
"code": "def v2():\n global _func_num\n v3 = v3 + 1\n ... | [
"datetime",
"functools"
] | [
"import datetime",
"from functools import partial"
] | 17 | ################################################################################
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements. See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership. The ASF licenses this... | null |
v9 | [
"str",
"bool"
] | Any | def v9(v10: str, v11: bool=False):
v12 = v0(v10)
v13 = []
for v14 in v12:
v13.append(v4(int(v14), v11))
return v13 | [
{
"name": "v0",
"input_types": [
"str"
],
"output_type": "Any",
"code": "def v0(v1: str):\n v2 = 'pgrep %s' % v1\n v3 = os.popen(v2).read().strip()\n return list(v3.splitlines())",
"dependencies": []
},
{
"name": "v4",
"input_types": [
"int",
"bool"
... | [
"os"
] | [
"import os"
] | 6 | from collections import namedtuple
from datetime import datetime
import os
import psutil
from psutil._common import addr, pconn
from psutil._pslinux import pcputimes
import pwd, grp
class ProcessAttributes:
@staticmethod
def get_all_attribute_names():
return [key for key, value in ATTRIBUTES.items()]
... | null |
v0 | [
"str"
] | Any | def v0(v1: str):
v2 = 'pgrep %s' % v1
v3 = os.popen(v2).read().strip()
return list(v3.splitlines()) | [] | [
"os"
] | [
"import os"
] | 4 | from collections import namedtuple
from datetime import datetime
import os
import psutil
from psutil._common import addr, pconn
from psutil._pslinux import pcputimes
import pwd, grp
class ProcessAttributes:
@staticmethod
def get_all_attribute_names():
return [key for key, value in ATTRIBUTES.items()]
... | null |
v0 | [
"str"
] | Any | def v0(v1: str):
if v1.lower() in ['true', '1', 't', 'y', 'yes']:
return True
elif v1.lower() in ['false', '0', 'f', 'n', 'no']:
return False
return None | [] | [] | [] | 6 | from collections import namedtuple
from datetime import datetime
import os
import psutil
from psutil._common import addr, pconn
from psutil._pslinux import pcputimes
import pwd, grp
class ProcessAttributes:
@staticmethod
def get_all_attribute_names():
return [key for key, value in ATTRIBUTES.items()]
... | null |
v0 | [
"tf.estimator.Estimator",
"Text",
"Optional[Text]",
"Optional[bytes]",
"bool"
] | bytes | def v0(self, v1: tf.estimator.Estimator, v2: Text, v3: Optional[Text], v4: Optional[bytes], v5: bool) -> bytes:
v6 = self._eval_saved_model_exporter.export(v1, v2, v3, v4, v5)
self._garbage_collect_exports(v2)
return v6 | [] | [] | [] | 4 | # Copyright 2016 The TensorFlow Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applica... | null |
v0 | [
"int",
"int",
"int",
"int",
"int",
"int",
"int",
"bytearray"
] | Any | def v0(self, v1: int, v2: int, v3: int, v4: int=32, v5: int=30, v6: int=0, v7: int=0, v8: bytearray=None):
self.bank = v1
self.nametable_address = v2
self.attributes_address = v3
self._width = v4
self._height = v5
self._x = v6
self._y = v7
self._unsaved_changes = False
self._modified... | [] | [] | [] | 61 | __author__ = "Fox Cunning"
from tkinter import Canvas
from typing import List
from PIL import Image, ImageTk
import colour
from appJar import appjar
from debug import log
from helpers import Point2D
from palette_editor import PaletteEditor
from rom import ROM
from undo_redo import UndoRedo
class CutsceneEditor:
... | null |
v0 | [
"int",
"int"
] | None | def v0(self, v1: int, v2: int) -> None:
v3 = len(self.attributes)
if v1 < v3:
self.attributes[v1] = v2
v1 = v1 + 1
if v1 < v3:
self.attributes[v1] = v2
v1 = v1 + 31
if v1 < v3:
self.attributes[v1] = v2
v1 = v1 + 1
if v1 < v3:
self.attributes[v1] = v2 | [] | [] | [] | 13 | __author__ = "Fox Cunning"
from tkinter import Canvas
from typing import List
from PIL import Image, ImageTk
import colour
from appJar import appjar
from debug import log
from helpers import Point2D
from palette_editor import PaletteEditor
from rom import ROM
from undo_redo import UndoRedo
class CutsceneEditor:
... | null |
v0 | [] | bool | def v0(self) -> bool:
if self._unsaved_changes is True:
if self.app.yesNoBox('Screen Editor', 'Are you sure you want to close the cutscene editor?\n' + 'All unsaved changes will be lost.', 'Cutscene_Editor') is False:
return False
self.app.hideSubWindow('Cutscene_Editor', False)
self._pa... | [] | [
"PIL"
] | [
"from PIL import Image, ImageTk"
] | 10 | __author__ = "Fox Cunning"
from tkinter import Canvas
from typing import List
from PIL import Image, ImageTk
import colour
from appJar import appjar
from debug import log
from helpers import Point2D
from palette_editor import PaletteEditor
from rom import ROM
from undo_redo import UndoRedo
class CutsceneEditor:
... | null |
v0 | [
"int"
] | None | def v0(self, v1: int) -> None:
self.palette_index = v1
self._selected_palette = 0
v2 = self.palette_editor.palettes[v1]
v3 = 0
for v4 in range(16):
v5 = bytes(self.palette_editor.get_colour(v2[v4]))
v6 = f'#{v5[0]:02X}{v5[1]:02X}{v5[2]:02X}'
if self._palette_items[v4] > 0:
... | [] | [] | [] | 13 | __author__ = "Fox Cunning"
from tkinter import Canvas
from typing import List
from PIL import Image, ImageTk
import colour
from appJar import appjar
from debug import log
from helpers import Point2D
from palette_editor import PaletteEditor
from rom import ROM
from undo_redo import UndoRedo
class CutsceneEditor:
... | null |
v0 | [
"int",
"int",
"int",
"int"
] | None | def v0(self, v1: int, v2: int, v3: int, v4: int) -> None:
v5 = self.palette_editor.sub_palette(self.palette_index, self._selected_palette)
while v3 > 0 and v4 < 256:
v6 = Image.new('P', (16, 16), 0)
v7 = bytes(self.rom.read_pattern(v1, v2))
v8 = Image.frombytes('P', (8, 8), v7)
v... | [] | [
"PIL"
] | [
"from PIL import Image, ImageTk"
] | 27 | __author__ = "Fox Cunning"
from tkinter import Canvas
from typing import List
from PIL import Image, ImageTk
import colour
from appJar import appjar
from debug import log
from helpers import Point2D
from palette_editor import PaletteEditor
from rom import ROM
from undo_redo import UndoRedo
class CutsceneEditor:
... | null |
v0 | [] | None | def v0(self) -> None:
v1 = 512
v2 = 480
v3 = 0
v4 = 0
v5 = 0
while v4 < v2 and v5 < len(self.nametable):
v6 = self.nametable[v5]
v7 = self.attributes[v5]
v8 = self.palette_editor.sub_palette(self.palette_index, v7)
try:
v9 = self._pattern_cache[v6]
... | [] | [
"PIL"
] | [
"from PIL import Image, ImageTk"
] | 48 | __author__ = "Fox Cunning"
from tkinter import Canvas
from typing import List
from PIL import Image, ImageTk
import colour
from appJar import appjar
from debug import log
from helpers import Point2D
from palette_editor import PaletteEditor
from rom import ROM
from undo_redo import UndoRedo
class CutsceneEditor:
... | null |
v0 | [
"int"
] | None | def v0(self, v1: int) -> None:
if 0 <= v1 <= 3:
if v1 != self._selected_palette:
v2 = self.palette_editor.sub_palette(self.palette_index, v1)
for v3 in range(256):
v4 = self._pattern_cache[v3]
v4.putpalette(v2)
if self._patterns[v3] > 0... | [] | [
"PIL"
] | [
"from PIL import Image, ImageTk"
] | 18 | __author__ = "Fox Cunning"
from tkinter import Canvas
from typing import List
from PIL import Image, ImageTk
import colour
from appJar import appjar
from debug import log
from helpers import Point2D
from palette_editor import PaletteEditor
from rom import ROM
from undo_redo import UndoRedo
class CutsceneEditor:
... | null |
v0 | [
"int",
"int"
] | None | def v0(self, v1: int, v2: int) -> None:
if self._selection_size == 1:
if v1 > 14:
v1 = 14
if v2 > 14:
v2 = 14
self._selected_pattern = v1 % 16 + (v2 << 4)
self.app.label('CE_Pattern_Info', f'Pattern: 0x{self._selected_pattern:02X}')
if self._pattern_rectangle > 0:... | [] | [] | [] | 13 | __author__ = "Fox Cunning"
from tkinter import Canvas
from typing import List
from PIL import Image, ImageTk
import colour
from appJar import appjar
from debug import log
from helpers import Point2D
from palette_editor import PaletteEditor
from rom import ROM
from undo_redo import UndoRedo
class CutsceneEditor:
... | null |
v0 | [
"int",
"int"
] | [] | def v0(self, v1: int, v2: int) -> []:
self._selected_tile = v1 % 32 + (v2 << 5)
self.app.label('CE_Info_Cutscene', f'Selection: {v1}, {v2} [0x{8192 + self._selected_tile:04X}] ' + f'| Pattern 0x{self.nametable[self._selected_tile]:02X} ' + f'| Palette {self.attributes[self._selected_tile]}')
if self._cutsce... | [] | [] | [] | 9 | __author__ = "Fox Cunning"
from tkinter import Canvas
from typing import List
from PIL import Image, ImageTk
import colour
from appJar import appjar
from debug import log
from helpers import Point2D
from palette_editor import PaletteEditor
from rom import ROM
from undo_redo import UndoRedo
class CutsceneEditor:
... | null |
v0 | [
"Any"
] | None | def v0(self, v1=None) -> None:
if len(self._undo_actions) < 1:
return
v2 = self._undo_actions.pop()
self._redo_actions.append(v2)
self._undo_redo.undo(v2) | [] | [] | [] | 6 | __author__ = "Fox Cunning"
from tkinter import Canvas
from typing import List
from PIL import Image, ImageTk
import colour
from appJar import appjar
from debug import log
from helpers import Point2D
from palette_editor import PaletteEditor
from rom import ROM
from undo_redo import UndoRedo
class CutsceneEditor:
... | null |
v0 | [] | None | def v0(self) -> None:
self._undo_redo.clear()
self._undo_actions = []
self._redo_actions = [] | [] | [] | [] | 4 | __author__ = "Fox Cunning"
from tkinter import Canvas
from typing import List
from PIL import Image, ImageTk
import colour
from appJar import appjar
from debug import log
from helpers import Point2D
from palette_editor import PaletteEditor
from rom import ROM
from undo_redo import UndoRedo
class CutsceneEditor:
... | null |
v0 | [
"any"
] | None | def v0(self, v1: any) -> None:
self._undo_actions.append(self._modified_tiles)
self._modified_tiles = 0
self._unsaved_changes = True | [] | [] | [] | 4 | __author__ = "Fox Cunning"
from tkinter import Canvas
from typing import List
from PIL import Image, ImageTk
import colour
from appJar import appjar
from debug import log
from helpers import Point2D
from palette_editor import PaletteEditor
from rom import ROM
from undo_redo import UndoRedo
class CutsceneEditor:
... | null |
v0 | [
"any"
] | None | def v0(self, v1: any) -> None:
self._last_modified.x = v1.x >> 4
self._last_modified.y = v1.y >> 4
v2 = self._last_modified.x % 32 + (self._last_modified.y << 5)
(v3, v4) = (self.nametable[v2], self.attributes[v2])
self._undo_redo(self.edit_nametable_entry, (self._last_modified.x, self._last_modifie... | [] | [] | [] | 7 | __author__ = "Fox Cunning"
from tkinter import Canvas
from typing import List
from PIL import Image, ImageTk
import colour
from appJar import appjar
from debug import log
from helpers import Point2D
from palette_editor import PaletteEditor
from rom import ROM
from undo_redo import UndoRedo
class CutsceneEditor:
... | null |
v0 | [
"any"
] | None | def v0(self, v1: any) -> None:
v2 = self._last_modified.x = v1.x >> 5 << 1
v3 = self._last_modified.y = v1.y >> 5 << 1
v4 = v2 % 32 + (v3 << 5)
(v5, v6) = (self.nametable[v4 + 33], self.attributes[v4 + 33])
self._undo_redo(self.edit_nametable_entry, (v2 + 1, v3 + 1, self._selected_pattern + 17), (v2... | [] | [] | [] | 13 | __author__ = "Fox Cunning"
from tkinter import Canvas
from typing import List
from PIL import Image, ImageTk
import colour
from appJar import appjar
from debug import log
from helpers import Point2D
from palette_editor import PaletteEditor
from rom import ROM
from undo_redo import UndoRedo
class CutsceneEditor:
... | null |
v0 | [
"any"
] | None | def v0(self, v1: any) -> None:
if 511 < v1.x < 0 or 479 < v1.y < 0:
return
v2 = v1.x >> 5 << 1
v3 = v1.y >> 5 << 1
if v2 == self._last_modified.x and v3 == self._last_modified.y:
return
else:
v4 = v2 % 32 + (v3 << 5)
self._last_modified.x = v2
self._last_modif... | [] | [] | [] | 20 | __author__ = "Fox Cunning"
from tkinter import Canvas
from typing import List
from PIL import Image, ImageTk
import colour
from appJar import appjar
from debug import log
from helpers import Point2D
from palette_editor import PaletteEditor
from rom import ROM
from undo_redo import UndoRedo
class CutsceneEditor:
... | null |
v0 | [
"any"
] | None | def v0(self, v1: any) -> None:
v2 = v1.x >> 5 << 1
v3 = v1.y >> 5 << 1
v4 = self.select_tile(v2, v3)
self.select_pattern(v4[0] % 16, v4[0] >> 4)
self.select_palette(v4[1]) | [] | [] | [] | 6 | __author__ = "Fox Cunning"
from tkinter import Canvas
from typing import List
from PIL import Image, ImageTk
import colour
from appJar import appjar
from debug import log
from helpers import Point2D
from palette_editor import PaletteEditor
from rom import ROM
from undo_redo import UndoRedo
class CutsceneEditor:
... | null |
v0 | [
"any"
] | None | def v0(self, v1: any) -> None:
v2 = v1.x >> 5
v3 = v1.y >> 5
self.select_pattern(v2 + (v3 << 3)) | [] | [] | [] | 4 | __author__ = "Fox Cunning"
from tkinter import Canvas
from typing import List
from PIL import Image, ImageTk
import colour
from appJar import gui
# ----------------------------------------------------------------------------------------------------------------------
from appJar.appjar import ItemLookupError
from d... | null |
v0 | [
"int",
"int",
"int"
] | None | def v0(self, v1: int, v2: int, v3: int) -> None:
v4 = v1 % 32 + (v2 << 5)
self.attributes[v4] = v3
v5 = self.palette_editor.sub_palette(self.palette_index, v3)
v6 = self.nametable[v4]
v7 = self._pattern_cache[v6]
v7.putpalette(v5)
self._tile_image_cache[v4] = ImageTk.PhotoImage(v7)
self.... | [] | [
"PIL"
] | [
"from PIL import Image, ImageTk"
] | 9 | __author__ = "Fox Cunning"
from tkinter import Canvas
from typing import List
from PIL import Image, ImageTk
import colour
from appJar import appjar
from debug import log
from helpers import Point2D
from palette_editor import PaletteEditor
from rom import ROM
from undo_redo import UndoRedo
class CutsceneEditor:
... | null |
v0 | [] | bool | def v0(self) -> bool:
v1: bool = True
if self._width == 32 and self._height == 30:
v2 = self.nametable
else:
v2 = bytearray()
for v3 in range(self._y, self._y + self._height):
for v4 in range(self._x, self._x + self._width):
v5 = self.nametable[v4 % 32 + (... | [] | [] | [] | 12 | __author__ = "Fox Cunning"
from tkinter import Canvas
from typing import List
from PIL import Image, ImageTk
import colour
from appJar import appjar
from debug import log
from helpers import Point2D
from palette_editor import PaletteEditor
from rom import ROM
from undo_redo import UndoRedo
class CutsceneEditor:
... | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.