prompt stringlengths 19 1.03M | completion stringlengths 4 2.12k | api stringlengths 8 90 |
|---|---|---|
from sklearn.linear_model import LogisticRegression
from sklearn.ensemble import RandomForestClassifier
import xgboost as xgb
import lightgbm as lgb
import numpy as np
import pandas as pd
import os
import matplotlib.pyplot as plt
import seaborn as sns
color = sns.color_palette()
import matplotlib as mpl
from sklearn i... | pd.DataFrame(data=[],index=y_train.index) | pandas.DataFrame |
import pandas as pd
import argparse
from difflib import get_close_matches
import PyFloraBook.in_out.data_coordinator as dc
# ---------------- GLOBALS ----------------
# These are the weights used to create the final score (a weighted avg)
WEIGHTS = {
"CalFlora": 1,
"OregonFlora": 1,
"CPNWH_OR": ... | pd.DataFrame.from_dict(WEIGHTS, orient="index") | pandas.DataFrame.from_dict |
from __future__ import absolute_import
import pandas as pd
from io import StringIO
import zlib
from .. import encode, decode
from ..handlers import BaseHandler, register, unregister
from ..util import b64decode, b64encode
from .numpy import register_handlers as register_numpy_handlers
from .numpy import unregister_ha... | pd.DataFrame() | pandas.DataFrame |
import numpy as np
import pytest
from pandas.errors import UnsupportedFunctionCall
from pandas import DataFrame, DatetimeIndex, Series
import pandas._testing as tm
from pandas.core.window import Expanding
def test_doc_string():
df = DataFrame({"B": [0, 1, 2, np.nan, 4]})
df
df.expanding(2... | tm.assert_series_equal(actual, expected) | pandas._testing.assert_series_equal |
"""
Test output formatting for Series/DataFrame, including to_string & reprs
"""
from datetime import datetime
from io import StringIO
import itertools
from operator import methodcaller
import os
from pathlib import Path
import re
from shutil import get_terminal_size
import sys
import textwrap
import dateutil
import ... | option_context("display.max_rows", None, "display.min_rows", 12) | pandas.option_context |
#!/usr/bin/env python
# -*- coding:utf-8 -*-
"""
Date: 2022/2/2 23:26
Desc: 东方财富网-行情首页-沪深京 A 股
"""
import requests
import pandas as pd
def stock_zh_a_spot_em() -> pd.DataFrame:
"""
东方财富网-沪深京 A 股-实时行情
http://quote.eastmoney.com/center/gridlist.html#hs_a_board
:return: 实时行情
:rtype: pandas.DataFrame
... | o_numeric(temp_df["最低"], errors="coerce") | pandas.to_numeric |
import os
import csv
import re
import csv
import math
from collections import defaultdict
from scipy.signal import butter, lfilter
import matplotlib.pyplot as plt
import pandas as pd
import numpy as np
from statistics import mean
from scipy.stats import kurtosis, skew
from sklearn.svm import SVC
from sklearn import met... | pd.Series(gyr_x_data) | pandas.Series |
# -*- coding: utf-8 -*-
"""
Created on Mon 11 January 2022
Modified by <EMAIL> on 21/10/2021
@author: <NAME>
@contact: <EMAIL>
@license: /
"""
import mmap
import os
import sys
import numpy as np
import pandas as pd
from io import StringIO
from configparser import ConfigParser
class CustomParser(Confi... | pd.read_csv(fname, sep='\t', header=None, dtype=float, prefix='Y') | pandas.read_csv |
# -*- coding: utf-8 -*-
"""
Tests the usecols functionality during parsing
for all of the parsers defined in parsers.py
"""
import nose
import numpy as np
import pandas.util.testing as tm
from pandas import DataFrame, Index
from pandas.lib import Timestamp
from pandas.compat import StringIO
class UsecolsTests(obj... | tm.assert_frame_equal(df, expected) | pandas.util.testing.assert_frame_equal |
"""
Same as simple_model_2, but use ensemble model.
"""
from sklearn_pandas import DataFrameMapper, CategoricalImputer
import logging
from ..Loader import Loader
from ..Paths import DICT_PATHS
import pandas as pd
from sklearn.pipeline import make_pipeline
from ..sk_util import CategoricalEncoder
from sklearn.preprocess... | pd.DataFrame(clf.cv_results_) | pandas.DataFrame |
import sys
import pandas as pd
import numpy as np
import pickle
import json
import util
def recommend_settings(model_dump, survey_json):
model = pickle.loads(model_dump)
survey_answers = pd.DataFrame(json.loads(survey_json)).T
measures = util.calc_measures_from_survey(survey_answers)
def search_sett... | pd.DataFrame() | pandas.DataFrame |
# Arithmetic tests for DataFrame/Series/Index/Array classes that should
# behave identically.
# Specifically for datetime64 and datetime64tz dtypes
from datetime import (
datetime,
time,
timedelta,
)
from itertools import (
product,
starmap,
)
import operator
import warnings
import numpy as np
impo... | Timestamp("20130101 9:02") | pandas.Timestamp |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""Analyze SON scan csv file. You can run this as a script.
Optional argument of script is a slice (notation 0:) or
list of indices (comma-soparated, e.g. 0,1,-2,-1).
Copyright <NAME> (2022) - Twitter: @hk_nien
License: MIT.
Created on Sat Feb 5 23:28:03 2022
"""
impor... | pd.to_datetime(df['scan_time']) | pandas.to_datetime |
"""
Define a set of classes that function like forecasters, akin
to the R forecast package.
"""
import copy
import itertools
from typing import List, Tuple, Callable
import pandas as pd
import numpy as np
import scipy.linalg as spla
import tensorly as tl
from scipy.fftpack import rfft, irfft, dct
from tensorly.decompo... | pd.Series(in_sample_approx, index=vals.index[:nr_in_steps]) | pandas.Series |
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
from __future__ import unicode_literals
import six
import logging
import numpy as np
import pandas as pd
import utils.boxes as box_utils
import utils.keypoints as keypoint_utils
from core.config import cfg
fro... | pd.DataFrame.from_dict(data_dict) | pandas.DataFrame.from_dict |
from .handler import function_handler
import yaml
import pytest
import pandas as pd
import numpy as np
from packaging import version
def transform_setup(function):
# read in file infos
with open("tests/test_yamls/test_transform.yml", "r") as stream:
file_infos = yaml.safe_load(stream)
if function... | pd.read_csv(input_file) | pandas.read_csv |
import re
import numpy as np
import pytest
import pandas as pd
import pandas._testing as tm
from pandas.core.arrays import IntervalArray
class TestSeriesReplace:
def test_replace_explicit_none(self):
# GH#36984 if the user explicitly passes value=None, give it to them
ser = pd.Series([0, 0, ""],... | pd.date_range("20130101", periods=5) | pandas.date_range |
import pandas as pd
import abc
class BaseField(abc.ABC):
def __init__(self, dtype=None, admits_null=True, admits_empty=True):
self._admits_null = bool(admits_null)
self._admits_empty = bool(admits_empty)
self._dtype = dtype
@property
def dtype(self):
return self._d... | pd.isnull(value) | pandas.isnull |
#!/usr/bin/env python2
# -*- coding: utf-8 -*-
"""
ImportExtinctionRecallTaskLog.py
Import, tabulate, and plot Extinction Recall 3 log data.
Created 1/3/19 by DJ.
Updated 1/10/19 by DJ - adjusted to new VAS logging format, added GetVasTypes.
Updated 1/11/19 by DJ - bug fixes, comments.
Updated 2/25/19 by DJ - renamed... | pd.read_excel(outSoundTable,index_col=None) | pandas.read_excel |
import pandas as pd
import sys
from Bio import SeqIO
sys.stderr = sys.stdout = open(snakemake.log[0], "w")
num_files = len(snakemake.input.annotations)
snakemake.output.taxid_db
annotations_id_dict = {}
annotations_name_dict = {}
# In annotations[0] if could be an empty string or the table provided by the user
if ... | pd.concat([taxid_df, merge_df]) | pandas.concat |
#!/usr/bin/env python
import re, argparse, sys, os
import numpy as np
import pandas as pd
class MQcolnames(object):
def __init__(self, df):
self.columns = df.columns.tolist()
self.new2old_colnames_dict = {"Potential contaminant": "Contaminant",
"Modified se... | pd.melt(dfm, id_vars=[groupby_], value_vars=["perc_OxM", "perc_DeamN", "perc_DeamQ"], var_name="MNQ", value_name="percDeam") | pandas.melt |
import json
import sys
from functools import partial
import numpy as np
import pandas as pd
if sys.version_info[0] < 3:
pass
else:
pass
from tqdm import tqdm
def create_et_data(data, n_bins=5):
data["et_data"] = data['et_data'] \
.apply(str) \
.str.replace('$', ',', regex=False)
et_i... | pd.notna(data['et_data']) | pandas.notna |
# -*- coding: utf-8 -*-
# pylint: disable=E1101
# flake8: noqa
from datetime import datetime
import csv
import os
import sys
import re
import nose
import platform
from multiprocessing.pool import ThreadPool
from numpy import nan
import numpy as np
from pandas.io.common import DtypeWarning
from pandas import DataFr... | u("""ignore this
ignore this too
index|A|B|C
foo|1|2|3
bar|4|5|6
baz|7|8|9
""") | pandas.compat.u |
import numpy as np
import pandas as pd
from .real_datasets import RealDataset
class KDDCup(RealDataset):
def __init__(self, seed):
super().__init__(
name="KDD Cup '99", raw_path='kddcup-data_10_percent_corrected.txt', file_name='kdd_cup.npz'
)
self.seed = seed
def load(se... | pd.DataFrame(data=test) | pandas.DataFrame |
import pandas as pd
import matplotlib.pyplot as plt
import main as mm
import work_wth_data as wd
def find_entry_date_range(filen):
"""input file or list, asks for descriptors, returns a list of lines"""
date_lower = input("Please enter a date LOWER BOUND (ex. 1-2-20, 10-21-19)(xxx to ignore): ")
da... | pd.DataFrame(list_of_lines[1:], columns=list_of_lines[0]) | pandas.DataFrame |
"""This module contains PlainFrame and PlainColumn tests.
"""
import collections
import datetime
import pytest
import numpy as np
import pandas as pd
from numpy.testing import assert_equal as np_assert_equal
from pywrangler.util.testing.plainframe import (
NULL,
ConverterFromPandas,
NaN,
PlainColumn... | pd.DataFrame({"float": [1.0, 2.0]}) | pandas.DataFrame |
from collections import defaultdict
import matplotlib.pyplot as plt
import numpy as np
from operator import itemgetter
import pandas as pd
import pickle
from scipy import sparse
from scipy.spatial.distance import cosine
import seaborn
from sklearn import preprocessing
from sklearn.neighbors import NearestNeighbors
from... | pd.DataFrame() | pandas.DataFrame |
# Copyright 2017 Google Inc.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, ... | pd.Series([[], []]) | pandas.Series |
import altair as alt
import pandas as pd
import numpy as np
import sys
TRUSTTSV = sys.argv[1]
CELLNUM = sys.argv[2]
BCRTEMP = """
<div style="width: 100%; height: 700px; position: relative; clear:both;overflow: hidden; white-space:nowrap; padding-top: 10px;clear:both;">
<div style="width: 110%, position: absolute; ... | pd.concat([lightchainaa, heavychainaa]) | pandas.concat |
import geopandas as gpd
import pandas as pd
import os
import numpy as np
import sys
import itertools
import ast
import math
from scipy import stats
def main():
'''
Traffic speed assignment script
vehicle_id, edge_path, time_stamp
'''
data_path,calc_path,output_path = load_config()['paths']['data']... | pd.read_csv(routes_in) | pandas.read_csv |
#
# Licensed to the Apache Software Foundation (ASF) under one or more
# contributor license agreements. See the NOTICE file distributed with
# this work for additional information regarding copyright ownership.
# The ASF licenses this file to You under the Apache License, Version 2.0
# (the "License"); you may not us... | pd.MultiIndex.from_tuples([("X", "A"), ("Y", "B")], names=["1", "2"]) | pandas.MultiIndex.from_tuples |
import time
import pandas as pd
import numpy as np
import sys
CITY_DATA = {'chicago': 'chicago.csv',
'new york city': 'new_york_city.csv',
'washington': 'washington.csv'}
def get_filters():
"""
Asks user to specify a city, month, and day to analyze.
Returns:
... | pd.read_csv(CITY_DATA[city]) | pandas.read_csv |
from math import sqrt
import time
import os
import sys
import pandas as pd
import gurobipy as gp
from gurobipy import GRB
import numpy as np
import jax
import jax.numpy as jnp
from architect.optimization import (
AdversarialLocalOptimizer,
)
from architect.examples.satellite_stl.sat_design_problem import (
... | pd.DataFrame() | pandas.DataFrame |
# <NAME>, <NAME>
# main.py
# Processes exoplanet data
import matplotlib
import sys
import pandas as pd
import numpy as np
from sklearn import datasets, linear_model
from sklearn.model_selection import train_test_split
import matplotlib.pyplot as plt
db_path = 'data/kepler.csv'
def main():
filein = open(db_path... | pd.to_numeric(df["radius"]) | pandas.to_numeric |
# # Customer/Card Detection techniques
#
# One of the main challenges of this competition (https://www.kaggle.com/c/ieee-fraud-detection) is **how you obtain the card or the customer whose the transactions, fraudulent or not, belong to.** It has been said that the datasets have all the information to get this, but we ... | pd.DataFrame(columns=[serie.name, 'count', 'weight fraud']) | pandas.DataFrame |
import numpy as np
import pandas as pd
from rdt import HyperTransformer
from rdt.transformers import OneHotEncodingTransformer
def get_input_data_with_nan():
data = pd.DataFrame({
'integer': [1, 2, 1, 3, 1],
'float': [0.1, 0.2, 0.1, np.nan, 0.1],
'categorical': ['a', 'b', np.nan, 'b', 'a'... | pd.testing.assert_frame_equal(data, reverse) | pandas.testing.assert_frame_equal |
import pandas as pd
import os
import re
import pdb
from glob import glob
from arctic import CHUNK_STORE, Arctic
from arctic.date import DateRange
from datetime import datetime as dt
from datetime import date
import arrow
DEFAULT_START_TIME = arrow.get(2017,1,20)
DEFAULT_END_TIME = arrow.get(2017,2,6)
def write_wrap... | pd.read_csv(f) | pandas.read_csv |
import pandas as pd
import xarray as xr
import numpy as np
import pyomo.environ as pe
from datetime import datetime
import os
from pyomo.opt import SolverStatus, TerminationCondition
class problem:
# Set up the problem
def __init__(self, folder, simulation_name):
# Path to the folder where the input fi... | pd.read_csv(folder + '/inflow.csv') | pandas.read_csv |
import time
import numpy as np
import pandas as pd
from scipy.sparse import csr_matrix
from tqdm import tqdm
from course_lib.Base.BaseRecommender import BaseRecommender
from src.data_management.data_preprocessing_fm import sample_negative_interactions_uniformly
from src.utils.general_utility_functions import get_tota... | pd.get_dummies(df_subclass['subclass']) | pandas.get_dummies |
import copy
from functools import lru_cache
from os import path
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
from ray import tune
from scipy import stats
from tune_tf2.defaults import EXPLOIT_CSV, HPS_CSV, PBT_CSV
@lru_cache(maxsize=10)
def load_tune_df(experiment_dir):
"""Cache the cre... | pd.isna(exploiter) | pandas.isna |
from pathlib import Path
from typing import Dict
import numpy as np
import pandas as pd
def read_files(folder) -> Dict[str, pd.DataFrame]:
"""Read in all data files. The time will be the index if present.
Parameters
----------
folder : str or pathlike
The folder where the data files are loca... | pd.read_csv(folder / filenames[2], delim_whitespace=True) | pandas.read_csv |
import dash
import dash_html_components as html
from dash.dependencies import Input, Output
import dash_core_components as dcc
#import dash_auth
import plotly.graph_objs as go
import pandas as pd
import dash_table
import numpy as np
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.metrics.pairwi... | pd.Series(cosine_similarities[article_index]) | pandas.Series |
from collections import (
abc,
deque,
)
from decimal import Decimal
from warnings import catch_warnings
import numpy as np
import pytest
import pandas as pd
from pandas import (
DataFrame,
Index,
MultiIndex,
PeriodIndex,
Series,
concat,
date_range,
)
import pandas._testing as tm
fr... | tm.makeTimeSeries() | pandas._testing.makeTimeSeries |
import os
import numpy as np
import soundfile
import librosa
from sklearn import metrics
import logging
import matplotlib.pyplot as plt
import matplotlib.ticker as ticker
import pandas as pd
import sed_eval
import torch
from torch.autograd import Variable
import vad
from vad import activity_detection
import config
... | pd.read_csv(strong_meta, sep='\t') | pandas.read_csv |
import os
import shutil
import sys
import glob
from pathlib import Path
import pandas as pd
# -----------------
# STEP 0: variables
# -----------------
root_dir = '/exports/fsw/Bendlab/SamenUniek'
raw_sessions = ['MCC_ses01-lab']
bids_sessions = ['ses-w01lab']
file_type = ['3DT1', 'SNAT1', 'SNAT2', 'SNAT3', 'PCG1', '... | pd.read_csv(conversion_log_fn) | pandas.read_csv |
# Preprocessing
import os, matplotlib
if 'DISPLAY' not in os.environ:
matplotlib.use('Pdf')
import matplotlib.pyplot as plt
import pandas as pd
pd.set_option('display.max_rows', 50)
import numpy as np
import xgboost as xgb
import xgbfir
import pdb
import time
np.random.seed(1337)
def client_anaylsis():
"""
... | pd.to_numeric(product["beverage"]) | pandas.to_numeric |
# -*- coding: utf-8 -*-
"""
Created on Wed Apr 17 18:51:11 2019
@author: Meagatron
"""
# -*- coding: utf-8 -*-
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt,mpld3
from collections import defaultdict
from sklearn.metrics.pairwise import euclidean_distances
from flask import Flask, render_t... | pd.read_csv('ecg.csv', sep=',', header=None) | pandas.read_csv |
'''
Created on Aug 24, 2018
@author: Prashant.Pal
'''
import pandas as pd
import matplotlib.pyplot as plt
mylist=['A','B','C','D','E']
mydict = {'X':[1,2,3,4,5],'Y':[20,30,40,50,60],'Z':[50,60,70,80,90]}
mydict1 = {0:[1,2,3,4,5],1:[20,30,40,50,60],2:[50,60,70,80,90]}
#print(mylist[1:])
df = pd.DataFrame(mydict)
prin... | pd.DataFrame(mydict1) | pandas.DataFrame |
"""
Created by: <NAME>
Sep 7
IEEE Fraud Detection Model
- Add back ids
- Add V Features
"""
import numpy as np # linear algebra
import pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)
import os
import sys
import matplotlib.pylab as plt
from sklearn.model_selection import KFold
from datetime import d... | pd.read_csv(csv_file, index_col=[0]) | pandas.read_csv |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import pandas as pd
from datetime import datetime, timedelta
import numpy as np
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt
import os
import matplotlib.ticker as tck
import matplotlib.font_manager as fm
import math as m
import matplotlib.dates as... | pd.concat([df_P348_15m, Rad_df_348, df_Theorical_348], axis=1) | pandas.concat |
import requests
from typing import List
import re
# from nciRetriever.updateFC import updateFC
# from nciRetriever.csvToArcgisPro import csvToArcgisPro
# from nciRetriever.geocode import geocodeSites
# from nciRetriever.createRelationships import createRelationships
# from nciRetriever.zipGdb import zipGdb
# from nciRe... | pd.read_csv(f'nciMainBiomarkers{today}.csv') | pandas.read_csv |
"""
Functions to create charts.
"""
import altair as alt
import altair_saver
import os
import pandas as pd
from processing_utils import default_parameters
from processing_utils import utils
from IPython.display import display, SVG
alt.renderers.enable('altair_saver', fmts=['svg'])
def show_svg(image_name):
imag... | pd.DataFrame({"y": [0.3]}) | pandas.DataFrame |
# Copyright 2022 Accenture Global Solutions Limited
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable ... | pd.Float32Dtype() | pandas.Float32Dtype |
import pandas as pd
from pandas._libs.parsers import pandas_dtype
import logging
def input_df_contract(contract_params: dict, df_param=None):
"""
This decorator allow to check properties of a df transformation
Args:
df_param: name of the param of the function that is the input df
contract_... | pd.testing.assert_index_equal(df_in.index, df_out.index) | pandas.testing.assert_index_equal |
#/Library/Frameworks/Python.framework/Versions/3.6/bin/python3
#
# Author: <NAME>
# Date: 2018-09-26
#
# This script runs all the models on Baxter Dataset subset of onlt cancer and normal samples to predict diagnosis based on OTU data only. This script only evaluates generalization performance of the model.
#
#######... | pd.concat([cv_aucs_df,test_aucs_df], axis=1, keys=['Cross-validation','Testing']) | pandas.concat |
import datetime as dt
import matplotlib.pyplot as plt
import matplotlib.ticker as mtick
import pandas as pd
from AShareData import AShareDataReader, constants, SHSZTradingCalendar, utils
from AShareData.config import get_db_interface
from AShareData.database_interface import DBInterface
from AShareData.factor import ... | tetime(df['最后交易日']) | pandas.to_datetime |
import numpy as np
from os.path import join, isfile
from os import chdir, makedirs, remove
import pandas as pd
import matplotlib.pyplot as plt
from shutil import rmtree, copyfile
import subprocess
import glob
import os
def post_disc(exp_name, dtw_thr, zr_root):
"run conn-comp clustering"
chdir(zr_root)
... | pd.DataFrame(columns=['filename', 'start', 'end']) | pandas.DataFrame |
import pandas as pd # version 1.0.1
# in pandas 1.1.4 dates for INTESA and BMG doesn't work after merge in "final"
from datetime import datetime
# TODO find repetitions and replace them with functions
# for example Santander and CITI files import and adjustment
# or date and amount formatting
pd.options.display.float... | pd.to_datetime(intesa['data'], format='%Y-%m-%d') | pandas.to_datetime |
"""local_mongo_sync_beta_app"""
#code='local_mongo_sync_beta_app'
#mongo_string='mongodb://root:pqeBqx8qgV@192.168.127.12:27017/?authSource=admin&readPreference=primary&appname=MongoDB%20Compass&ssl=false'
#es_host = 'localhost:9200'
#from elasticsearch import Elasticsearch
#es = Elasticsearch([{'host': 'localhost', 'p... | pd.DataFrame(users_list) | pandas.DataFrame |
import numpy as np
import pandas as pd
import pyapprox as pya
from scipy.stats import uniform
import json
import os
import time
from pyapprox.random_variable_algebra import product_of_independent_random_variables_pdf
from basic.boots_pya import fun
from basic.partial_rank import partial_rank
from basic.read_data impor... | pd.DataFrame.from_dict(errors_cv) | pandas.DataFrame.from_dict |
import pandas as pd
import pytest
import numpy as np
import dask.dataframe as dd
from dask.dataframe.utils import assert_eq, PANDAS_VERSION
N = 40
df = pd.DataFrame(
{
"a": np.random.randn(N).cumsum(),
"b": np.random.randint(100, size=(N,)),
"c": np.random.randint(100, size=(N,)),
... | pd.Timedelta(after) | pandas.Timedelta |
from tools.crawler import SecCrawler
import re
import requests
import os
import sys
import pandas as pd
import numpy as np
from datetime import datetime, timedelta
# add config.py file which contains https://www.worldtradingdata.com/ API key
from config.config import WTD_api_key, simfin_api_key
from ipdb import set_tra... | pd.Series(0, index=stock_count.index) | pandas.Series |
import logging
import os
import re
import openpyxl
import pandas as pd
from Configs import getConfig
config = getConfig()
log = logging.getLogger(__name__)
log.addHandler(logging.StreamHandler())
log.setLevel(getattr(logging, config.LOG_LEVEL))
def parse_targets(ttd_target_download_file):
pattern = re.compile(... | pd.DataFrame.from_dict(targets, orient='index') | pandas.DataFrame.from_dict |
import os
import json
import hashlib
import logging
import datetime
import contextlib
import pandas as pd
from sqlalchemy import create_engine
from sqlalchemy import select, column, text, desc
from sqlalchemy.exc import OperationalError
from koapy import KiwoomOpenApiContext
from koapy.backend.cybos.CybosPlusComObje... | pd.read_excel(filepath, dtype=str) | pandas.read_excel |
import numpy as np
import pandas as pd
import pytest
from temporis.transformation.features.imputers import (ForwardFillImputer,
MeanImputer,
MedianImputer,
... | pd.isnull(df_new['a'][1]) | pandas.isnull |
import pandas as pd
from bs4 import BeautifulSoup
import requests
# For player ranks
url = 'http://www.cricmetric.com/ipl/ranks/'
pd.read_html(requests.get(url).content)[-1].to_csv("./Dataset/_player_rank.csv", index=False, header=None)
# Store the sum of EF score by team.
data = pd.read_csv('./Dataset/_player_rank.c... | pd.DataFrame(clean_df) | pandas.DataFrame |
# pylint: disable=redefined-outer-name,protected-access
# pylint: disable=missing-function-docstring,missing-module-docstring,missing-class-docstring
# pylint: disable=global-statement
import pandas as pd
import param
import pytest
from bokeh.models.sources import ColumnDataSource
from awesome_panel_extensions.widgets... | pd.DataFrame({"x": [1, 2, 3, 4], "y": ["a", "b", "c", "d"]}) | pandas.DataFrame |
import geopandas as gp
import numpy as np
import pandas as pd
import pytest
import shapely
import xarray as xr
from regionmask import Regions, from_geopandas, mask_3D_geopandas, mask_geopandas
from regionmask.core._geopandas import (
_check_duplicates,
_construct_abbrevs,
_enumerate_duplicates,
)
from .ut... | pd.Series([1, 1, 2, 3, 4]) | pandas.Series |
"""Module to perform QC on the xiRT performance."""
import glob
import logging
import os
import matplotlib as mpl
import matplotlib.pyplot as plt
import numpy as np
import palettable
import pandas as pd
import seaborn as sns
import statannot
from matplotlib import ticker
from matplotlib.lines import Line2D
from scipy.... | pd.read_csv(i) | pandas.read_csv |
import pandas as pd
import numpy as np
from .utility_fxns import distribute
def generate_id_dict(id_list, prod_ids, df):
''' docstring for generate_id_dict
input: product id list
output: dictionary of
key: product id
values: [position of product id in full matrix
, number o... | pd.read_csv(filename) | pandas.read_csv |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Written by <NAME> for
Low runoff variability driven by a dominance of snowmelt inhibits clear coupling of climate, tectonics, and topography in the Greater Caucasus Mountains
If you use this code or derivatives, please cite the original paper.
"""
import pandas as pd... | pd.read_csv('data_tables/gc_ero_master_table.csv') | pandas.read_csv |
#!/usr/bin/env python
import requests
import numpy as np
import pandas as pd
import json
import pytz
def _GET(url):
req = requests.get(url)
data = req.json()
return data
def _get_data(url):
raw = _GET(url)
return json.dumps(raw['Data'])
def _get_dowjones_data(url):
... | pd.read_json(data, convert_dates=['time']) | pandas.read_json |
import pandas
import dateutil
import datetime
import seaborn
import matplotlib
import matplotlib.pylab
import databaseAccess
import matplotlib.pyplot as plt
# py -c 'import visualiseData; visualiseData.getFastestTimes()'
def getFastestTimes():
splits = databaseAccess.getSplits()
activities = splits[['activity_... | pandas.concat(frames) | pandas.concat |
#!/usr/bin/python
# encoding: utf-8
"""
@author: Ian
@file: abnormal_detection_gaussian.py
@time: 2019-04-18 18:03
"""
import pandas as pd
from mayiutils.file_io.pickle_wrapper import PickleWrapper as picklew
from feature_selector import FeatureSelector
if __name__ == '__main__':
mode = 4
if mode == 4:
... | pd.get_dummies(df2['核保标识'], prefix='核保标识') | pandas.get_dummies |
import math
import os
from os.path import join as pjoin
import json
import copy
import matplotlib.pyplot as plt
import numpy as np
import seaborn as sns
import GPUtil
import pandas as pd
from multiprocessing import Pool
from tqdm import tqdm
import sklearn.metrics
from .config import print_config, class_labels
from .... | pd.read_csv(config['path_to_valid_anno_cache'], index_col=0) | pandas.read_csv |
import hydra
import pandas as pd
from sklearn import preprocessing
import os
from pathlib import Path
def handle_columns(cfg, df, median_dict, label_encoder, is_train=False):
# Add column for missing values
if cfg.data.add_missing_col_rep_income:
df['isNaN_rep_income'] = (df['rep_income'].isnull()).as... | pd.read_csv(path/'test.csv') | pandas.read_csv |
import module
import os
import librosa
import soundfile as sf
import numpy as np
import glob
import pandas as pd
def extract_features():
# path to dataset containing 10 subdirectories of .ogg files
sub_dirs = os.listdir('data')
sub_dirs.sort()
features_list = []
for label, sub_dir ... | pd.DataFrame(features_list,columns = ['feature','class_label', 'Directory']) | pandas.DataFrame |
"""
Developer : <NAME>
Description: Based on the Battery sensor Data, charger plug in time and duration of plug in time are extracted on a daily basis.
"""
#Importing the required libraries.
import collections as col
import functools
from collections import Counter
import pandas as pd
import FeatureExtraction.CommonFu... | pd.DataFrame(batterychargeTime_perDay,columns=['ID','Date','CharginTimeDaily']) | pandas.DataFrame |
import re
import pandas as pd
import numpy as np
from gensim import corpora, models, similarities
from difflib import SequenceMatcher
from build_tfidf import split
def ratio(w1, w2):
'''
Calculate the matching ratio between 2 words.
Only account for word pairs with at least 90% similarity
'''
m = Sequence... | pd.DataFrame(testData, columns=['qt', 'qd', 'qa', 'mt', 'md', 'ma', 'ql']) | pandas.DataFrame |
#Author: <NAME>
#Email: <EMAIL>
#Script uses a random forest classifier to predict loan defaults within the lending Club dataset
import os, errno, time, smtplib, ssl, pickle
from datetime import datetime
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from pandas.plotting import register_... | pd.read_csv(r'C:\Users\mhr19\Dropbox\CODE\CONSUMER_DEBT\DATA\TRAIN\loans_SMOTE_y_train_all.CSV') | pandas.read_csv |
# BSD 2-CLAUSE LICENSE
# Redistribution and use in source and binary forms, with or without modification,
# are permitted provided that the following conditions are met:
# Redistributions of source code must retain the above copyright notice, this
# list of conditions and the following disclaimer.
# Redistributions i... | pd.DataFrame() | pandas.DataFrame |
# *****************************************************************************
# Copyright (c) 2019, Intel Corporation All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are met:
#
# Redistributions of sou... | pandas.core.strings.StringMethods(self) | pandas.core.strings.StringMethods |
# Copyright 2021 Prayas Energy Group(https://www.prayaspune.org/peg/)
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by... | pd.read_csv(filepath) | pandas.read_csv |
from dataset_loader import *
from utils import *
from model import BeautyModel
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import matplotlib.style as style
from PIL import Image
physical_devices = tf.config.experimental.list_physical_devices('GPU')
if len(physical_devices) > 0:
tf.confi... | pd.read_csv('Dataset/beauty_dataset.csv') | pandas.read_csv |
# EcoFOCI
"""Contains a collection of wetlabs equipment parsing.
(A seabird product now)
These include:
Moored Eco and Wetstars:
* 1 channel -> 3 channel systems
Non-moored:
* processing is likely the same if recording internally.
"""
import sys
import pandas as pd
class wetlabs(object):
r""" Wetlabs Unified... | pd.DatetimeIndex(rawdata_df['date_time']) | pandas.DatetimeIndex |
from PyDSS.pyContrReader import pySubscriptionReader as pySR
from PyDSS.pyLogger import getLoggerTag
from PyDSS.unitDefinations import type_info as Types
from PyDSS.unitDefinations import unit_info as Units
from PyDSS.pyContrReader import pyExportReader as pyER
from PyDSS import unitDefinations
from PyDSS.exceptions im... | pd.MultiIndex.from_tuples(tuples, names=['timestamp', 'frequency', 'Simulation mode']) | pandas.MultiIndex.from_tuples |
import json
import pytest
import numpy as np
import pandas as pd
import scipy.spatial.distance as scipy_distance
from whatlies import Embedding, EmbeddingSet
from .common import validate_plot_general_properties
"""
*Guide*
Here are the plot's propertites which could be checked (some of them may not be applicable
f... | pd.DataFrame(chart["datasets"][chart["data"]["name"]]) | pandas.DataFrame |
# Title: Sensor Reading Output
# Description: Pulls sensor readings data from the databases
# and outputs to a CSV file for analysis
# Author: <NAME>
# Date: 30/03/2021
# Import libraries
#import sys
import pandas as pd
import numpy as np
import os
#import traceback
import datetime
import pyodbc
#import re
from... | pd.DataFrame() | pandas.DataFrame |
import codecs
import math
import os
import re
import gensim
import jieba.posseg as jieba
import numpy as np
import pandas as pd
from sklearn.cluster import KMeans
# 返回特征词向量
def getWordVecs(wordList, model):
name = []
vecs = []
for word in wordList:
word = word.replace('\n', '')
try:
... | pd.read_csv(dataFile) | pandas.read_csv |
# Copyright 2019 Elasticsearch BV
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicabl... | pd.DataFrame() | pandas.DataFrame |
from xlsx_writer import dataframes_to_xlsx
import os
import pandas as pd
import tempfile
def test_datasets_to_xlsx():
output_file_name = 'sample_test.xlsx'
tmp_output_dir = tempfile.TemporaryDirectory(dir='.')
output_file = os.path.join(tmp_output_dir.name, output_file_name)
df1 = | pd.DataFrame({'dfId': [1], 'gender': ['M'], 'birthdate': ['1953/10/5']}) | pandas.DataFrame |
# -*- coding: utf-8 -*-
"""
Tests for Results.predict
"""
import numpy as np
import pandas as pd
from numpy.testing import assert_allclose, assert_equal
import pandas.util.testing as pdt
from statsmodels.regression.linear_model import OLS
from statsmodels.genmod.generalized_linear_model import GLM
class CheckPredi... | pdt.assert_index_equal(pred.index, fitted.index) | pandas.util.testing.assert_index_equal |
##Script to consolidate output from corrected MIGMAP alignments into consensus CDR3s for cells, B Cells
#<NAME>, 5/24/15
##---NOTES----
#1. Run in the directory of the corrected aligned reads, ie the tab delimited corected aligned files
#!/usr/bin/python # 2.7.14
import os
import collections
import glob
import pand... | pd.Series(['No Consensus'], index=['v']) | pandas.Series |
#!/usr/bin/env python
__author__ = "<NAME>"
import logging
import os
import re
import pandas
import numpy
import gzip
from timeit import default_timer as timer
from pyarrow import parquet as pq
from genomic_tools_lib import Logging, Utilities
from genomic_tools_lib.data_management import TextFileTools
from genomic_t... | pandas.DataFrame(cov) | pandas.DataFrame |
"""Functions to noise components based on selected strategey."""
import numpy as np
import pandas as pd
from .load_confounds_utils import (_add_suffix,
_check_params,
_find_confounds)
from .load_confounds_compcor import _find_compcor
from .load_conf... | pd.DataFrame() | pandas.DataFrame |
"""Version the GTFS by changing all the Id of each table."""
import logging
import pandas as pd
import utilities.pandas_tools as pt
from utilities.decorator import logged
from mixer.glogger import logger
class Model(object):
"""Transform Id of each entitie into sha1."""
def __init__(self, dict... | pd.merge(vstops, stops, on="StopScheduleId") | pandas.merge |
import uuid
import numpy as np
import pandas as pd
from irspack.split import split_last_n_interaction_df
RNS = np.random.RandomState(0)
n_users = 1000
n_items = 512
df_size = 10000
user_ids = np.asarray([str(uuid.uuid1()) for _ in range(n_users)])
item_ids = np.asarray([str(uuid.uuid1()) for _ in range(n_items)])
... | pd.concat([df_train, df_val]) | pandas.concat |
#!/usr/bin/env python3
"""
Correct bed file to be compatible with bedToBigBed tool.
1.) restrict all scores to the maximal value of 1000,
2.) in strand column replace '?' with '.'.
"""
import argparse
import pandas as pd
from pandas.errors import EmptyDataError
from resolwe_runtime_utils import error
parser... | pd.to_numeric(df.iloc[:, 4]) | pandas.to_numeric |
# pylint: disable-msg=E1101,W0612
from datetime import datetime, time, timedelta, date
import sys
import os
import operator
from distutils.version import LooseVersion
import nose
import numpy as np
randn = np.random.randn
from pandas import (Index, Series, TimeSeries, DataFrame,
isnull, date_ran... | assert_series_equal(result, expected) | pandas.util.testing.assert_series_equal |
import pandas as pd
import pytest
from pandas.testing import assert_frame_equal, assert_series_equal
from application import model_builder
def test_validate_types_numeric_success():
# Arrange
df = | pd.DataFrame() | pandas.DataFrame |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.