content
stringlengths
35
762k
sha1
stringlengths
40
40
id
int64
0
3.66M
import os def get_ground_weather_one_place(dir_path): """ 1地点の地上気象データを取得する Args: dir_path(string) : ディレクトリパス Returns: DataFrame : ファイルの読込結果 """ # 地上気象データのファイル一覧取得 file_paths = read_csv.get_file_paths(dir_path) # 気象データを読み込み、DataFrameに格納する ground_df = None for file_path in file_paths: # 地上気象データ読み込み df = read_csv.read_ground(file_path) # 指定した行のデータを抽出 df1 = wdfproc.extract_row_isin(df, ('時', '時'), [9, 21]) # DataFrameに追加する if ground_df is None: ground_df = df1 else: ground_df = ground_df.append(df1) # 地点名を取得する dirname = os.path.basename(dir_path) elements = name_handle.elements_from_dirname_ground(dirname) place_name = elements['name'] # 列名を変更する ground_df = wdfproc.rename_column_ground(ground_df, place_name) return ground_df
b25c6008c1f1cf9760c16dc10fd44dee8e62ad55
5,200
def trash_description(spl, garbage, keyword, description="description_1"): """description_1 OR description_2""" relocate = spl[spl[description].str.contains(keyword, na=False, regex=True)] spl = spl[~spl[description].str.contains(keyword, na=False, regex=True)] garbage = pd.concat([garbage, relocate], ignore_index=True, sort=False) return (spl, garbage, relocate)
16a1512ddaf914bd5ebcd00f2dcdfa11d59ec73c
5,201
import random def prepositionalPhrase(): """Builds and returns a prepositional phrase.""" return random.choice(prepositions) + " " + nounPhrase()
33a6f1111f752c160ef90eedde4bf56b79b1100a
5,202
def check_possible_dtype(df): """Guess dtypes for each column in a dataframe, where dataframe must contains only string values. Raise an exception if dataframe contains non-string values. :param df: a DataFrame whose all values must be strings. """ column = [] int_cnt = [] dec_cnt = [] str_cnt = [] d = {"column": column, "int_cnt": int_cnt, "dec_cnt": dec_cnt, "str_cnt": str_cnt} for i in df.columns: ser = df[i].drop_duplicates() column.append(i) int_cnt.append(ser.apply(lambda x: is_int_str(x)).sum()) dec_cnt.append(ser.apply(lambda x: is_dec_str(x)).sum()) str_cnt.append(ser.apply(lambda x: not is_number_str(x)).sum()) dtype_options_df = pd.DataFrame(d, columns=["column", "int_cnt", "dec_cnt", "str_cnt"]) # Best-effort guess on dtype guessed_dtype = dtype_options_df.apply(guess_dtype, axis=1).rename("guessed_type_for_non_nan") return pd.concat([dtype_options_df, guessed_dtype], axis=1)
0e9759959af04fbf1bb9db3672f6a188afe7f6ab
5,203
from typing import List def filter_objects_avoiding_duplicated(objects: List[Object], max_distance: int = 20) -> List[Object]: """Filtra los objetos evitando aquellas posibles que sean detecciones múltiples. El fundamento del algoritmo es que si se detectan dos objetos con un centroide muy cercano, a una distancia máxima indicada por ``max_distance``, entonces es una detección múltiple. El conflicto se resuelve eliminando las detecciones múltiple y escogiendo la que mejor puntuación ha obtenido en la detección. :param objects: lista de objetos. :param max_distance: máxima distancia entre centros para considerar que ese objeto puede ser un duplicado. :return: lista de objetos filtrados. """ # Lista de las posiciones en 'objects' de los objetos eliminados. removed_objects_id = list() # Buscar los posibles candidatos para cada objeto. for obj_id, obj_detection in enumerate(objects): for candidate_id, candidate_detection in enumerate(objects): # Ignorar el mismo objeto como posible candidato. if obj_id == candidate_id: continue # Ignorar si alguno de los que se está comparando ha sido eliminado ya. if obj_id in removed_objects_id or candidate_id in removed_objects_id: continue # Calcular la distancia euclídea entre ambas detecciones. p = np.array(obj_detection.center) q = np.array(candidate_detection.center) distance = np.linalg.norm(p - q) # Si hay poca distancia, puede ser el mismo objeto. if distance <= max_distance: # Eliminar el que menos puntuación tiene. if obj_detection.score > candidate_detection.score: removed_objects_id.append(candidate_id) else: removed_objects_id.append(obj_id) # Lista de los objetos que han pasado el filtro. objects_filtered: List[Object] = list() for obj_id, obj_detection in enumerate(objects): if obj_id not in removed_objects_id: objects_filtered.append(obj_detection) return objects_filtered
042fee5df94dc1c72fb53635577c8006c57f73f9
5,204
import os def splitall(path): """ Credit goes to Trent Mick SOURCE: https://www.oreilly.com/library/view/python-cookbook/0596001673/ch04s16.html """ allparts = [] while 1: parts = os.path.split(path) if parts[0] == path: # sentinel for absolute paths allparts.insert(0, parts[0]) break elif parts[1] == path: # sentinel for relative paths allparts.insert(0, parts[1]) break else: path = parts[0] allparts.insert(0, parts[1]) return allparts
3d25bdfab5fd74d59e67100c864c950a2aaaa78b
5,205
import os def netstat(): """ Return list of all connections. Return list of TCP listenning connections and UDP connections. All localhost connections are filtered out. This script must run as root in order to be able to obtain PID values of all processes. For more information see: https://unix.stackexchange.com/questions/226276/read-proc-to-know-if-a-process-has-opened-a-port :return: List of connections """ uid = os.getuid() assert uid == 0, "This script must run as root" tcp4_list = netstat_tcp4() udp4_list = netstat_udp4() tcp6_list = netstat_tcp6() udp6_list = netstat_udp6() raw_list = netstat_raw() return tcp4_list + udp4_list + tcp6_list + udp6_list + raw_list
04884bd091438956012c1524671a1ffdfddc4c6f
5,206
def print_hdr(soup, hdr, file = None): """ :param soup: [bs4.BeautifulSoup] document context :param hdr: [dict] header node to process :param file: [stream] I/O stream to print to :return: [stream] pass on the I/O stream so descent continues """ tag = hdr['tag'] tag_id = tag['id'] indent = (hdr['level'] - 1) * ' ' # do this replacement for (relative) readability content_tags = ["<%s>" % (h.name) if h.name else h.string for h in hdr['content']] print("%s%s - %s %s" % (indent, tag.name, tag_id, content_tags), file=file) return file
2c6fd613a5c6ddb5ec842fb7cee845d1a8771ccd
5,207
from unittest.mock import Mock def __empty_2(): """ Empty used as parent of cube_2 """ obj = Mock() obj.name = 'empty_2' obj.mode = 'OBJECT' obj.to_mesh.return_value = None obj.matrix_world = Matrix.Identity(4) obj.visible_get.return_value = False obj.hide_viewport = True obj.hide_render = True return obj
024614d7967da5da6d6629167a20eda4188e812f
5,208
import argparse def parse_args(args): """Parse command line parameters Args: args ([str]): command line parameters as list of strings Returns: :obj:`argparse.Namespace`: command line parameters namespace """ parser = argparse.ArgumentParser( description="A scaffolding program for developer notes") parser.add_argument( "-v", "--version", action="version", version="nota {ver}".format(ver=__version__)) parser.add_argument( dest="name", help="name of new note", metavar="<name>") parser.add_argument( "-c", "--config", dest="config", help="configuration file location") parser.add_argument( "-t", "--template", dest="template", help="custom template file location") parser.add_argument( "-i", "--identifier", dest="identifier", help="custom note identifier") parser.add_argument( "--directories", dest="dirs", help="additional directories to create", action="append", nargs="+") parser.add_argument( "--filename", dest="filename", help="custom note filename") parser.add_argument( "-l", "--list", dest="list", help="lists all notes available", action="store_true") parser.add_argument( "-r", "--root", dest="root", help="root directory for all notes") group = parser.add_mutually_exclusive_group(required=True) group.add_argument( "-d", "--defect", dest="note_type", help="create a defect note", action="store_const", const=NoteType.Defect) group.add_argument( "-b", "--bug", dest="note_type", help="create a bug note", action="store_const", const=NoteType.Bug) group.add_argument( "-s", "--story", dest="note_type", help="create a story note", action="store_const", const=NoteType.Story) group.add_argument( "-f", "--feature", dest="note_type", help="create a feature note", action="store_const", const=NoteType.Feature) group.add_argument( "-o", "--option", dest="custom", help="create a custom note") return parser.parse_args(args)
8217e73fe219e18a8a7c8d0560fba95c5c3458df
5,209
def get_gradient(bf_data: np.ndarray, smooth=10): """ Removes first dimension, Computes gradient of the image, applies gaussian filter Returns SegmentedImage object """ data = strip_dimensions(bf_data) gradient = get_2d_gradient(data) smoothed_gradient = gaussian_filter(gradient, smooth) # sm = multiwell.gaussian_filter(well, smooth) return smoothed_gradient.reshape(bf_data.shape)
864b3bc118d08099c56657b2f2883e20de5c663e
5,210
def sum_seq(seq): """ Lambda wrapper for sum. """ return K.sum(seq, axis=1, keepdims=False)
e2bf342f6cda9bda50dc15814c7808a42e8a9925
5,211
def split_by_time(files_rad): """Separate a list of files by their timestamp""" out = {} if type(files_rad) == dict: for k in files_rad.keys(): out[k] = _split_by_time(files_rad[k]) else: out = _split_by_time(files_rad) return out
9a77b3db2e21c27198337b1a1852494bca5acefb
5,212
def make_general_csv_rows(general_csv_dict): """ Method for make list of metrics from general metrics dict. Rows using in general metrics writer :param general_csv_dict: dict with all metrics :type general_csv_dict: dict :return: all metrics as rows :rtype: list """ rows = [] for key, value in general_csv_dict.items(): row = [key[0], key[1]] row.extend(value) rows.append(row) return rows
45ca165d312b39cd0b7088e0bcbfb402a92e7e2b
5,213
def build_hstwcs(crval1, crval2, crpix1, crpix2, naxis1, naxis2, pscale, orientat): """ Create an HSTWCS object for a default instrument without distortion based on user provided parameter values. """ wcsout = wcsutil.HSTWCS() wcsout.wcs.crval = np.array([crval1,crval2]) wcsout.wcs.crpix = np.array([crpix1,crpix2]) wcsout.naxis1 = naxis1 wcsout.naxis2 = naxis2 wcsout.wcs.cd = fileutil.buildRotMatrix(orientat)*[-1,1]*pscale/3600.0 # Synchronize updates with PyWCS/WCSLIB objects wcsout.wcs.set() wcsout.setPscale() wcsout.setOrient() wcsout.wcs.ctype = ['RA---TAN','DEC--TAN'] return wcsout
0247a8dc7e6aa083db50f21d82676216583be206
5,214
def build_regressor_for_ranking_positive_class(dataset, features, regression_target=TARGET_COLUMN): """This function builds a regressor based exclusively on positive class' examples present in the dataset """ if regression_target in features: print('The target for the regression task cannot be one of the features') return positive_examples = dataset.loc[dataset[TARGET_COLUMN] > ALPHA] X = positive_examples[features] y = positive_examples[regression_target] regressor = RandomForestRegressor(random_state=20) regressor.fit(X, y) return regressor
1312751425f79c1e4fec09f705f0ea551e2a60b3
5,215
def get_speakable_timestamp(timestamp): """Return a 'speakable' timestamp, e.g. 8am, noon, 9pm, etc.""" speakable = f"{timestamp.strftime('%I').lstrip('0')} {timestamp.strftime('%p')}" if speakable == '12 PM': return 'noon' elif speakable == '12 AM': return 'midnight' return speakable
0b724686ebd5d3152d9017dc456d2945c78be0ee
5,216
def createColor(red: int, green: int, blue: int) -> tuple: """ Create color Parameters: red -> 0-255 green -> 0-255 blue -> 0-255 """ return tuple( max(min(red, 255), 0), max(min(green, 255), 0), max(min(blue, 255), 0) )
3e8ee43e9d458668f4312f9fd75050b5875036d7
5,217
from typing import List def export_nodeclass_list(node_classes: List[NodeClass]) -> str: """Writes the Node data as a XML string. Does not write to a file -- use ``with open(output_file) as out_stream:`` etc. """ # This is the data string, the rest is formalities node_classes_string = '\n'.join([str(c) for c in node_classes]) lines = list() lines.append('<?xml version="1.0" encoding="utf-8"?>') lines.append('<NodeClasses noNamespaceSchema="mff-muscima-mlclasses.xsd">') lines.append(node_classes_string) lines.append('</NodeClasses>') return '\n'.join(lines)
f50638e9b3a7ab2f1df6e49703b9ed3e39916f9d
5,218
import time def recognition(request): """ style transform service """ if request.method == 'POST': name = '' predicitons = '' try: # load image now = time.localtime() img = request.FILES['image'] image_name = '{}{}{}{}{}object.jpg'.format(now[1], now[2], now[3], now[4], now[5]) # get prediction predicitons = predict_app(img) # save to database Image = ContentImage() Image.name = 'static/images/predict/' + image_name Image.save() # save to disk addr = BASE_DIR + 'predict/' + image_name save_to_disk(addr, img) image_url = 'images/predict/' + image_name except Exception as e: print(e) return render(request, 'recognition/basic.html', {}) return render(request, 'recognition/basic.html', {'image_url':image_url, 'predictions': predicitons}) if request.method == 'GET': return render(request, 'recognition/basic.html', {})
d8de5ab5c33e6ca0c2ac5afbec81c402f7151187
5,219
def url(s): """Validate url input""" u = urlparse(s) if u.scheme not in ["http", "https"]: raise ValueError(s) return u.geturl()
82683af4ad6fb35b6d74409a9a429c4dfd81a723
5,220
import pickle def getGPLCs(df, savepath='./',plotpath='./', bands='ugrizY', ts='0000000', fn='GPSet'): """Short summary. Parameters ---------- df : type Description of parameter `df`. savepath : type Description of parameter `savepath`. plotpath : type Description of parameter `plotpath`. bands : type Description of parameter `bands`. ts : type Description of parameter `ts`. fn : type Description of parameter `fn`. Returns ------- type Description of returned object. """ #num_bands = len(np.unique(band_idx)) Npt = 100 tmin = -30 tmax = 150 num_bands = len(bands) GP_dict = {} # make our plots look nice stylePlots() for idx, row in df.iterrows(): t = np.array(row["T"]) f = np.array(row["Flux"]) f[f<0.] = 0. #getting rid of negative flux #the magnitude-like array for the sake of the conversion y = np.log(f + 1) yerr = np.array(row["Flux_Err"]) / np.array(row["Flux"]) t_test = np.linspace(tmin, tmax, Npt) band = row["Filter"] band_idx = pd.Series(row['Filter']).astype('category').cat.codes.values matrix = [t_test] def build_gp(params): time_kernel = tinygp.kernels.Matern32(jnp.exp(params["log_scale"])) kernel = Multiband(time_kernel, jnp.exp(params["log_diagonal"]), params["off_diagonal"]) diag = yerr ** 2 + jnp.exp(2 * params["log_jitter"][X[1]]) return tinygp.GaussianProcess(kernel, X, diag=diag, mean=lambda x: params["mean"][x[1]]) #the GP parameters @jax.jit def loss(params): return -build_gp(params).condition(y) X = (t, band_idx) solver = jaxopt.ScipyMinimize(fun=loss) soln = solver.run(params) gp = build_gp(soln.params) df_t = [] df_flux = [] df_flux_err = [] df_filt = [] if idx%50 == 0: plt.figure(figsize=(10,7)) for n in np.unique(band_idx): m = band_idx == n plt.errorbar(t[m], np.exp(y[m])-1,yerr=row['Flux_Err'][m], fmt="o", color=f"C{n}") mu, var = gp.predict(y, X_test=(t_test, np.full_like(t_test, n, dtype=int)), return_var=True) std = np.sqrt(var) if idx%50 == 0: plt.plot(t_test, np.exp(mu)-1, '.-', ms=2, color=f"C{n}") plt.fill_between(t_test,np.exp(mu - std)-1, np.exp(mu + std)+1, color=f"C{n}", alpha=0.3, label=bands[n]) #going in order of band here--don't forget it! matrix.append(np.exp(mu)-1) matrix.append(std) if idx%50 == 0: plt.xlim((t_test[0], t_test[-1])) plt.xlabel("Phase from Trigger (Days)") plt.ylabel("Flux") plt.legend() plt.savefig(plotpath + "/GP_%i.png"%row.CID,dpi=200, bbox_inches='tight') stacked = np.vstack(matrix) GP_dict[row.CID] = stacked with open(savepath + '/%s_%i.pkl'%(fn, ts), 'wb') as f: pickle.dump(GP_dict, f) return GP_dict
755dec48771ae17c058565ef88087d6ec6a78aec
5,221
import torch def _featurize(inputs,model): """ Helper function used to featurize exemplars before feeding into buffer. """ with torch.no_grad(): # Forward pass outputs = model(*inputs).detach() #Featurize raw exem return outputs
191fd1b362f38309a35618284fcf3f1910a06bd6
5,222
def ligth_condition(img, args): """ Change ligthning condition in the image Inputs: img: Image to change ligthning args: Dictionary with "gamma" argument Return: Image with ligthning values changed """ invGamma = 1.0 / args["gamma"] table = np.array([((i / 255.0) ** invGamma) * 255 for i in np.arange(0, 256)]).astype("uint8") return cv2.LUT(img, table)
dc5273a1df8e13292147b00be45452a7ccf4a197
5,223
import numpy as np from sklearn.metrics import mean_squared_error def calc_RMSE(varx,vary,lats,lons,weight): """ Calculates root mean square weighted average Parameters ---------- varx : 2d array vary : 2d array lons : 1d array of latitude weight : string (yes or no) Returns ------- rmse : 1d array Usage ----- rmse = calc_RMSE(varx,vary,lats,lons) """ print('\n>>> Using calc_RMSE function!') ### Import modules if weight == 'yes': # Computed weighted correlation coefficient ### mask mask = 'yes' if mask == 'yes': latq = np.where(lats > 30)[0] lats = lats[latq] varx = varx[latq,:] vary = vary[latq,:] print('MASKING LATITUDES!') ### Create 2d meshgrid for weights lon2,lat2 = np.meshgrid(lons,lats) ### Create 2d array of weights based on latitude gw = np.cos(np.deg2rad(lat2)) ### Calculate rmse sq_err = (varx - vary)**2 rmse = np.sqrt((np.sum(sq_err*gw))/np.sum(gw)) elif weight == 'no': ### Root mean square error from sklearn (not weighted) rmse = np.sqrt(mean_squared_error(varx.ravel(),vary.ravel())) print('Completed: Computed NON-weighted correlation!') else: ValueError('Wrong weighted arguement in function!') print('*Completed: Finished calc_RMSE function!') return rmse
150d08e0790f3a8ce59a2054cdc042ff6cdc2969
5,224
def sample(internal_nodes, alpha=0.5, beta=0.5, only_tree=False): """ Generates a junction tree with order internal nodes with the junction tree expander. Args: internal_nodes (int): number of nodes in the underlying graph alpha (float): parameter for the subtree kernel beta (float): parameter for the subtree kernel directory (string): path to Returns: NetworkX graph: a junction tree """ nodes = None if type(internal_nodes) is int: nodes = range(internal_nodes) else: nodes = internal_nodes tree = JunctionTree() #from trilearn.graph.junction_tree_gt import JunctionTreeGT #tree = JunctionTreeGT() tree.add_node(frozenset([nodes[0]])) # print tree.nodes() # for n in tree.nodes(): # lab = tuple(n) # if len(n) == 1: # lab = "("+str(list(n)[0])+")" # tree.node[n] = {"color": "black", "label": lab} for j in nodes[1:]: if only_tree: jte.sample(tree, j, alpha, beta, only_tree=only_tree) else: (tree, _, _, _, _, _) = jte.sample(tree, j, alpha, beta, only_tree=only_tree) #print("vert dict: " + str(tree.gp.vert_dict)) #print("nodes: " + str(list(tree.vp.nodes))) return tree
d0cc00e7ad96491147149aa4be396af970a9f68f
5,225
def _get_version_tuple(): """ version as a tuple """ return major, minor, revision
1d82390224de07964dce7c4e7fd3e32595b189a0
5,226
def _fit_seasonal_model_with_gibbs_sampling(observed_time_series, seasonal_structure, num_warmup_steps=50, num_results=100, seed=None): """Builds a seasonality-as-regression model and fits it by Gibbs sampling.""" with tf.name_scope('fit_seasonal_model_with_gibbs_sampling'): observed_time_series = sts_util.canonicalize_observed_time_series_with_mask( observed_time_series) dtype = observed_time_series.time_series.dtype design_matrix = seasonality_util.build_fixed_effects( num_steps=ps.shape(observed_time_series.time_series)[-2], seasonal_structure=seasonal_structure, dtype=dtype) # Default priors. # pylint: disable=protected-access one = tf.ones([], dtype=dtype) level_variance_prior = tfd.InverseGamma(concentration=16, scale=16. * 0.001**2 * one) level_variance_prior._upper_bound = one slope_variance_prior = tfd.InverseGamma(concentration=16, scale=16. * 0.05**2 * one) slope_variance_prior._upper_bound = 0.01 * one observation_noise_variance_prior = tfd.InverseGamma( concentration=0.05, scale=0.05 * one) observation_noise_variance_prior._upper_bound = 1.2 * one # pylint: enable=protected-access model = gibbs_sampler.build_model_for_gibbs_fitting( observed_time_series=observed_time_series, design_matrix=design_matrix, weights_prior=tfd.Normal(loc=0., scale=one), level_variance_prior=level_variance_prior, slope_variance_prior=slope_variance_prior, observation_noise_variance_prior=observation_noise_variance_prior) return [ model, gibbs_sampler.fit_with_gibbs_sampling(model, observed_time_series, num_results=num_results, num_warmup_steps=num_warmup_steps, seed=seed) ]
c13d4df3eca25f1a53ed27cd94e5f2b4b102013c
5,227
def deskew(data, angle, dx, dz, rotate=True, return_resolution=True, out=None): """ Args: data (ndarray): 3-D array to apply deskew angle (float): angle between the objective and coverslip, in degree dx (float): X resolution dz (float): Z resolution rotate (bool, optional): rotate and crop the output return_resolution (bool, optional): return deskewed X/Z resolution out (ndarray, optional): array to store the result """ angle = radians(angle) # shift along X axis, in pixels shift = dz * cos(angle) / dx logger.debug(f"layer shift: {shift:.04f} px") # estimate new size nw, nv, nu = data.shape nz, ny, nx = nw, nv, nu + ceil(shift * (nw - 1)) # upload texture ch = ChannelFormatDescriptor(32, 0, 0, 0, runtime.cudaChannelFormatKindFloat) arr = CUDAarray(ch, nu, nw) res = ResourceDescriptor(runtime.cudaResourceTypeArray, cuArr=arr) address_mode = (runtime.cudaAddressModeBorder, runtime.cudaAddressModeBorder) tex = TextureDescriptor( address_mode, runtime.cudaFilterModeLinear, runtime.cudaReadModeElementType ) # transpose data = np.swapaxes(data, 0, 1) data = np.ascontiguousarray(data) data_in = data.astype(np.float32) data_out = cp.empty((ny, nz, nx), np.float32) for i, layer in enumerate(data_in): arr.copy_from(layer) # TODO use stream texobj = TextureObject(res, tex) kernels["shear_kernel"]( (ceil(nx / 16), ceil(nz / 16)), (16, 16), (data_out[i, ...], texobj, nx, nz, nu, np.float32(shift)), ) data_out = cp.swapaxes(data_out, 0, 1) data_out = cp.asnumpy(data_out) data_out = data_out.astype(data.dtype) if return_resolution: # new resolution dz *= sin(angle) return data_out, (dz, dx) else: return data_out
a39ff1d48777c266e83358e272b6ba7d6d7ce894
5,228
import os import tqdm def process_data(path,stage = 'train'): """ train test sample_submission """ # loading the data df = pd.read_csv(os.path.join(path,f'{stage}.csv')) MASK = -1 # fill NA with -1 T_HIST = 10 # time history, last 10 games # for cols "date", change to datatime for col in df.filter(regex='date', axis=1).columns: df[col] = pd.to_datetime(df[col]) # Creating some feature engineering print('processing hitorical data...') for i in tqdm(range(1, 11)): # range from 1 to 10 # Feat. difference of days df[f'home_team_history_match_DIFF_day_{i}'] = (df['match_date'] - df[f'home_team_history_match_date_{i}']).dt.days df[f'away_team_history_match_DIFF_days_{i}'] = (df['match_date'] - df[f'away_team_history_match_date_{i}']).dt.days # Feat. difference of scored goals df[f'home_team_history_DIFF_goal_{i}'] = df[f'home_team_history_goal_{i}'] - df[f'home_team_history_opponent_goal_{i}'] df[f'away_team_history_DIFF_goal_{i}'] = df[f'away_team_history_goal_{i}'] - df[f'away_team_history_opponent_goal_{i}'] # Results: multiple nested where df[f'home_team_result_{i}'] = np.where(df[f'home_team_history_DIFF_goal_{i}'] > 0, 1, (np.where(df[f'home_team_history_DIFF_goal_{i}'] == 0, 0, np.where(df[f'home_team_history_DIFF_goal_{i}'].isna(),np.nan, -1)))) df[f'away_team_result_{i}'] = np.where(df[f'away_team_history_DIFF_goal_{i}'] > 0, 1, (np.where(df[f'away_team_history_DIFF_goal_{i}'] == 0, 0, np.where(df[f'away_team_history_DIFF_goal_{i}'].isna(), np.nan, -1)))) # Feat. difference of rating ("modified" ELO RATING) df[f'home_team_history_ELO_rating_{i}'] = 1 / (1 + 10 ** ((df[f'home_team_history_opponent_rating_{i}'] - df[f'home_team_history_rating_{i}']) / 10)) df[f'away_team_history_ELO_rating_{i}'] = 1 / (1 + 10 ** ((df[f'away_team_history_opponent_rating_{i}'] - df[f'away_team_history_rating_{i}']) / 10)) # df[f'away_team_history_DIFF_rating_{i}'] = - df[f'away_team_history_opponent_rating_{i}'] # Feat. same coach id df[f'home_team_history_SAME_coaX_{i}'] = np.where(df['home_team_coach_id'] == df[f'home_team_history_coach_{i}'], 1, 0) df[f'away_team_history_SAME_coaX_{i}'] = np.where(df['away_team_coach_id'] == df[f'away_team_history_coach_{i}'], 1, 0) # Feat. same league id #df[f'home_team_history_SAME_leaG_{i}'] = np.where(df['league_id'] == df[f'home_team_history_league_id_{i}'],1, 0) #df[f'away_team_history_SAME_leaG_{i}'] = np.where(df['league_id'] == df[f'away_team_history_league_id_{i}'],1, 0) # Fill NA with -1 print('done') df.fillna(MASK, inplace=True) # le = LabelEncoder() # df['home_team_name'] = le.fit_transform(df['home_team_name']) # df['away_team_name'] = le.fit_transform(df['away_team_name']) # df['league_name'] = le.fit_transform(df['league_name']) # save targets # y_train = train[['target_int']].to_numpy().reshape(-1, 1) id = df['id'].copy() drop_list = ['id', 'target', 'home_team_name', 'away_team_name'] if stage =='train': y = df['target'].copy() drop_list.append('target') else: y = None # keep only some features df.drop(drop_list, axis=1, inplace=True) df['is_cup'] = df['is_cup'].replace({True: 1, False: 0}) # Exclude all date, league, coach columns df.drop(df.filter(regex='date').columns, axis=1, inplace=True) df.drop(df.filter(regex='league').columns, axis=1, inplace=True) df.drop(df.filter(regex='coach').columns, axis=1, inplace=True) # Store feature names feature_names = list(df.columns) # Scale features using statistics that are robust to outliers RS = RobustScaler() df = RS.fit_transform(df) # Back to pandas.dataframe df = pd.DataFrame(df, columns=feature_names) df = pd.concat([id, df], axis=1) # Pivot dataframe to create an input array for the LSTM network feature_groups = ["home_team_history_is_play_home", "home_team_history_is_cup", "home_team_history_goal", "home_team_history_opponent_goal", "home_team_history_rating", "home_team_history_opponent_rating", "away_team_history_is_play_home", "away_team_history_is_cup", "away_team_history_goal", "away_team_history_opponent_goal", "away_team_history_rating", "away_team_history_opponent_rating", "home_team_history_match_DIFF_day", "away_team_history_match_DIFF_days", "home_team_history_DIFF_goal", "away_team_history_DIFF_goal", "home_team_history_ELO_rating", "away_team_history_ELO_rating", "home_team_history_SAME_coaX", "away_team_history_SAME_coaX", "home_team_history_SAME_leaG", "away_team_history_SAME_leaG", "home_team_result", "away_team_result"] # Pivot dimension (id*features) x time_history x_pivot = pd.wide_to_long(df, stubnames=feature_groups,i='id', j='time', sep='_', suffix='\d+') # Trying to keep the same id order x = pd.merge(id, x_pivot, on="id") x = x.drop(['id'], axis=1).to_numpy().reshape(-1, T_HIST, x_pivot.shape[-1]) return x,y
ff6542c8a4f7366c2a1b612d7b41e3aa539e34a4
5,229
import pandas as pd import numpy as np def rm_standard_dev(var,window): """ Smoothed standard deviation """ print('\n\n-----------STARTED: Rolling std!\n\n') rollingstd = np.empty((var.shape)) for ens in range(var.shape[0]): for i in range(var.shape[2]): for j in range(var.shape[3]): series = pd.Series(var[ens,:,i,j]) rollingstd[ens,:,i,j] = series.rolling(window).std().to_numpy() newdata = rollingstd[:,window:,:,:] print('-----------COMPLETED: Rolling std!\n\n') return newdata
d37cfa3c756f8fc062a28ac078e4e16557282951
5,230
import os def load_letter(folder, min_num_images): """Load the data for a single letter label.""" image_files = os.listdir(folder) dataset = np.ndarray(shape=(len(image_files), image_size, image_size), dtype=np.float32) image_index = 0 print(folder) for image in os.listdir(folder): image_file = os.path.join(folder, image) try: image_data = (ndimage.imread(image_file).astype(float) - pixel_depth / 2) / pixel_depth if image_data.shape != (image_size, image_size): raise Exception('Unexpected image shape: %s' % str(image_data.shape)) dataset[image_index, :, :] = image_data image_index += 1 except IOError as e: print('Could not read:', image_file, ':', e, '- it\'s ok, skipping.') num_images = image_index dataset = dataset[0:num_images, :, :] if num_images < min_num_images: raise Exception('Many fewer images than expected: %d < %d' % (num_images, min_num_images)) print('Full dataset tensor:', dataset.shape) print('Mean:', np.mean(dataset)) print('Standard deviation:', np.std(dataset)) return dataset
30324858e8481b348f004dfbc39bf790cd0ca930
5,231
def visualizeTimeSeriesCategorization(dataName, saveDir, numberOfLagsToDraw=3, autocorrelationBased=True): """Visualize time series classification. Parameters: dataName: str Data name, e.g. "myData_1" saveDir: str Path of directories pointing to data storage numberOfLagsToDraw: boolean, Default 3 First top-N lags (or frequencies) to draw autocorrelationBased: boolean, Default True Whether autocorrelation or frequency based Returns: None Usage: visualizeTimeSeriesClassification('myData_1', '/dir1/dir2/') """ info = 'Autocorrelations' if autocorrelationBased else 'Periodograms' def internal(className): print('\n\n%s of Time Series:'%(className)) clusteringObject = dataStorage.read(saveDir + 'consolidatedGroupsSubgroups/' + dataName + '_%s_%s'%(className,info) + '_GroupsSubgroups') if clusteringObject is None: print('Clustering object not found') return print('Plotting Dendrogram with Heatmaps.') visualizationFunctions.makeDendrogramHeatmapOfClusteringObject(clusteringObject, saveDir, dataName + '_%s_%sBased'%(className,info), AutocorrNotPeriodogr=autocorrelationBased) return for lag in range(1,numberOfLagsToDraw + 1): internal('LAG%s'%(lag)) internal('SpikeMax') internal('SpikeMin') return None
b2fcac2179e3a689ee73e13519e2f4ad77c59037
5,232
from typing import Dict def refund(payment_information: Dict, connection_params) -> Dict: """Refund a payment using the culqi client. But it first check if the given payment instance is supported by the gateway. It first retrieve a `charge` transaction to retrieve the payment id to refund. And return an error with a failed transaction if the there is no such transaction, or if an error from culqi occurs during the refund.""" error = check_payment_supported(payment_information=payment_information) response_has_errors = False if error: response = get_error_response( payment_information.amount, error=error) else: setup_client(**connection_params) try: payload = format_culqui_payload( payment_information, TransactionKind.REFUND) response = culqipy.Refund.create(payload) print(f"DATA::response::{response}") # Fix: get specific errors except Exception as error: response_has_errors = True response = get_error_response( payment_information.amount, error=error) if not response_has_errors: if response.get('object', None) == 'error': error = response.get('user_message', None) if error is None: error = response.get('merchant_message', None) if error is None: error = 'Unkonw error!' response = get_error_response( payment_information.amount, error=error, id=payment_information.token) else: clean_culqi_response(response) return _generate_response( payment_information=payment_information, kind=TransactionKind.REFUND, data=response)
75dff392c0748a1408eb801ad78ef65be988026c
5,233
import argparse import os def get_args(): """Get command-line arguments""" parser = argparse.ArgumentParser( description='Howler', formatter_class=argparse.ArgumentDefaultsHelpFormatter) parser.add_argument('text', metavar='str', help='Input text or file') parser.add_argument('-o', '--outfile', help='Output filename', metavar='str', type=str, default='') args = parser.parse_args() #if the args.text is a file name (checks using os.path.isfile) if os.path.isfile(args.text): args.text = open(args.text).read().rstrip() #then open args.text, read its name and strip the whitespace out return args
906e38ad510016068ca7d431c681b4680ee56f5d
5,234
import torch from typing import Tuple def _ssim_map( X: torch.Tensor, Y: torch.Tensor, data_range: float, win: torch.Tensor, K: Tuple[float, float] = (0.01, 0.03), scales: Tuple[float, float, float] = (1, 1, 1), gradient_based: bool = False, ) -> Tuple[torch.Tensor, torch.Tensor]: """ Given two tensors it calculates the resulting SSIM and contrast sensitivity maps. Args: X (torch.Tensor): images Y (torch.Tensor): images data_range (float): value range of input images. win (torch.Tensor): 1-D gauss kernel K (Tuple[float,float]): stability constants (K1, K2). Defaults to (0.01, 0.03). gradient_based (bool): whether or not to use gradient based ssim. Returns: torch.Tensor: SSIM map torch.Tensor: contrast sensitivity map References: [1] Wang, Z., Bovik, A.C., Sheikh, H.R. and Simoncelli, E.P., 2004. Image quality assessment: from error visibility to structural similarity. IEEE transactions on image processing, 13(4), pp.600-612. """ K1, K2 = K alpha, beta, gamma = scales C1 = (K1 * data_range) ** 2 C2 = (K2 * data_range) ** 2 C3 = C2 / 2 win = win.to(X.device, dtype=X.dtype) # TODO: Replace this with fftconvolution mu1 = _gaussian_filter(X, win) mu2 = _gaussian_filter(Y, win) mu1_sq = mu1.pow(2) mu2_sq = mu2.pow(2) mu1_mu2 = mu1 * mu2 print(f"mu1: {torch.isnan(mu1).any()}") print(f"mu2: {torch.isnan(mu2).any()}") print(f"mu1_sq: {torch.isnan(mu1_sq).any()}") print(f"mu2_sq: {torch.isnan(mu2_sq).any()}") print(f"mu1_mu2: {torch.isnan(mu1_mu2).any()}") # Ref 1 - Sec 3.B - Eq 6 luminance = (2 * mu1_mu2 + C1) / (mu1_sq + mu2_sq + C1) print(f"Luminance: {torch.isnan(luminance).any()}") if gradient_based: X = _gradient_map(input=X) Y = _gradient_map(input=Y) mu1 = _gaussian_filter(X, win) mu2 = _gaussian_filter(Y, win) mu1_sq = mu1.pow(2) mu2_sq = mu2.pow(2) mu1_mu2 = mu1 * mu2 # TODO: Understand why it is squared sigma1_sq = _gaussian_filter(X * X, win) - mu1_sq sigma2_sq = _gaussian_filter(Y * Y, win) - mu2_sq sigma12 = _gaussian_filter(X * Y, win) - mu1_mu2 print(torch.min(sigma1_sq)) print(torch.min(sigma2_sq)) sigma1 = torch.sqrt(sigma1_sq) sigma2 = torch.sqrt(sigma2_sq) print(f"sigma1: {torch.isnan(sigma1).any()}") print(f"sigma2: {torch.isnan(sigma2).any()}") print(f"sigma12: {torch.isnan(sigma12).any()}") print(f"sigma1_sq: {torch.isnan(sigma1_sq).any()}") print(f"sigma2_sq: {torch.isnan(sigma2_sq).any()}") # Ref 1 - Sec 3.B - Eq 9 contrast = (2 * sigma1 * sigma2 + C2) / (sigma1_sq + sigma2_sq + C2) print(f"Contrast: {torch.isnan(contrast).any()}") # Ref 1 - Sec 3.B - Eq 10 structure = (sigma12 + C3) / (sigma1 * sigma2 + C3) print(f"Structure {torch.isnan(structure).any()}") # Ref 1 - Sec 3.B - Eq 12 luminance = torch.pow(luminance, alpha) contrast = torch.pow(contrast, beta) structure = torch.pow(structure, gamma) ssim_map = luminance * contrast * structure return ssim_map, contrast
3a1d34497228bb95d0bc295475fb0df38220107b
5,235
import numbers def check_random_state(seed): """Turn `seed` into a `np.random.RandomState` instance. Parameters ---------- seed : {None, int, `numpy.random.Generator`, `numpy.random.RandomState`}, optional If `seed` is None (or `np.random`), the `numpy.random.RandomState` singleton is used. If `seed` is an int, a new ``RandomState`` instance is used, seeded with `seed`. If `seed` is already a ``Generator`` or ``RandomState`` instance then that instance is used. Returns ------- seed : {`numpy.random.Generator`, `numpy.random.RandomState`} Random number generator. """ if seed is None or seed is np.random: return np.random.mtrand._rand if isinstance(seed, (numbers.Integral, np.integer)): return np.random.default_rng(seed) if isinstance(seed, (np.random.RandomState, np.random.Generator)): return seed raise ValueError( "%r cannot be used to seed a numpy.random.RandomState" " instance" % seed )
57390806329776c77977a27e18e78fdad298fef9
5,236
def power3_sum_2method(): """ Input: nothing, it have everything it needs. Output: sum: summ of all numbers which is power of 3 and fit in between 0 and upper bound == 1000000 """ k = 0 sum = 0 while True: a = 3**k k += 1 if a < 1000000: sum += a else: break return sum
b86bfaeb2418e183a78054d2a4b76c58d58be388
5,237
def bitwise_right_shift(rasters, extent_type="FirstOf", cellsize_type="FirstOf", astype=None): """ The BitwiseRightShift operation The arguments for this function are as follows: :param rasters: array of rasters. If a scalar is needed for the operation, the scalar can be a double or string :param extent_type: one of "FirstOf", "IntersectionOf", "UnionOf", "LastOf" :param cellsize_type: one of "FirstOf", "MinOf", "MaxOf, "MeanOf", "LastOf" :param astype: output pixel type :return: the output raster """ return local(rasters, 15, extent_type=extent_type, cellsize_type=cellsize_type, astype=astype)
8d07a60a514466ee4aa0b15b0b442fb71b3347ed
5,238
import re def strip_comments(line): """Strips comments from a line and return None if the line is empty or else the contents of line with leading and trailing spaces removed and all other whitespace collapsed""" commentIndex = line.find('//') if commentIndex is -1: commentIndex = len(line) line = re.sub(r'\s+', ' ', line[:commentIndex].strip()) if line == '': return None else: return line
09579031294d7b5787c97fa81807fa5ecfe12329
5,239
import logging def fft_pxscale(header,wave): """Compute conversion scale from telescope space to sky space. Parameters ---------- ima : array 2D Telescope pupil model. Returns ------- fftscale : float The frequency scale in sky space. Example ------- .. code-block:: python fftscale = fft_pxscale(ima) """ #size of the image. This should be taken from the header. gridsize = header['NAXIS1'] #pixel scale of the image. This should be taken from the header. pxscale_mod = header['PIXSCALE'] #in meters/px #1D FFT of the gridsize. fft_freq=np.fft.fftfreq(gridsize,pxscale_mod) #wavelength of the desires psf. This is a input of the user, wavelength in microns wave = (getQuantity(wave,recognized_units=UNITS['WAVE'])) lam = wave.to(u.m) #in meters #re-orginizing the 1D FFT to match with the grid. roll=np.floor(gridsize//2).astype("int") freq = np.fft.fftshift(fft_freq) ## ## pxscale -> fftscale fftscale=np.diff(freq)[0] ## cycles / mas per pixel in FFT image mas2rad=np.deg2rad(1./3600000.) ## mas per rad fftscale = fftscale/mas2rad * lam ## meters baseline per px in FFT image at a given wavelength logging.info("Pixel scale in PSF image is: %g mas per pixel" % fftscale.value) return fftscale.value
6935bdefe96aec771704a79952cfc25ffb55e8bb
5,240
def parse_git_submodules(gitmodules_data): """Parse a .gitmodules file to extract a { name -> url } map from it.""" result = {} # NOTE: configparser.ConfigParser() doesn't seem to like the file # (i.e. read_string() always returns None), so do the parsing # manually here. section_name = None in_submodule_section = False submodule_name = None submodule_prefix = 'submodule "' urls = {} branches = {} for line in gitmodules_data.splitlines(): if line.startswith('['): section_name = line[1:-1] is_submodule_section = section_name.startswith(submodule_prefix) if is_submodule_section: submodule_name = section_name[len(submodule_prefix):-1] elif is_submodule_section: key, _, value = line.strip().partition('=') if not value: continue key = key.strip() value = value.strip() if key == 'url': urls[submodule_name] = value elif key == 'branch': branches[submodule_name] = value result = {} for submodule, url in urls.iteritems(): branch = branches.get(submodule) if not branch: branch = get_git_remote_ref(url, 'heads/master') result[submodule] = '%s@%s' % (url, branch) return result
78d01ec70b68164189a2ea775c6084e256116d0a
5,241
import pathlib from typing import Dict import json def get_model_cases(dir_path: pathlib.Path) -> Dict[str, Dict[str, str]]: """ Returns the Zen model case for each test if it exists. :param dir_path: The path to the directory containing the DIFFERENCES directory. """ model_cases = defaultdict(dict) # type: Dict[str, Dict[str, str]] queries_dir = dir_path / QUERIES expected_res_dir = dir_path / QUERY_RESPONSES tag_dir = None if queries_dir.exists() and queries_dir.is_dir(): tag_dir = queries_dir elif expected_res_dir.exists() and expected_res_dir.is_dir(): tag_dir = expected_res_dir if isinstance(tag_dir, pathlib.Path): for queries_file in tag_dir.iterdir(): with open(queries_file, 'r') as qf_fp: queries_info = json.load(qf_fp) for qinfo in queries_info: if "ZenResponseTag" in qinfo: query_str = qinfo["Query"]["Name"] + ":" +\ qinfo["Query"]["Type"] model_cases[queries_file.stem][query_str] = qinfo["ZenResponseTag"] return model_cases
d35b4cf59cf9b99a6aeb9e05e0af3ee342b11f3b
5,242
def _format_date(event): """Returns formated date json object for event""" old_date = event["date"] term = event["term"] dates = old_date.split("-") if len(dates) == 1: is_range = False else: is_range = True is_range = (len(dates) > 1) if is_range: start_date = dates[0] end_date = dates[-1] else: start_date = dates[0] end_date = dates[0] new_start_date = _format_date_string(start_date, term) new_end_date = _format_date_string(end_date, term) date = { "start_date": new_start_date, "end_date": new_end_date, "range": is_range, } return date
aa8bf9a41fe30b664920e895cdc31d6993a408b2
5,243
def fetch(bibcode, filename=None, replace=None): """ Attempt to fetch a PDF file from ADS. If successful, then add it into the database. If the fetch succeeds but the bibcode is not in th database, download file to current folder. Parameters ---------- bibcode: String ADS bibcode of entry to update. filename: String Filename to assign to the PDF file. If None, get from guess_name() funcion. Replace: Bool If True, enforce replacing a PDF regardless of a pre-existing one. If None (default), only ask when fetched PDF comes from arxiv. Returns ------- filename: String If successful, return the full path of the file name. If not, return None. """ arxiv = False print('Fetching PDF file from Journal website:') req = request_ads(bibcode, source='journal') if req is None: return if req.status_code != 200: print('Fetching PDF file from ADS website:') req = request_ads(bibcode, source='ads') if req is None: return if req.status_code != 200: print('Fetching PDF file from ArXiv website:') req = request_ads(bibcode, source='arxiv') arxiv = True if replace is None: replace = False if req is None: return if replace is None: replace = True if req.status_code == 200: if bm.find(bibcode=bibcode) is None: if filename is None: filename = f'{bibcode}.pdf' with builtin_open(filename, 'wb') as f: f.write(req.content) print(f"Saved PDF to: '{filename}'.\n" "(Note that BibTex entry is not in the Bibmanager database)") else: filename = set_pdf( bibcode, bin_pdf=req.content, filename=filename, arxiv=arxiv, replace=replace) return filename print('Could not fetch PDF from any source.')
7d264df3f0eab896a9cb4858e7b19e2590d8142b
5,244
def crop_multi(x, wrg, hrg, is_random=False, row_index=0, col_index=1): """Randomly or centrally crop multiple images. Parameters ---------- x : list of numpy.array List of images with dimension of [n_images, row, col, channel] (default). others : args See ``tl.prepro.crop``. Returns ------- numpy.array A list of processed images. """ h, w = x[0].shape[row_index], x[0].shape[col_index] if (h < hrg) or (w < wrg): raise AssertionError("The size of cropping should smaller than or equal to the original image") if is_random: h_offset = int(np.random.uniform(0, h - hrg)) w_offset = int(np.random.uniform(0, w - wrg)) results = [] for data in x: results.append(data[h_offset:hrg + h_offset, w_offset:wrg + w_offset]) return np.asarray(results) else: # central crop h_offset = int(np.floor((h - hrg) / 2.)) w_offset = int(np.floor((w - wrg) / 2.)) results = [] for data in x: results.append(data[h_offset:h - h_offset, w_offset:w - w_offset]) return np.asarray(results)
61593029455a880d5309e8343cf4f6d1049f598f
5,245
def value_loss_given_predictions(value_prediction, rewards, reward_mask, gamma, epsilon, value_prediction_old=None): """Computes the value loss given the prediction of the value function. Args: value_prediction: np.ndarray of shape (B, RT+1, 1) rewards: np.ndarray of shape (B, RT) of rewards. reward_mask: np.ndarray of shape (B, RT), the mask over rewards. gamma: float, discount factor. epsilon: float, clip-fraction, used if value_value_prediction_old isn't None value_prediction_old: np.ndarray of shape (B, RT+1, 1) of value predictions using the old parameters. If provided, we incorporate this in the loss as well. This is from the OpenAI baselines implementation. Returns: Pair (value_loss, summaries), where value_loss is the average L2 value loss, averaged over instances where reward_mask is 1. Summaries is a dict of summaries collected during value loss computation. """ B, RT = rewards.shape # pylint: disable=invalid-name assert (B, RT) == reward_mask.shape assert (B, RT + 1) == value_prediction.shape value_prediction = value_prediction[:, :-1] * reward_mask # (B, RT) r2g = rewards_to_go(rewards, reward_mask, gamma=gamma) # (B, RT) loss = (value_prediction - r2g)**2 # From the baselines implementation. if value_prediction_old is not None: value_prediction_old = value_prediction_old[:, :-1] * reward_mask # (B, RT) v_clipped = value_prediction_old + np.clip( value_prediction - value_prediction_old, -epsilon, epsilon) v_clipped_loss = (v_clipped - r2g)**2 loss = np.maximum(v_clipped_loss, loss) # Take an average on only the points where mask != 0. value_loss = np.sum(loss) / np.sum(reward_mask) summaries = { 'value_loss': value_loss, } return (value_loss, summaries)
5896dd57e1e9d05eb71e5b31aab4071b61d0fdbf
5,246
def build_pkt(pkt): """Build and return a packet and eth type from a dict.""" def serialize(layers): """Concatenate packet layers and serialize.""" result = packet.Packet() for layer in reversed(layers): result.add_protocol(layer) result.serialize() return result layers = [] assert 'eth_dst' in pkt and 'eth_src' in pkt ethertype = None if 'arp_source_ip' in pkt and 'arp_target_ip' in pkt: ethertype = ether.ETH_TYPE_ARP arp_code = pkt.get('arp_code', arp.ARP_REQUEST) layers.append(arp.arp( src_ip=pkt['arp_source_ip'], dst_ip=pkt['arp_target_ip'], opcode=arp_code)) elif 'ipv6_src' in pkt and 'ipv6_dst' in pkt: ethertype = ether.ETH_TYPE_IPV6 if 'router_solicit_ip' in pkt: layers.append(icmpv6.icmpv6( type_=icmpv6.ND_ROUTER_SOLICIT)) elif 'neighbor_advert_ip' in pkt: layers.append(icmpv6.icmpv6( type_=icmpv6.ND_NEIGHBOR_ADVERT, data=icmpv6.nd_neighbor( dst=pkt['neighbor_advert_ip'], option=icmpv6.nd_option_sla(hw_src=pkt['eth_src'])))) elif 'neighbor_solicit_ip' in pkt: layers.append(icmpv6.icmpv6( type_=icmpv6.ND_NEIGHBOR_SOLICIT, data=icmpv6.nd_neighbor( dst=pkt['neighbor_solicit_ip'], option=icmpv6.nd_option_sla(hw_src=pkt['eth_src'])))) elif 'echo_request_data' in pkt: layers.append(icmpv6.icmpv6( type_=icmpv6.ICMPV6_ECHO_REQUEST, data=icmpv6.echo(id_=1, seq=1, data=pkt['echo_request_data']))) layers.append(ipv6.ipv6( src=pkt['ipv6_src'], dst=pkt['ipv6_dst'], nxt=inet.IPPROTO_ICMPV6)) elif 'ipv4_src' in pkt and 'ipv4_dst' in pkt: ethertype = ether.ETH_TYPE_IP proto = inet.IPPROTO_IP if 'echo_request_data' in pkt: echo = icmp.echo(id_=1, seq=1, data=pkt['echo_request_data']) layers.append(icmp.icmp(type_=icmp.ICMP_ECHO_REQUEST, data=echo)) proto = inet.IPPROTO_ICMP net = ipv4.ipv4(src=pkt['ipv4_src'], dst=pkt['ipv4_dst'], proto=proto) layers.append(net) elif 'actor_system' in pkt and 'partner_system' in pkt: ethertype = ether.ETH_TYPE_SLOW layers.append(slow.lacp( version=1, actor_system=pkt['actor_system'], actor_port=1, partner_system=pkt['partner_system'], partner_port=1, actor_key=1, partner_key=1, actor_system_priority=65535, partner_system_priority=1, actor_port_priority=255, partner_port_priority=255, actor_state_defaulted=0, partner_state_defaulted=0, actor_state_expired=0, partner_state_expired=0, actor_state_timeout=1, partner_state_timeout=1, actor_state_collecting=1, partner_state_collecting=1, actor_state_distributing=1, partner_state_distributing=1, actor_state_aggregation=1, partner_state_aggregation=1, actor_state_synchronization=pkt['actor_state_synchronization'], partner_state_synchronization=1, actor_state_activity=0, partner_state_activity=0)) elif 'chassis_id' in pkt and 'port_id' in pkt: ethertype = ether.ETH_TYPE_LLDP return valve_packet.lldp_beacon( pkt['eth_src'], pkt['chassis_id'], str(pkt['port_id']), 1, org_tlvs=pkt.get('org_tlvs', None), system_name=pkt.get('system_name', None)) assert ethertype is not None, pkt if 'vid' in pkt: tpid = ether.ETH_TYPE_8021Q layers.append(vlan.vlan(vid=pkt['vid'], ethertype=ethertype)) else: tpid = ethertype eth = ethernet.ethernet( dst=pkt['eth_dst'], src=pkt['eth_src'], ethertype=tpid) layers.append(eth) result = serialize(layers) return result
afd84446d3bb545b03b9d4c42d80f096b6665342
5,247
def make_file_prefix(run, component_name): """ Compose the run number and component name into string prefix to use with filenames. """ return "{}_{}".format(component_name, run)
73ef37d75d9e187ee49ee058958c3b8701185585
5,248
def identifier_needs_escaping(text): """ Slightly slow, but absolutely correct determination if a given symbol _must_ be escaped. Necessary when you might be generating column names that could be a reserved keyword. >>> identifier_needs_escaping("my_column") False >>> identifier_needs_escaping("my_column3424") False >>> identifier_needs_escaping("my column with spaces") True >>> identifier_needs_escaping("mycolumn;") True >>> identifier_needs_escaping("SELECT") True >>> identifier_needs_escaping("my_column.blah") True >>> identifier_needs_escaping("UPDATE") True >>> identifier_needs_escaping("column ") True """ # TODO: Replace with custom caching decorator? global _ident_needs_escaping_cache if text not in _ident_needs_escaping_cache: try: ast = sql_subexpr_ast(text, "identifier") _ident_needs_escaping_cache[text] = not ( isinstance(ast, Identifier) and ast.text == text ) except Exception as e: _ident_needs_escaping_cache[text] = True return _ident_needs_escaping_cache[text]
265f7acd1e92a954758f44eb03247b0b935d6d4d
5,249
from typing import Dict def initialize_lock_and_key_ciphers() -> Dict[str, VigenereCipher]: """[summary] Returns: Dict[VigenereCipher]: [description]""" ciphers = {} with open(CIPHER_RESOURCE, "r") as cipher_resource_file: cipher_data = load(cipher_resource_file, Loader=FullLoader) for cipher_key_name, cipher_keys in cipher_data.items(): ciphers[cipher_key_name] = VigenereCipher(key=cipher_keys['key'], alphabet=cipher_keys['alphabet']) return ciphers
1c0a27b36b4c0524b77dcb5c44a3bc840797b226
5,250
def add_service(): """ Used to register a new service """ form = ServiceForm() if form.validate_on_submit(): try: srv = Services() srv.populate_from_form(form) srv.authentication.value = {"db":request.form.get('authdb'),"user":request.form.get('authuser'),"pswd":request.form.get("authpass")} srv.save() flash('Datele au fost adaugate!', category='alert-success') return redirect(url_for('services.list_services')) except Exception as err: flash('Datele nu pot fi adaugate!', category='alert-danger') return render_template('services/settings/add.html', pagetitle='Adauga serviciu', form=form)
56ce52c293d42710a9d4d5ac57b21f5ba1c0c0ac
5,251
def f_columnas_pips(datos): """ Parameters ---------- datos : pandas.DataFrame : df con información de transacciones ejecutadas en Oanda, después de haber ejecutado f_columnas_tiempos Returns ------- datos : pandas.DataFrame : df modificado Debugging ------- datos = 'f_leer_archivo("archivo_tradeview_1.csv") """ datos['pips'] = [(datos.closeprice[i]-datos.openprice[i])*f_pip_size(datos.symbol[i]) for i in range(len(datos))] datos['pips'][datos.type=='sell'] *= -1 datos['pips_acm'] = datos.pips.cumsum() datos['profit_acm'] = datos['profit'].cumsum() return datos.copy()
5d6d47d23dbe16f3619b7e1264d30e91a9acd8ce
5,252
def parse_resolution(resolution): """ return: width, height, resolution """ resolution = resolution.strip() splits = resolution.split(',') return int(splits[0]), int(splits[1]), int(splits[2])
de937e440c4540d11cedd868e3f4a046baa99f22
5,253
def link_cube(cube, locale, provider=None, namespace=None, ignore_missing=False): """Links dimensions to the `cube` in the `context` object. The `context` object should implement a function `dimension(name, locale, namespace, provider)`. Modifies cube in place, returns the cube. """ # TODO: change this to: link_cube(cube, locale, namespace, provider) # Assumption: empty cube linked = set() for dim_name in list(cube.dimension_links.keys()): if dim_name in linked: raise ModelError("Dimension '{}' linked twice" .format(dim_name)) try: dim = find_dimension(dim_name, locale, provider=provider, namespace=namespace) except TemplateRequired as e: raise ModelError("Dimension template '%s' missing" % dim_name) if not dim and not ignore_missing: raise CubesError("Dimension '{}' not found.".format(dim_name)) cube.link_dimension(dim) return cube
09062ff3fd9dcfeeac7a746557c7f5384e4560a6
5,254
import argparse def _parser() -> argparse.Namespace: """Take care of all the argparse stuff. :returns: the args """ # parser = GooeyParser(description='Remove : from data files') parser = argparse.ArgumentParser(description='Combines Nods using ') parser.add_argument('listspectra', help='List of spectra to combine.', default=False) parser.add_argument('-o', "--optimal-nods", help="Optimal nod bool matrix file.") parser.add_argument("-s", "--spectralcoords", default=False, action="store_true", help="Turn spectra into spectral coordinates first before adding. Default=False") parser.add_argument("-n", "--nod_num", help="Number of nods in the nod cycle, default=8", default=8, type=int) parser.add_argument("-c", "--combination", help="Nod combination method, default=all means do all three.", default="all", choices=["all", "optimal", "non-opt", "mix"]) parser.add_argument("-u", "--unnorm", help="Combine the un-normalized nods.", action="store_true") parser.add_argument("--snr", help="Show snr of continuum.", action="store_true") parser.add_argument("-p", "--plot", help="Show the plots.", action="store_true") parser.add_argument("--output_verify", help="Fits file verification mode", default="fix+warn") parser.add_argument("-r", "--overwrite", help="Overwrite output file if already exists", action="store_true") args = parser.parse_args() return args
3edcefc24898d15fd67925729590710a4f0d1fb5
5,255
import inspect def get_arguments(func): """Returns list of arguments this function has.""" if hasattr(func, '__code__'): # Regular function. return inspect.getargspec(func).args elif hasattr(func, '__call__'): # Callable object. print(func) return _get_arguments(func.__call__) elif hasattr(func, 'func'): # Partial function. return _get_arguments(func.func)
f93133f20c819c590c30e25b6c339c07732daebe
5,256
def _check(isamAppliance, name): """ Check if suffix exists """ ret_obj = get(isamAppliance) check_value, warnings = False, ret_obj['warnings'] if warnings == []: for suffix in ret_obj['data']: if suffix['name'] == name: logger.info("Suffix found in embedded ldap: " + name) check_value = True return check_value, suffix['id'], warnings logger.info("Suffix *not* found in embedded ldap: " + name) return check_value, None, warnings
be2a6226ebdccb92ec3361df79e50165a22d6981
5,257
def check_listening_address(address: str) -> bool: """Check entered ip address for validity.""" if address == 'localhost': return True return address in get_local_addresses()
eaa5cecfee4e8be2947150a537213f4159ee6baf
5,258
import base64 def multibase_b64decode(data): """ Follow forge's base64 urlsafe encode convention to decode string Args: data(string): encoded string Returns: bytes Examples: >>> multibase_b64decode('aGVsbG8') b'hello' """ if isinstance(data, str): data = data.encode() return base64.urlsafe_b64decode( (data + b'=' * (-len(data) % 4)))
fdbc0f937e33d7994737a3a515973598cac3debd
5,259
from typing import List def parse_ordering_params(param: List[str]) -> List[str]: """ Ignores the request to sort by "ord". Returns a sorting order based on the params and includes "readable_id" sorting in passed params if the sorting request contains title otherwise, it returns the requested order. """ if "ord" in param: order = [] elif "title" in param: prefix = "-" if param[0] == "-" else "" order = ["{prefix}coursepage__course__readable_id".format(prefix=prefix), param] else: order = [param] return order
a6a5f4665515a292ad2367945a6b8407000d656a
5,260
def file_senzing_rabbitmq(): """#!/usr/bin/env bash # --- Functions --------------------------------------------------------------- function up { echo -ne "\033[2K${CONTAINER_NAME} status: starting...\r" mkdir -p ${RABBITMQ_DIR} chmod 777 ${RABBITMQ_DIR} if [ "${CONTAINER_VERSION}" == "latest" ] then ${SENZING_SUDO} docker pull ${SENZING_DOCKER_REGISTRY_URL}/bitnami/rabbitmq:${CONTAINER_VERSION} >> ${CONTAINER_LOG} 2>&1 fi ${SENZING_SUDO} docker run \\ --detach \\ --env RABBITMQ_PASSWORD=${SENZING_RABBITMQ_PASSWORD} \\ --env RABBITMQ_USERNAME=${SENZING_RABBITMQ_USERNAME} \\ --interactive \\ --name ${CONTAINER_NAME} \\ --publish ${CONTAINER_PORT}:15672 \\ --publish ${SENZING_DOCKER_PORT_RABBITMQ}:5672 \\ --restart always \\ --tty \\ --volume ${RABBITMQ_DIR}:/bitnami \\ ${SENZING_DOCKER_RUN_PARAMETERS_GLOBAL} \\ ${SENZING_DOCKER_RUN_PARAMETERS_RABBITMQ} \\ ${SENZING_NETWORK_PARAMETER} \\ ${SENZING_PRIVILEGED_PARAMETER} \\ bitnami/rabbitmq:${CONTAINER_VERSION} \\ >> ${CONTAINER_LOG} 2>&1 COUNTER=0 COUNTER_NOTICE=5 TIME_STRING=".." CONTAINER_STATUS="$( docker container inspect -f '{{.State.Status}}' ${CONTAINER_NAME})" while [ "${CONTAINER_STATUS}" != "running" ]; do COUNTER=$((${COUNTER}+1)) if [ "${COUNTER}" -eq "${COUNTER_NOTICE}" ]; then echo -ne "\033[2K" echo "" echo "To see what is happening behind-the-scenes, view the log at" echo "${CONTAINER_LOG}" echo "and/or run 'docker logs ${CONTAINER_NAME}'" echo "" fi TIME_STRING="${TIME_STRING}." echo -ne "\033[2K${CONTAINER_NAME} status: ${CONTAINER_STATUS}${TIME_STRING}\r" sleep 5 CONTAINER_STATUS="$( docker container inspect -f '{{.State.Status}}' ${CONTAINER_NAME})" done sleep 10 echo "${SENZING_HORIZONTAL_RULE}" echo "${SENZING_HORIZONTAL_RULE:0:2} ${CONTAINER_NAME} running on http://${SENZING_DOCKER_HOST_IP_ADDR}:${CONTAINER_PORT}" echo "${SENZING_HORIZONTAL_RULE:0:2} Username: ${SENZING_RABBITMQ_USERNAME} Password: ${SENZING_RABBITMQ_PASSWORD}" echo "${SENZING_HORIZONTAL_RULE:0:2} Mount information: (Format: in container > on host)" echo "${SENZING_HORIZONTAL_RULE:0:2} /bitnami > ${RABBITMQ_DIR}" echo "${SENZING_HORIZONTAL_RULE:0:2} Logs:" echo "${SENZING_HORIZONTAL_RULE:0:2} ${CONTAINER_LOG}" echo "${SENZING_HORIZONTAL_RULE:0:2} and/or run 'docker logs ${CONTAINER_NAME}'" echo "${SENZING_HORIZONTAL_RULE:0:2} For more information:" echo "${SENZING_HORIZONTAL_RULE:0:2} ${SENZING_REFERENCE_URL}#senzing-rabbitmq" echo "${SENZING_HORIZONTAL_RULE}" } function down { ${SENZING_SUDO} docker stop ${CONTAINER_NAME} >> ${CONTAINER_LOG} 2>&1 ${SENZING_SUDO} docker rm ${CONTAINER_NAME} >> ${CONTAINER_LOG} 2>&1 } function usage { echo "usage: $0 [up | down | restart]" echo "For more information:" echo "${SENZING_REFERENCE_URL}#senzing-rabbitmq" } # --- Main -------------------------------------------------------------------- SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" >/dev/null 2>&1 && pwd )" source ${SCRIPT_DIR}/docker-environment-vars.sh CONTAINER_LOG="${SENZING_LOG_RABBITMQ}" CONTAINER_NAME="${SENZING_DOCKER_CONTAINER_NAME_RABBITMQ}" CONTAINER_PORT="${SENZING_DOCKER_PORT_RABBITMQ_UI}" CONTAINER_VERSION="${SENZING_DOCKER_IMAGE_VERSION_RABBITMQ}" if [ "$1" == "up" ]; then up elif [ "$1" == "down" ]; then down elif [ "$1" == "restart" ]; then down up else usage fi """ return 0
95396425074096d17561b20cd197e77f1d550476
5,261
def mse(predictions, targets): """Calculate MSE: (Mean squared error) """ return ((predictions - targets) ** 2).mean()
79d87a3422d4d24201cae86ee861614c83f6770f
5,262
def export1d(hist): """Export a 1-dimensional `Hist` object to uproot This allows one to write a coffea histogram into a ROOT file, via uproot. Parameters ---------- hist : Hist A 1-dimensional histogram object Returns ------- out A ``uproot_methods.classes.TH1`` object Examples -------- Creating a coffea histogram, filling, and writing to a file:: import coffea, uproot, numpy h = coffea.hist.Hist("Events", coffea.hist.Bin("var", "some variable", 20, 0, 1)) h.fill(var=numpy.random.normal(size=100)) fout = uproot.create('output.root') fout['myhist'] = coffea.hist.export1d(h) fout.close() """ if hist.dense_dim() != 1: raise ValueError("export1d() can only support one dense dimension") if hist.sparse_dim() != 0: raise ValueError("export1d() expects zero sparse dimensions") axis = hist.axes()[0] sumw, sumw2 = hist.values(sumw2=True, overflow='all')[()] edges = axis.edges(overflow='none') out = TH1.__new__(TH1) out._fXaxis = TAxis(len(edges) - 1, edges[0], edges[-1]) out._fXaxis._fName = axis.name out._fXaxis._fTitle = axis.label if not axis._uniform: out._fXaxis._fXbins = edges.astype(">f8") centers = (edges[:-1] + edges[1:]) / 2.0 out._fEntries = out._fTsumw = out._fTsumw2 = sumw[1:-1].sum() out._fTsumwx = (sumw[1:-1] * centers).sum() out._fTsumwx2 = (sumw[1:-1] * centers**2).sum() out._fName = "histogram" out._fTitle = hist.label out._classname = b"TH1D" out.extend(sumw.astype(">f8")) out._fSumw2 = sumw2.astype(">f8") return out
ffe09495a268c68d26f9861e6d732649f2f74497
5,263
def filter_words(w_map, emb_array, ck_filenames): """ delete word in w_map but not in the current corpus """ vocab = set() for filename in ck_filenames: for line in open(filename, 'r'): if not (line.isspace() or (len(line) > 10 and line[0:10] == '-DOCSTART-')): line = line.rstrip('\n').split() assert len(line) >= 3, 'wrong ck file format' word = line[0] vocab.add(word) word = word.lower() vocab.add(word) new_w_map = {} new_emb_array = [] for (word, idx) in w_map.items(): if word in vocab or word in ['<unk>', '<s>', '< >', '<\n>']: assert word not in new_w_map new_w_map[word] = len(new_emb_array) new_emb_array.append(emb_array[idx]) print('filtered %d --> %d' % (len(emb_array), len(new_emb_array))) return new_w_map, new_emb_array
efdef92093acf25c992dba86da25a4118ba728ec
5,264
def get_cache_template(sources, grids, geopackage, table_name="tiles"): """ Returns the cache template which is "controlled" settings for the application. The intent is to allow the user to configure certain things but impose specific behavior. :param sources: A name for the source :param grids: specific grid for the data source :param geopackage: Location for the geopackage :return: The dict template """ if sources == ["None"]: sources = [] return { "sources": sources, "cache": {"type": "geopackage", "filename": str(geopackage), "table_name": table_name}, "grids": [grid for grid in grids if grid == "default"] or grids, "format": "mixed", "request_format": "image/png", }
dc83a155d28e0b39f12a7dc7142b61a4bf27512b
5,265
from datetime import datetime def plotter(fdict): """ Go """ pgconn = get_dbconn('coop') ccursor = pgconn.cursor(cursor_factory=psycopg2.extras.DictCursor) ctx = get_autoplot_context(fdict, get_description()) station = ctx['station'] lagmonths = ctx['lag'] months = ctx['months'] month = ctx['month'] highyears = [int(x) for x in ctx['year'].split(",")] h = ctx['h'] wantmonth = month + lagmonths yearoffset = 0 if month + lagmonths < 1: wantmonth = 12 - (month + lagmonths) yearoffset = 1 wanted = [] deltas = [] for m in range(month, month+months): if m < 13: wanted.append(m) deltas.append(0) else: wanted.append(m-12) deltas.append(-1) table = "alldata_%s" % (station[:2],) nt = network.Table("%sCLIMATE" % (station[:2],)) elnino = {} ccursor.execute("""SELECT monthdate, soi_3m, anom_34 from elnino""") for row in ccursor: if row[0].month != wantmonth: continue elnino[row[0].year + yearoffset] = dict(soi_3m=row[1], anom_34=row[2]) ccursor.execute(""" SELECT year, month, sum(precip), avg((high+low)/2.) from """ + table + """ where station = %s GROUP by year, month """, (station, )) yearly = {} for row in ccursor: (_year, _month, _precip, _temp) = row if _month not in wanted: continue effectiveyear = _year + deltas[wanted.index(_month)] nino = elnino.get(effectiveyear, {}).get('soi_3m', None) if nino is None: continue data = yearly.setdefault(effectiveyear, dict(precip=0, temp=[], nino=nino)) data['precip'] += _precip data['temp'].append(float(_temp)) fig = plt.figure(figsize=(10, 6)) ax = plt.axes([0.1, 0.12, 0.5, 0.75]) msg = ("[%s] %s\n%s\n%s SOI (3 month average)" ) % (station, nt.sts[station]['name'], title(wanted), datetime.date(2000, wantmonth, 1).strftime("%B")) ax.set_title(msg) cmap = plt.get_cmap("RdYlGn") zdata = np.arange(-2.0, 2.1, 0.5) norm = mpcolors.BoundaryNorm(zdata, cmap.N) rows = [] xs = [] ys = [] for year in yearly: x = yearly[year]['precip'] y = np.average(yearly[year]['temp']) xs.append(x) ys.append(y) val = yearly[year]['nino'] c = cmap(norm([val])[0]) if h == 'hide' and val > -0.5 and val < 0.5: ax.scatter(x, y, facecolor='#EEEEEE', edgecolor='#EEEEEE', s=30, zorder=2, marker='s') else: ax.scatter(x, y, facecolor=c, edgecolor='k', s=60, zorder=3, marker='o') if year in highyears: ax.text(x, y + 0.2, "%s" % (year, ), ha='center', va='bottom', zorder=5) rows.append(dict(year=year, precip=x, tmpf=y, soi3m=val)) ax.axhline(np.average(ys), lw=2, color='k', linestyle='-.', zorder=2) ax.axvline(np.average(xs), lw=2, color='k', linestyle='-.', zorder=2) sm = plt.cm.ScalarMappable(norm, cmap) sm.set_array(zdata) cb = plt.colorbar(sm, extend='both') cb.set_label("<-- El Nino :: SOI :: La Nina -->") ax.grid(True) ax.set_xlim(left=-0.01) ax.set_xlabel("Total Precipitation [inch], Avg: %.2f" % (np.average(xs),)) ax.set_ylabel((r"Average Temperature $^\circ$F, " "Avg: %.1f") % (np.average(ys), )) df = pd.DataFrame(rows) ax2 = plt.axes([0.67, 0.6, 0.28, 0.35]) ax2.scatter(df['soi3m'].values, df['tmpf'].values) ax2.set_xlabel("<-- El Nino :: SOI :: La Nina -->") ax2.set_ylabel(r"Avg Temp $^\circ$F") slp, intercept, r_value, _, _ = stats.linregress(df['soi3m'].values, df['tmpf'].values) y1 = -2.0 * slp + intercept y2 = 2.0 * slp + intercept ax2.plot([-2, 2], [y1, y2]) ax2.text(0.97, 0.9, "R$^2$=%.2f" % (r_value**2, ), ha='right', transform=ax2.transAxes, bbox=dict(color='white')) ax2.grid(True) ax3 = plt.axes([0.67, 0.1, 0.28, 0.35]) ax3.scatter(df['soi3m'].values, df['precip'].values) ax3.set_xlabel("<-- El Nino :: SOI :: La Nina -->") ax3.set_ylabel("Total Precip [inch]") slp, intercept, r_value, _, _ = stats.linregress(df['soi3m'].values, df['precip'].values) y1 = -2.0 * slp + intercept y2 = 2.0 * slp + intercept ax3.plot([-2, 2], [y1, y2]) ax3.text(0.97, 0.9, "R$^2$=%.2f" % (r_value**2, ), ha='right', transform=ax3.transAxes, bbox=dict(color='white')) ax3.grid(True) return fig, df
0f41a53336f2bf65805adaf83a8f3f17c006e161
5,266
def _action_spec(): """Returns the action spec.""" paddle_action_spec = dm_env_rpc_pb2.TensorSpec( dtype=dm_env_rpc_pb2.INT8, name=_ACTION_PADDLE) tensor_spec_utils.set_bounds( paddle_action_spec, minimum=np.min(_VALID_ACTIONS), maximum=np.max(_VALID_ACTIONS)) return {1: paddle_action_spec}
130b7b2fe9f56d925d4ec1206eb3fb2752fee716
5,267
def stdin(sys_stdin): """ Imports standard input. """ inputs = [x.strip("[]\n") for x in sys_stdin] a = [int(x) for x in inputs[0].split(",")] x = int(inputs[1][0]) return a, x
4c34e1bc80da31c6c7aff0d71a0c65f6fc01ed00
5,268
def _row_key(row): """ :param row: a normalized row from STATEMENT_METRICS_QUERY :return: a tuple uniquely identifying this row """ return row['database_name'], row['user_name'], row['query_signature'], row['query_hash'], row['query_plan_hash']
2984e0e0b5fcc4e51a26af188e51fe65c52077a2
5,269
from io import StringIO def get (url, user_agent=UA, referrer=None): """Make a GET request of the url using pycurl and return the data (which is None if unsuccessful)""" data = None databuffer = StringIO() curl = pycurl.Curl() curl.setopt(pycurl.URL, url) curl.setopt(pycurl.FOLLOWLOCATION, 1) curl.setopt(pycurl.CONNECTTIMEOUT, 5) curl.setopt(pycurl.TIMEOUT, 8) curl.setopt(pycurl.WRITEFUNCTION, databuffer.write) curl.setopt(pycurl.COOKIEFILE, '') if user_agent: curl.setopt(pycurl.USERAGENT, user_agent) if referrer is not None: curl.setopt(pycurl.REFERER, referrer) try: curl.perform() data = databuffer.getvalue() except Exception: pass curl.close() return data
e18de239a598be249d81c2a15486a66af763bc85
5,270
def detect_callec(tree): """Collect names of escape continuations from call_ec invocations in tree. Currently supported and unsupported cases:: # use as decorator, supported @call_ec def result(ec): # <-- we grab name "ec" from here ... # use directly on a literal lambda, supported result = call_ec(lambda ec: ...) # <-- we grab name "ec" from here # use as a function, **NOT supported** def g(ec): # <-- should grab from here ... ... result = call_ec(g) # <-- but this is here; g could be in another module """ # literal function names that are always interpreted as an ec. # "brk" is needed to combo with unpythonic.fploop.breakably_looped. fallbacks = ["ec", "brk"] iscallec = partial(isx, make_isxpred("call_ec")) @Walker def detect(tree, *, collect, **kw): # TODO: add support for general use of call_ec as a function (difficult) if type(tree) in (FunctionDef, AsyncFunctionDef) and any(iscallec(deco) for deco in tree.decorator_list): fdef = tree collect(fdef.args.args[0].arg) # FunctionDef.arguments.(list of arg objects).arg elif is_decorated_lambda(tree, mode="any"): decorator_list, thelambda = destructure_decorated_lambda(tree) if any(iscallec(decocall.func) for decocall in decorator_list): collect(thelambda.args.args[0].arg) # we assume it's the first arg, as that's what call_ec expects. return tree return fallbacks + detect.collect(tree)
1980c2abd9d5b995a47eab381eb595eb71ced595
5,271
from typing import List from typing import Tuple from typing import Any def apply_filters( stream: StreamMeta, filters: List[Tuple[str, str]], config: Any ) -> StreamMeta: """Apply enabled filters ordered by priority on item""" filter_pool = get_filter_pool(filters, config) for filter_instance in filter( lambda x: x.enabled, sorted(filter_pool, key=lambda x: x.priority) ): filter_instance.apply(stream) return stream
2ff50b5d31e84ba69afe694b4beb4116dbc5fc55
5,272
def threading_d(func): """ A decorator to run function in background on thread Args: func:``function`` Function with args Return: background_thread: ``Thread`` """ @wraps(func) def wrapper(*args, **kwags): background_thread = Thread(target=func, args=(*args,)) background_thread.daemon = True background_thread.start() return background_thread return wrapper
ff4d86ded189737d68d4cdc98c0e9ba9f1a28664
5,273
def create_anchors_3d_stride( feature_size, sizes=[1.6, 3.9, 1.56], anchor_strides=[0.4, 0.4, 0.0], anchor_offsets=[0.2, -39.8, -1.78], rotations=[0, np.pi / 2], velocities=[], dtype=np.float32, ): """ Args: feature_size: list [D, H, W](zyx) sizes: [N, 3] list of list or array, size of anchors, xyz Returns: anchors: [*feature_size, num_sizes, num_rots, 7] tensor. """ # almost 2x faster than v1 x_stride, y_stride, z_stride = anchor_strides x_offset, y_offset, z_offset = anchor_offsets z_centers = np.arange(feature_size[0], dtype=dtype) y_centers = np.arange(feature_size[1], dtype=dtype) x_centers = np.arange(feature_size[2], dtype=dtype) z_centers = z_centers * z_stride + z_offset y_centers = y_centers * y_stride + y_offset x_centers = x_centers * x_stride + x_offset sizes = np.reshape(np.array(sizes, dtype=dtype), [-1, 3]) rotations = np.array(rotations, dtype=dtype) velocities = np.array(velocities, dtype=dtype).reshape([-1, 2]) combines = np.hstack([sizes, velocities]).reshape([-1, 5]) rets = np.meshgrid(x_centers, y_centers, z_centers, rotations, indexing="ij") tile_shape = [1] * 5 tile_shape[-2] = int(sizes.shape[0]) for i in range(len(rets)): rets[i] = np.tile(rets[i][..., np.newaxis, :], tile_shape) rets[i] = rets[i][..., np.newaxis] # for concat # sizes = np.reshape(sizes, [1, 1, 1, -1, 1, 3]) combines = np.reshape(combines, [1, 1, 1, -1, 1, 5]) tile_size_shape = list(rets[0].shape) tile_size_shape[3] = 1 # sizes = np.tile(sizes, tile_size_shape) combines = np.tile(combines, tile_size_shape) # rets.insert(3, sizes) rets.insert(3, combines) ret = np.concatenate(rets, axis=-1) return np.transpose(ret, [2, 1, 0, 3, 4, 5])
6834d20f44196f5dad19d1917a673196334adf9f
5,274
import hashlib def sha1_file(filename): """ Return the hex string representation of the SHA1 checksum of the filename """ s = hashlib.sha1() with open(filename, "rb") as f: for line in f: s.update(line) return s.hexdigest()
b993ac9f025d69124962905f87b1968617bb33f5
5,275
def unit_parameters(_bb_spine_db_export: dict, _grid_name: str, _node_name: str, _unit_name: str, _time_index, _alternative='Base', _eff_level=1, _p_unit=False, _node_name_if_output=None, _node_name_if_input=None ): """ :param _bb_spine_db_export: :param _grid_name: :param _node_name: name used to search in _bb_spine_db_export :param _unit_name: :param _time_index: used only for time-variant fuel prices :param _alternative: :param _eff_level: default efficiency level for units without effLevelGroupUnit definition, should be set to the highest level in practice :param _p_unit: default Fault, True to enable parsing unit specific values from p_unit :param _node_name_if_output: str, set a new name for the sought node (_node_name) if the unit outputs to it :param _node_name_if_input: str, set a new name for the sought node (_node_name) if the unit receives its input :return: """ _temp_importer = SpineDBImporter() # Parameters 1: from BB_gdx p_gnu_io (SpineDB grid__node__unit__io) _parameters_1 = [ x for x in _bb_spine_db_export['relationship_parameter_values'] if all([x[0] == 'grid__node__unit__io', x[1][:3] == [_grid_name, _node_name, _unit_name]]) ] _fuel_commodity = [ x[1][0] for x in _bb_spine_db_export['relationships'] if x[0] == 'commodity' ] _unit_capacity = 0 # Parameters 2: from BB_gdx effLevelGroupUnit (SpineDB efflevel__group__unit) # unit_online_type _parameters_2 = [ x for x in _bb_spine_db_export['relationships'] if all([x[0] == 'efflevel__group__unit', _unit_name in x[1]]) ] # Parameters 3: from BB_gdx p_unit (SpineDB unit) _parameters_3 = [ x for x in _bb_spine_db_export['object_parameter_values'] if all([x[0] == 'unit', x[1] == _unit_name]) ] # Translate Parameter 1 # TODO: other bb parameter under the category p_gnu_io, unitSize for investment for par in _parameters_1: if par[1][3] == 'output': if _node_name_if_output: _node_name = _node_name_if_output # add unit__to_node relationship for output _temp_importer.relationships.append(("unit__to_node", (_unit_name, _node_name))) if par[2] == 'capacity': # capacity is aggregated in Backbone but SpineOpt requires unit capacity _number_of_units = __get_number_of_units(_bb_spine_db_export, _unit_name, default=1) _unit_capacity = par[3] / _number_of_units[0] _temp_importer.relationship_parameter_values += [ ("unit__to_node", [_unit_name, _node_name], "unit_capacity", _unit_capacity, _alternative), ] elif par[2] == 'conversionCoeff': _temp_importer.relationship_parameter_values += [ ("unit__to_node", [_unit_name, _node_name], "unit_conv_cap_to_flow", par[3], _alternative), ] elif par[2] == 'vomCosts': _temp_importer.relationship_parameter_values += [ ("unit__to_node", [_unit_name, _node_name], "vom_cost", par[3], _alternative), ] elif par[1][3] == 'input': if _node_name_if_input: _node_name = _node_name_if_input # add unit__from_node relationship for input _temp_importer.relationships.append(("unit__from_node", (_unit_name, _node_name))) # build parameters if par[2] == 'capacity': # capacity is aggregated in Backbone but SpineOpt requires unit capacity _number_of_units = __get_number_of_units(_bb_spine_db_export, _unit_name, default=1) _unit_capacity = par[3] / _number_of_units[0] _temp_importer.relationship_parameter_values += [ ("unit__from_node", [_unit_name, _node_name], "unit_capacity", _unit_capacity, _alternative), ] elif par[2] == 'conversionCoeff': _temp_importer.relationship_parameter_values += [ ("unit__from_node", [_unit_name, _node_name], "unit_conv_cap_to_flow", par[3], _alternative), ] elif par[2] == 'vomCosts': _temp_importer.relationship_parameter_values += [ ("unit__from_node", [_unit_name, _node_name], "vom_cost", par[3], _alternative), ] # For nodes which are created to supply fuels if _node_name in _fuel_commodity: # add an additional dummy unit to balance the input node that is particularly for fuel source _temp_importer = dummy_unit_for_node( _temp_importer, _node_name, f"Fueling_unit_{_node_name}", "to_node" ) # build fuel price, in either TimeSeries or constant value _fuel_price_dict = __restore_fuel_price_map(_bb_spine_db_export, _node_name, _alternative=_alternative) if len(_fuel_price_dict) != 1: __time_index = [str(x) for x in _time_index] _fuel_price_ts = dict(zip(__time_index, list(_fuel_price_dict.values())[:len(__time_index)])) _temp_importer.relationship_parameter_values += [ ( "unit__from_node", [_unit_name, _node_name], "fuel_cost", {"type": "time_series", "data": _fuel_price_ts, "index": {"repeat": timeseries_repeat}}, _alternative ), ] # constant value else: _fuel_price = list(_fuel_price_dict.values())[0] _temp_importer.relationship_parameter_values += [ ("unit__from_node", [_unit_name, _node_name], "fuel_cost", _fuel_price, _alternative), ] # grid in bb_format translated as commodity in spineopt # node in bb_format translated as node in spineopt # unit in bb_format translated as unit in spineopt _temp_importer.objects += [("commodity", _grid_name), ("node", _node_name), ("unit", _unit_name)] # add node__commodity relationship _temp_importer.relationships.append(("node__commodity", (_node_name, _grid_name))) # Translate Parameters 2 if _parameters_2: # TODO: level?, lambda eff type? _unit_on = _parameters_2['level1' in _parameters_2] if _unit_on[1][1] == 'directOnMIP': _temp_importer.object_parameter_values.append( ("unit", _unit_name, "online_variable_type", "unit_online_variable_type_integer", _alternative), ) elif _unit_on[1][1] == 'directOnLP': _temp_importer.object_parameter_values.append( ("unit", _unit_name, "online_variable_type", "unit_online_variable_type_linear", _alternative), ) elif _unit_on[1][1] == 'directOff': _number_of_units = __get_number_of_units(_bb_spine_db_export, _unit_name, default=1) _temp_importer.object_parameter_values.append( ("unit", _unit_name, "fix_units_on", _number_of_units[0], _alternative), ) # Translate Parameters 3 _operating_points = [0] _min_operating_point = _operating_points[0] # for units with efficiency levels if _parameters_2: _eff_level = len(_parameters_2) _direction = set([x[1][3] for x in _parameters_1]) # TODO: what about the units with _direction containing both input and output? _constraint_name = f"Eff_{_unit_name}" if 'output' in _direction and len(_direction) == 1: if ("unit_constraint", _constraint_name) not in _temp_importer.objects: _temp_importer.objects += [("unit_constraint", _constraint_name), ] # specify constraint settings _temp_importer.object_parameter_values += [ ("unit_constraint", _constraint_name, "constraint_sense", "==", _alternative), ("unit_constraint", _constraint_name, "right_hand_side", 0.0, _alternative), ] _temp_importer.relationships += [ ("unit__unit_constraint", (_unit_name, _constraint_name)), ("unit__to_node__unit_constraint", (_unit_name, _node_name, _constraint_name)), ] # data for units with constant efficiency is stored in the highest effLevel if all(['directOff' in x[1] for x in _parameters_2]): _max_level = max(range(0, _eff_level)) _operating_points = [x[3] for x in _parameters_3 if x[2] == f"op{_max_level:02d}"] # eff = output/input _unit_flow_coefficient = [-(x[3] ** -1) for x in _parameters_3 if x[2] == f"eff{_max_level:02d}"] else: _operating_points = list( map(lambda i: [x[3] for x in _parameters_3 if x[2] == f"op{i:02d}"][0], range(0, _eff_level)) ) # TODO: to be confirmed _min_operating_point = _operating_points[0] # eff = output/input _unit_flow_coefficient = list( map(lambda i: [-(x[3] ** -1) for x in _parameters_3 if x[2] == f"eff{i:02d}"][0], range(0, _eff_level)) ) _temp_importer.relationship_parameter_values += [ ("unit__to_node", (_unit_name, _node_name), "operating_points", {"type": "array", "value_type": "float", "data": _operating_points}, _alternative), ("unit__to_node", (_unit_name, _node_name), "minimum_operating_point", _min_operating_point, _alternative), ("unit__to_node__unit_constraint", (_unit_name, _node_name, _constraint_name), "unit_flow_coefficient", {"type": "array", "value_type": "float", "data": _unit_flow_coefficient}, _alternative) ] elif 'input' in _direction and len(_direction) == 1: if ("unit_constraint", _constraint_name) not in _temp_importer.objects: _temp_importer.objects += [("unit_constraint", _constraint_name), ] # specify constraint settings _temp_importer.object_parameter_values += [ ("unit_constraint", _constraint_name, "constraint_sense", "==", _alternative), ("unit_constraint", _constraint_name, "right_hand_side", 0.0, _alternative), ] _temp_importer.relationships += [ ("unit__unit_constraint", (_unit_name, _constraint_name)), ("unit__from_node__unit_constraint", (_unit_name, _node_name, _constraint_name)), ] _unit_flow_coefficient = [ x[3] for x in _parameters_1 if all([x[2] == "conversionCoeff"]) ][0] _temp_importer.relationship_parameter_values += [ ("unit__from_node__unit_constraint", (_unit_name, _node_name, _constraint_name), "unit_flow_coefficient", _unit_flow_coefficient, _alternative), ] # Whether to parse unit specific values from p_unit if _p_unit: # parameters directly translatable def _rename_unit_para(obj_para_value_entity: tuple, _target_para_name: str, __alternative: str): _para = list(obj_para_value_entity) _para[2] = _target_para_name _para[4] = __alternative return _para for par in _parameters_3: if par[2] == 'availability': _parameter = _rename_unit_para(par, "unit_availability_factor", _alternative) _temp_importer.object_parameter_values.append(tuple(_parameter)) elif par[2] == 'minOperationHours': _parameter = _rename_unit_para(par, "min_up_time", _alternative) _parameter[3] = {"type": "duration", "data": f"{int(_parameter[3])}h"} _temp_importer.object_parameter_values.append(tuple(_parameter)) elif par[2] == 'minShutdownHours': _parameter = _rename_unit_para(par, "min_down_time", _alternative) _parameter[3] = {"type": "duration", "data": f"{int(_parameter[3])}h"} _temp_importer.object_parameter_values.append(tuple(_parameter)) # number of units, 1 is default value defined in SpineOpt database template elif par[2] == 'unitCount': _parameter = _rename_unit_para(par, "number_of_units", _alternative) _temp_importer.object_parameter_values.append(tuple(_parameter)) # EUR/start/unit, start per unit capacity elif par[2] == 'startCostCold': _start_up_cost = par[3] * _unit_capacity _temp_importer.object_parameter_values.append( ("unit", _unit_name, "start_up_cost", _start_up_cost, _alternative) ) elif par[2] == 'startFuelConsCold': # MWh fuel/unit startup _start_up_fuel_consumption = - par[3] * _unit_capacity # Parameters 4: from BB_gdx p_uStartupfuel (SpineDB unit__startupFuel) _parameters_4 = [ x for x in _bb_spine_db_export['relationship_parameter_values'] if all([x[0] == 'unit__startupFuel', _unit_name in x[1]]) ] if _parameters_4: # the corresponding fuel node for te startup fuel _start_up_fuel = _parameters_4[0][1][1] # explicit startup fuel node for clarity _startup_fuel_node = f"{_start_up_fuel}_for_unit_startup" # _startup_fuel_node links to the same fueling unit as the fuel node if ("node", _startup_fuel_node) not in _temp_importer.objects: _temp_importer.objects.append(("node", _startup_fuel_node)) _temp_importer = dummy_unit_for_node( _temp_importer, _startup_fuel_node, f"Fueling_unit_{_start_up_fuel}", "to_node" ) # add commodity for the fuel node if there is any # _startup_fuel_node shares the same commodity with the fuel node _grid_for_fuel_commodity = [ x[1][0] for x in _bb_spine_db_export['relationships'] if all([x[0] == 'grid__node', _start_up_fuel in x[1]]) ] if _grid_for_fuel_commodity: _fuel_commodity = _grid_for_fuel_commodity[0] if ("commodity", _fuel_commodity) not in _temp_importer.objects: _temp_importer.objects.append(("commodity", _fuel_commodity)) _temp_importer.relationships += [ ("node__commodity", (_startup_fuel_node, _fuel_commodity)), ] else: print(f"The corresponding grid for fuel node {_start_up_fuel} is missing.") # build unit_constraint for startup fuel flow _constraint_name = f"Startup_fuel_{_unit_name}" _temp_importer.objects += [ ("unit_constraint", _constraint_name), ] _temp_importer.relationships += [ ("unit__from_node", (_unit_name, _startup_fuel_node)), ("unit__unit_constraint", (_unit_name, _constraint_name)), ("unit__from_node__unit_constraint", (_unit_name, _startup_fuel_node, _constraint_name)), ] _temp_importer.object_parameter_values += [ ("unit_constraint", _constraint_name, "constraint_sense", "==", _alternative), ("unit_constraint", _constraint_name, "right_hand_side", 0.0, _alternative), ] _temp_importer.relationship_parameter_values += [ ("unit__unit_constraint", (_unit_name, _constraint_name), "units_started_up_coefficient", _start_up_fuel_consumption, _alternative), ("unit__from_node__unit_constraint", (_unit_name, _startup_fuel_node, _constraint_name), "unit_flow_coefficient", 1.0, _alternative), ] # build fuel price, in either TimeSeries or constant value, if there is any _fuel_price_dict = __restore_fuel_price_map( _bb_spine_db_export, _start_up_fuel, _alternative=_alternative ) if len(_fuel_price_dict) != 1: __time_index = [str(x) for x in _time_index] _fuel_price_ts = dict( zip(__time_index, list(_fuel_price_dict.values())[:len(__time_index)])) _temp_importer.relationship_parameter_values += [ ("unit__from_node", [_unit_name, _startup_fuel_node], "fuel_cost", {"type": "time_series", "data": _fuel_price_ts, "index": {"repeat": timeseries_repeat}}, _alternative), ] # constant value else: _fuel_price = list(_fuel_price_dict.values())[0] _temp_importer.relationship_parameter_values += [ ("unit__from_node", [_unit_name, _startup_fuel_node], "fuel_cost", _fuel_price, _alternative), ] # set default number_of_units and unit_availability_factor to 1.0 if not explicitly recorded in the database # else: # _temp_importer.object_parameter_values += [ # ("unit", _unit_name, "unit_availability_factor", 1.0, _alternative), # ("unit", _unit_name, "number_of_units", 1.0, _alternative), # ] return _temp_importer
698770193d23c8decb240132c462860cd59ef77b
5,276
def read_from_file(file_path): """ Read a file and return a list with all the lines in the file """ file_in_list = [] with open(file_path, 'r') as f: for line in f.readlines(): file_in_list.append(line) return file_in_list
5fef3a3f50528c1a9786451666ae7e43be282bf9
5,277
def count(predicate, iterable): """ Iterate over iterable, pass the value to the predicate predicate and return the number of times the predicate returns value considered True. @param predicate: Predicate function. @param iterable: Iterable containing the elements to count. @return: The number of true element. """ result = 0L for i in iterable: if predicate(i): result += 1 return result
1a2d9a05203f32a6f1a8349b6e31d14cb1b82b71
5,278
def get_object_from_path(path): """ :param path: dot seperated path. Assumes last item is the object and first part is module path(str) - example: cls = get_object_from_path("a.module.somewhere.MyClass") you can create a path like this: class_path = "{0}.{1}".format(MyClass.__module__, MyClass.__name__) """ module_path, _, obj_name = path.rpartition(".") module = __import__(module_path, globals(), locals(), [obj_name], -1) obj = getattr(module, obj_name, None) return obj
e722b040486288d53fe4a357d81ddec8dfc9820e
5,279
def _get_collection_memcache_key(collection_id, version=None): """Returns a memcache key for the collection. Args: collection_id: str. ID of the collection. version: int. Schema version of the collection. Returns: str. The memcache key of the collection. """ if version: return 'collection-version:%s:%s' % (collection_id, version) else: return 'collection:%s' % collection_id
cc054d726d1d2642701803a816e214eed4d9663d
5,280
def biKmeans(dataSet, k, distMeas=calcEuclideanDistance): """ 二分K-均值算法 :param dataSet: :param k: :param distMeas: :return: """ m = np.shape(dataSet)[0] clusterAssment = np.mat(np.zeros((m, 2))) centroid0 = np.mean(dataSet, axis=0).tolist()[0] centList = [centroid0] # create a list with one centroid for j in range(m): # calc initial Error clusterAssment[j, 1] = distMeas(np.mat(centroid0), dataSet[j, :]) ** 2 while len(centList) < k: lowestSSE = np.inf for i in range(len(centList)): # get the data points currently in cluster i ptsInCurrCluster = dataSet[np.nonzero(clusterAssment[:, 0].A == i)[0], :] centroidMat, splitClustAss = kMeans(ptsInCurrCluster, 2, distMeas) sseSplit = sum(splitClustAss[:, 1]) # compare the SSE to the currrent minimum sseNotSplit = sum(clusterAssment[np.nonzero(clusterAssment[:, 0].A != i)[0], 1]) print "sseSplit, and notSplit: ", sseSplit, sseNotSplit if (sseSplit + sseNotSplit) < lowestSSE: bestCentToSplit = i bestNewCents = centroidMat bestClustAss = splitClustAss.copy() lowestSSE = sseSplit + sseNotSplit bestClustAss[np.nonzero(bestClustAss[:, 0].A == 1)[0], 0] = len(centList) # change 1 to 3,4, or whatever bestClustAss[np.nonzero(bestClustAss[:, 0].A == 0)[0], 0] = bestCentToSplit print 'the bestCentToSplit is: ', bestCentToSplit print 'the len of bestClustAss is: ', len(bestClustAss) centList[bestCentToSplit] = bestNewCents[0, :].tolist()[0] # replace a centroid with two best centroids centList.append(bestNewCents[1, :].tolist()[0]) # reassign new clusters, and SSE clusterAssment[np.nonzero(clusterAssment[:, 0].A == bestCentToSplit)[0], :] = bestClustAss return np.mat(centList), clusterAssment
1421dfa95c44e046bd7d729ad343e98eb83bbbcd
5,281
import glob import os import logging def get(directory): """Prepare df and gdf with solar atlas tiled data.""" files_list = glob.glob(os.path.join(directory, "*", "*.csv")) data = [] for file in files_list: logging.info(file) tiles = pd.read_csv(file, header=None) tiles.columns = ["tilename", "minx", "maxx", "miny", "maxy"] tiles["extentBox"] = tiles.apply( lambda x: box(x.minx, x.miny, x.maxx, x.maxy), axis=1 ) tiles["tilename"] = ( os.path.basename(os.path.dirname(file)) + "/" + tiles["tilename"] ) tiles["start_at"] = pd.to_datetime( "2099-" + os.path.dirname(file).split("_")[1], format="%Y-%m" ) data.append(tiles) data = pd.concat(data, ignore_index=True) enermaps_data = utilities.ENERMAPS_DF enermaps_data["fid"] = data["tilename"] enermaps_data["start_at"] = data["start_at"] enermaps_data["variable"] = VARIABLE enermaps_data["unit"] = UNIT enermaps_data["israster"] = ISRASTER enermaps_data["dt"] = DT spatial = gpd.GeoDataFrame(geometry=data["extentBox"], crs="EPSG:3035",) spatial["fid"] = data["tilename"] return enermaps_data, spatial
69a32931930ffc5793f84faa09c3aa4b09688b42
5,282
def cleanup(args, repo): """Clean up undeployed pods.""" if args.keep < 0: raise ValueError('negative keep: %d' % args.keep) def _is_enabled_or_started(pod): for instance in pod.iter_instances(): if scripts.systemctl_is_enabled(instance.unit_name): return True if scripts.systemctl_is_active(instance.unit_name): return True return False for pod_dir_name in repo.get_pod_dir_names(): LOG.info('%s - cleanup', pod_dir_name) all_pods = list(repo.iter_pods(pod_dir_name)) num_left = len(all_pods) for pod in all_pods: if num_left <= args.keep: break if _is_enabled_or_started(pod): LOG.info('refuse to undeploy pod: %s', pod) continue _undeploy_pod(repo, pod) num_left -= 1 return 0
b015c1dbfeb3ad50218afaadfe198123ff2ab6df
5,283
from typing import Dict def optimizer_builder( config: Dict): """ Instantiate an optimizer. :param config: :return: """ # --- argument checking if not isinstance(config, dict): raise ValueError("config must be a dictionary") # --- read configuration decay_rate = config["decay_rate"] decay_steps = config["decay_steps"] learning_rate = config["learning_rate"] gradient_clipping_by_norm = config["gradient_clipping_by_norm"] # --- set up schedule lr_schedule = \ keras.optimizers.schedules.ExponentialDecay( initial_learning_rate=learning_rate, decay_steps=decay_steps, decay_rate=decay_rate) return \ keras.optimizers.RMSprop( learning_rate=lr_schedule, global_clipnorm=gradient_clipping_by_norm),\ lr_schedule
2194408d74d4f03bc54371b98b12c8dbe85fb585
5,284
def psi(z: float, a: float, b: float) -> float: """Penalty function with uniformly bounded derivative (Eq. 20) Args: z: Relative distance a: Cohesion strength b: Separation strength """ c = np.abs(a - b) / (2 * np.sqrt(a * b)) return ((a + b) / 2) * (np.sqrt(1 + (z + c) ** 2) - np.sqrt(1 + c ** 2)) + ((a - b) / 2) * z
df88e57d80a32d95367f30ce52af84308349387a
5,285
def caselessSort(alist): """Return a sorted copy of a list. If there are only strings in the list, it will not consider case. """ try: return sorted(alist, key=lambda a: (a.lower(), a)) except TypeError: return sorted(alist)
7558a57e28255817c71846da84230ced49553bb6
5,286
def EnableRing(serialPort): """ Enable the ISU to listen for SBD Ring Alerts. When SBD Ring Alert indication is enabled, the 9602 asserts the RI line and issues the unsolicited result code SBDRING when an SBD Ring Alert is received. """ # Enables Ring message to indicate there's a message to read. Log("EnableRing()") if not WriteAndCheck(serialPort, "AT+SBDMTA=1\r", "OK", 30): Log("Issue enabling ring notifications.") return False Log("OK.") return True
7036610523802f659c7a69ae192f1009401a6ac3
5,287
def render(template, **context): """Render the given template. :param template: The template file name or string to render. :param **context: Context keyword-arguments. """ class Undefined(BaseUndefined): def _fail_with_undefined_error(self, *args, **kwargs): try: super(Undefined, self)._fail_with_undefined_error(*args, **kwargs) except Exception, error: return "{{{{ {0} }}}}".format(error) try: try: template_file = file(expanduser(template)) loader = FileSystemLoader(dirname(template_file.name)) environment = Environment(loader=loader, undefined=Undefined) try: template = environment.get_template(basename( template_file.name)) except TemplateSyntaxError, error: message = "Template {0}:{1}, {2}{3}".format(error.filename, error.lineno, error.message[:1].lower(), error.message[1:]) exit(message) except IOError: try: template = Template(template, undefined=Undefined) except TemplateSyntaxError, error: message = "Template \"{0}\" {1}{2}".format(template, error.message[:1].lower(), error.message[1:]) exit(message) except TemplateError, error: message = "Template error: {0}".format(error.message) exit(message) return template.render(context)
6680f163e1b89424e88b1a3046784083cdbb6520
5,288
import re from io import StringIO import os import json def read(pth, format=None, encoding=None, cols=None, **kwargs): """Returns the contents of a file into a string or format-dependent data type (with special handling for json and csv files). The format will either be inferred from the file extension or can be set explicitly using the `format` arg. Text will be read using the specified `encoding` or default to UTF-8. JSON files will be parsed and an appropriate python type will be selected based on the top-level object defined in the file. The optional keyword argument `dict` can be set to `adict` or `odict` if you'd prefer not to use the standard python dictionary for decoded objects. CSV files will return a list of rows. By default each row will be an ordered list of column values. If the first line of the file defines column names, you can call read() with cols=True in which case each row will be a namedtuple using those names as keys. If the file doesn't define its own column names, you can pass a list of strings as the `cols` parameter. Rows can be formatted as column-keyed dictionaries by passing True as the `dict` parameter. """ if re.match(r'https?:', pth): resp = HTTP.get(pth) resp.raise_for_status() extension_type = splitext(urlparse(pth).path)[-1] content_type = resp.headers.get('content-type', extension_type).lower() for data_t in ['json', 'csv']: if data_t in content_type: extension_type = data_t if binaryish(content_type, format): fd = BytesIO(resp.content) else: if encoding: resp.encoding = encoding elif 'charset' not in content_type: resp.encoding = resp.apparent_encoding fd = StringIO(resp.text) else: enc = encoding or 'utf-8' extension_type = splitext(pth)[-1].lower() if binaryish(extension_type, format): fd = open(os.path.expanduser(pth), 'rb') else: fd = open(os.path.expanduser(pth), 'rt', encoding=enc) if kwargs.get('dict') is True: kwargs['dict'] = dict elif kwargs.get('dict') is False: del kwargs['dict'] dict_type = kwargs.get('dict', dict) format = (format or extension_type).lstrip('.') if format=='json': return json.load(fd, object_pairs_hook=dict_type) elif format=='csv': dialect = csv_dialect(fd) if cols: if kwargs.get('dict'): return list(csv_dict(fd, dialect=dialect, cols=cols, dict=dict_type)) else: return list(csv_tuple(fd, dialect=dialect, cols=cols)) return list(csv_rows(fd, dialect=dialect)) else: return fd.read()
58f1b53b7ece08bc0da44dbd709e107e0ae46dbf
5,289
def audio(src: str) -> str: """ Insert audio tag The tag is currently not supported by Nuance, please use `audio_player` kit: docs/use_kits_and_actions.md :param src: :return: """ return f'<audio src="{src}"/>'
f9396d5f82eeca27089de41187fd7d5e967cc9cf
5,290
import os def read(*rnames): """ Read content of a file. We assume the file to be in utf8 """ return open(os.path.join(os.path.dirname(__file__), *rnames), encoding="utf8", mode="r").read()
15b1acf39188810080c3c47908b011011f4d35ca
5,291
import math def PerpendicularDistanceToFinish(point_b_angle: float, point_b: gps_pb2.Point) -> float: """ cos(B) = Adjacent / Hypotenuse https://www.mathsisfun.com/algebra/trig-finding-side-right-triangle.html """ return math.cos(math.radians(point_b_angle)) * point_b.start_finish_distance
3c18c323c625893ab474c48eb00d48da543956ba
5,292
import requests from typing import List def get_revolut_stocks() -> List[str]: """ Gets all tickers offered on Revolut trading platform. Returns: list(str) """ req = requests.get("https://globefunder.com/revolut-stocks-list/") tickers = list(pd.read_html(req.content)[0]["Symbol"]) tickers = [ticker.replace(".", "-") for ticker in tickers] return tickers
3e7f41a04c653a954609cee618cbf89d962fef1d
5,293
def response_text(response_class): """ Return the UTF-8 encoding of the API response. :param response_class: class to cast the response to :return: Text of the response casted to the specified class """ def _inner(f): @wraps(f) def wrapper(obj, *args, **kwargs): result = f(obj, *args, **kwargs) if isinstance(result, response_class): return result try: return response_class(result.text) except Exception: logger.debug("Exception during response parsing.", exc_info=True) raise APIError("Exception during response parsing") return wrapper return _inner
43f0d4cde4790128073440172ed30850794de7a9
5,294
from typing import Tuple def create_rankings( a: Dataset, b: Dataset, n_samples: int = 100, unravel: bool = False, **kwargs: int ) -> Tuple[ndarray, ndarray]: """ Sample a dataset 'a' with 'n' negative samples given interactions in dataset 'a' and 'b'. Practically, this function allows you to generate evaluation data as described in the work of He et al. [1]. The evaluation procedure assumes that the input datasets 'a' and 'b' have been generated with a leave 'n' out policy, such that dataset 'b' corresponds to the 'training' dataset (i.e. dataset with 'left out' samples removed) and 'a' corresponds to the 'test' dataset with 'n' for each user with n_interactions > n. For each user in 'a', the function will return that user's 'n' left-out interactions, plus 'n_samples' negative samples (items the user has not interacted with in both the 'train' and 'test' datasets). Parameters ---------- a: Dataset The 'test' dataset (the dataset you wish to use for evaluation). b: Dataset The 'train' dataset (the dataset you wish to include for purposes of sampling items the user has not interacted with -- negative samples). n_samples: int The total number of negative samples per user to generate. For example, if the dataset 'a' was generated from a leave-one-out split, and n_samples=100, that user would receive 101 samples. unravel: bool If 'True', the function will return two arrays, where the first element of the first array corresponds to the user _vector_ (i.e. user ID + optional metadata), the first element of the first array corresponds to an associated sampled item vector(i.e. item ID + optional metadata). Returns ------- output: (ndarray, List[ndarray]) If 'unravel=False', the first element corresponds to an array of _ordered_ user ids, the second the `n_samples+1`per-user samples. If `unravel=True`, the first element corresponds to an array of _ordered_ user vectors, the second to each individual item vector. See `unravel` argument and `_unravel_ranked`, below. This function is provided for use when evaluating Keras Models with the `predict` method. References ---------- [1] He et al. https://dl.acm.org/doi/10.1145/3038912.3052569 """ users, items, _ = a.to_components( negative_samples=n_samples, aux_matrix=b.interactions.tocsr(), shuffle=False, sampling_mode="absolute", ) unique_users = unique(users) sampled_users, sampled_items = ( users[len(unique_users) :], items[len(unique_users) :], ) _, grouped = groupby(sampled_users, sampled_items) grouped = c_[grouped, items[: len(unique_users)]] if unravel: return _unravel_sampled(unique_users, grouped, a, **kwargs) else: return unique_users, grouped
28282fc14d02b7f93d58d209d143a315e7b25422
5,295
def make_even(x): """Make number divisible by 2""" if x % 2 != 0: x -= 1 return x
10129eb6abd718414d0ada53915672dcf4d7b5b6
5,296
def get_num_vehicles(session, query_filters): """Gets the total number of annotations.""" # pylint: disable-msg=E1101 num_vehicles_query = session.query( func.count(Vehicle.id)) \ .join(Photo) \ .filter(Photo.test == True) \ # pylint: enable-msg=E1101 for query_filter in query_filters: num_vehicles_query = num_vehicles_query.filter(query_filter) num_vehicles, = num_vehicles_query.one() return num_vehicles
bf626edad29b136bb595dabb7e878649c08c0d84
5,297
def task_status_edit(request, status_id, response_format='html'): """TaskStatus edit""" status = get_object_or_404(TaskStatus, pk=status_id) if not request.user.profile.has_permission(status, mode='w'): return user_denied(request, message="You don't have access to this Task Status") if request.POST: if 'cancel' not in request.POST: form = TaskStatusForm( request.user.profile, request.POST, instance=status) if form.is_valid(): status = form.save() return HttpResponseRedirect(reverse('projects_index_by_status', args=[status.id])) else: return HttpResponseRedirect(reverse('projects_index_by_status', args=[status.id])) else: form = TaskStatusForm(request.user.profile, instance=status) context = _get_default_context(request) context.update({'form': form, 'status': status}) return render_to_response('projects/status_edit', context, context_instance=RequestContext(request), response_format=response_format)
593384ab55bf889a1e87d7909e848a2dbacad68e
5,298
import platform def is_windows_system(): """ | ##@函数目的: 获取系统是否为Windows | ##@参数说明:True or False | ##@返回值: | ##@函数逻辑: | ##@开发人:jhuang | ##@时间: """ return 'Windows' in platform.system()
6bfe296188b9dccf8338f0b2bbaaf146d9b22243
5,299