prompt stringlengths 19 1.03M | completion stringlengths 4 2.12k | api stringlengths 8 90 |
|---|---|---|
import numpy as np
import pytest
import pandas as pd
from pandas import (
DataFrame,
lreshape,
melt,
wide_to_long,
)
import pandas._testing as tm
class TestMelt:
def setup_method(self, method):
self.df = tm.makeTimeDataFrame()[:10]
self.df["id1"] = (self.df["A"] > 0).astype(np.int... | tm.assert_frame_equal(result, expected) | pandas._testing.assert_frame_equal |
# -*- coding: utf-8 -*-
'''
Created on Mon Sep 28 16:26:09 2015
@author: r4dat
'''
# ICD9 procs from NHSN definition.
# Diabetes diagnoses from AHRQ version 5 SAS program, CMBFQI32.TXT
# sample string generator print((','.join(map(str, [str(x) for x in range(25040,25094)]))).replace(',','","'))
#
# "25000"-"250... | pd.to_datetime(col14['admitdate']) | pandas.to_datetime |
"""
This script uses the slack users.list endpoint to pull
all users.
Refer to https://api.slack.com/methods/users.list
"""
import os
import logging
import pandas as pd
from slack_sdk import WebClient # Import WebClient from Python SDK (github.com/slackapi/python-slack-sdk)
"""
FUNCTIONS
"""
def connect(api_token)... | pd.DataFrame(user_list) | pandas.DataFrame |
# -*- coding: utf-8 -*-
"""
Directory structure of training
The network directory is the root of the structure and is typically in
_ibeis_cache/nets for ibeis databases. Otherwise it it custom defined (like in
.cache/wbia_cnn/training for mnist tests)
# era=(group of epochs)
Datasets contain ingested data packed int... | pd.Series(data_idx, name='data_idx') | pandas.Series |
# -*- coding: utf-8 -*-
"""
Created on Sat Jan 13 22:45:00 2018
@author: benmo
"""
import pandas as pd, numpy as np, dask.dataframe as ddf
import quandl
import sys, os, socket
import pickle
from dask import delayed
from difflib import SequenceMatcher
from matplotlib.dates import bytespdate2num, num2date
from matplotl... | pd.read_pickle(pth) | pandas.read_pickle |
from pandas import DataFrame
from requests.models import HTTPError
import pandas as pd
import tmdbsimple as tmdb
import json
flatten = lambda l: [item for sublist in l for item in sublist]
def create_actors_dataframe(credits_df, save_path=None, actor_id=None):
"""Create the dataframe of actors present in the tmd... | pd.DataFrame(actors) | pandas.DataFrame |
import cv2
import pickle
import numpy as np
import os
import pandas as pd
import matplotlib.pyplot as plt
from skimage.feature import hog
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
from sklearn.preprocessing import StandardScaler
from sklearn.decomposition import PCA... | pd.read_csv(DSPath + "data.csv", index_col=0) | pandas.read_csv |
import numpy as np
import pandas as pd
import allel
import matplotlib.pyplot as plt
from sklearn.decomposition import PCA
vcf = allel.read_vcf("../../data/raw/1349 sample and all 253k unfiltered SNPs.vcf", )
variants = np.char.array(vcf["variants/CHROM"].astype(str)) + ":" + np.char.array(vcf["variants/POS"].astype(st... | pd.Index(['55062', '56104', '34903', '16820', '41060', '54687', '44119', '48523',
'33287', '14947', '21560', '87483', '42335', '30146', '28289', '40007']) | pandas.Index |
"""
A warehouse for constant values required to initilize the PUDL Database.
This constants module stores and organizes a bunch of constant values which are
used throughout PUDL to populate static lists within the data packages or for
data cleaning purposes.
"""
import pandas as pd
import sqlalchemy as sa
##########... | pd.StringDtype() | pandas.StringDtype |
# Quantile utilities for processing MERRA/AIRS data
import numpy
import numpy.ma as ma
import calculate_VPD
import netCDF4
from netCDF4 import Dataset
from numpy import random, linalg
import datetime
import pandas
import os, sys
from scipy import stats
import h5py
def quantile_cloud_locmask(airsdr, mtdr, indr, dtdr,... | pandas.DataFrame(data=dtout,columns=varlstout) | pandas.DataFrame |
import pandas as pd
import numpy as np
import nltk
import multiprocessing
import difflib
import time
import gc
import xgboost as xgb
import category_encoders as ce
import itertools
from collections import Counter
from sklearn.metrics import log_loss
from sklearn.cross_validation import train_test_split
def labelcou... | pd.DataFrame() | pandas.DataFrame |
import pandas as pd
import matplotlib.pyplot as plt
#plt.rcParams['animation.ffmpeg_path'] = '/Users/alejandrosusillo/opt/anaconda3/lib/python3.7/site-packages/ffmpeg'
import seaborn as sns
import numpy as np
import io
import matplotlib.animation as animation
from pandas.plotting import register_matplotlib_converters... | pd.to_datetime(aux['Fecha']) | pandas.to_datetime |
# coding=utf-8
# pylint: disable-msg=E1101,W0612
from datetime import datetime, timedelta
import operator
from itertools import product, starmap
from numpy import nan, inf
import numpy as np
import pandas as pd
from pandas import (Index, Series, DataFrame, isnull, bdate_range,
NaT, date_range, ti... | assert_series_equal(res, expected) | pandas.util.testing.assert_series_equal |
import pandas as pd
from typing import Union, Any, Tuple
import os
import subprocess
import zarr
import xarray as xr
import numpy as np
from satpy import Scene
from pathlib import Path
import datetime
from satip.geospatial import lat_lon_to_osgb, GEOGRAPHIC_BOUNDS
from satip.compression import Compressor, is_dataset_... | pd.Timestamp(dataset.attrs["end_time"]) | pandas.Timestamp |
# -*- coding: utf-8 -*-
"""
Created on Fri Sep 7 16:54:46 2018
@author: xiaoyang
"""
import requests
from bs4 import BeautifulSoup
import pandas as pd
from ast import literal_eval
class PriceOfCrudeOil(object):
# 得到原油现货价格
def get_latest_data(self):
df = self.get_latest_month_data()
... | pd.DataFrame(columns=['收盘', '开盘', '高', '低', '涨跌']) | pandas.DataFrame |
import pandas as pd
from pandas import Timestamp
import numpy as np
import pytest
import niimpy
from niimpy.util import TZ
df11 = pd.DataFrame(
{"user": ['wAzQNrdKZZax']*3 + ['Afxzi7oI0yyp']*3 + ['lb983ODxEFUD']*3,
"device": ['iMTB2alwYk1B']*3 + ['3Zkk0bhWmyny']*3 + ['n8rndM6J5_4B']*3,
"time"... | Timestamp('2019-01-17 09:20:14.049999872+02:00') | pandas.Timestamp |
import re
import numpy as np
import pytest
from pandas import Categorical, CategoricalIndex, DataFrame, Index, Series
import pandas._testing as tm
from pandas.core.arrays.categorical import recode_for_categories
from pandas.tests.arrays.categorical.common import TestCategorical
class TestCategoricalAPI:
... | Index([4, 3, 2, 1]) | pandas.Index |
import os
from posixpath import join
import re
import math
import random
import pickle
from typing import ByteString
from pandas.core import base
import librosa
import numpy as np
import pandas as pd
from tqdm import tqdm
import soundfile as sf
from sklearn.model_selection import train_test_split
from sklearn.preproce... | pd.read_csv(labels_path) | pandas.read_csv |
import pytest
import pandas as pd
import numpy as np
@pytest.fixture(scope="function")
def set_helpers(request):
rand = np.random.RandomState(1337)
request.cls.ser_length = 120
request.cls.window = 12
request.cls.returns = pd.Series(
rand.randn(1, 120)[0] / 100.0,
index=pd.date_range(... | pd.date_range("2000-1-30", periods=1000, freq="D", tz="UTC") | pandas.date_range |
from unittest.mock import MagicMock
import pandas as pd
import pytest
from click.testing import CliRunner
from pytest_mock import MockerFixture
from nlpland import cli
df_filtered = pd.DataFrame({"AA url": ["a"]})
df_full = pd.DataFrame({"AA url": ["a", "b"]})
@pytest.fixture
def filtered(mocker: MockerFixture) ->... | pd.DataFrame({"AA url": ["b"]}) | pandas.DataFrame |
import click
import sys
import pandas as pd
import math
import subprocess
import logging
import os
import re
from datetime import datetime
from distutils.dir_util import copy_tree
##########################################################################
#
# Initialize globals
#
###################... | pd.merge(starts_new,ends_new,how='inner', on=['name'], suffixes=['_s', '_e']) | pandas.merge |
# Quantify the dots to select the best quantifitcation
# Will take mid pixel, mid 9 pixels and mic 25 pixels and divide them by the corners.
# bsub -q short -W 4:00 -R "rusage[mem=50000]" -oo multiple_dot_lists_quantify_corners_HFF_mean_density.out -eo multiple_dot_lists_quantify_corners_HFF_mean_density.err 'python m... | pd.read_table(exp_paths[cond]) | pandas.read_table |
__description__ = \
"""
Helper code for converting raw values from plate reader into fluorescence
anisotropy binding experiments.
"""
__author__ = "<NAME>"
__date__ = "2020-09-01"
from matplotlib import pyplot as plt
import numpy as np
import pandas as pd
import scipy.optimize
import re
def calculate_r(vv,vh,G=1.0):... | pd.DataFrame(out_dict) | pandas.DataFrame |
import pandas as pd
def find_timegaps(series, gap, gap_comparison='higher', divergent_only=False):
"""
Find time gaps in the datetime series in input according to the gap size
checked using the operator specified.
The type of comparison along with the gap size define what gaps will be
flagged. If t... | pd.Timedelta(gap) | pandas.Timedelta |
from datetime import datetime
import pytest
from pytz import utc
import pandas._testing as tm
from pandas.tseries.holiday import (
MO,
SA,
AbstractHolidayCalendar,
DateOffset,
EasterMonday,
GoodFriday,
Holiday,
HolidayCalendarFactory,
Timestamp,
USColumbusDay,... | Timestamp("2001-07-03 00:00:00") | pandas.tseries.holiday.Timestamp |
# -*- coding: utf-8 -*-
from typing import Optional, Union
import pandas as pd
import typic
from standard_precip.spi import SPI
from tstoolbox import tsutils
def _nlarge_nsmall(pe_data, nlargest, nsmallest, groupby):
if nlargest is None and nsmallest is None:
return pe_data
nlarge = pd.Series()
... | pd.date_range(start=nlarge.index[0], end=nlarge.index[-1], freq="D") | pandas.date_range |
import numpy as np
import re as re
from scipy import stats
import gnc
import netCDF4 as nc
import copy as pcopy
import pdb
import pb
import pandas as pa
def Dic_DataFrame_to_Excel(excel_file,dic_df,multisheet=False,keyname=True,na_rep='', cols=None, header=True, index=True, index_label=None):
"""
Write a dicti... | pa.concat(df_list) | pandas.concat |
from Kernel import Kernel
from agent.ExchangeAgent import ExchangeAgent
from agent.HeuristicBeliefLearningAgent import HeuristicBeliefLearningAgent
from agent.examples.ImpactAgent import ImpactAgent
from agent.ZeroIntelligenceAgent import ZeroIntelligenceAgent
from util.order import LimitOrder
from util.oracle.MeanReve... | pd.to_timedelta('09:30:00') | pandas.to_timedelta |
from datetime import datetime, timedelta
import numpy as np
import pytest
from pandas._libs.tslibs import period as libperiod
import pandas as pd
from pandas import DatetimeIndex, Period, PeriodIndex, Series, notna, period_range
import pandas._testing as tm
class TestGetItem:
def test_ellipsis(self):
#... | pd.PeriodIndex([p1, p2, p1]) | pandas.PeriodIndex |
import pandas as pd
from flask import current_app
def venn_diagram_join(df1, df2):
# Calculates the join between two dataframes like a Venn diagram
#
# Join criteria is all columns in common between them.
# Returns which rows are rows are only present in the left, which overlap,
# and which are on... | pd.DataFrame(columns=pdp_contacts_df.columns) | pandas.DataFrame |
import numpy as np
import pandas as pd
import tqdm
from . import algorithm
from . import loss
from . import utils
try:
import tensorflow as tf
except:
import warnings
warnings.warn("`import tensorflow as tf` returns an error: gradient.py won't work.")
class GradientAlgorithm(algorithm.Algorithm):
... | pd.concat((self.explainer.data, _data_changed)) | pandas.concat |
from __future__ import division
from functools import partial
import gc
from multiprocessing import Pool
from operator import attrgetter
from typing import List, Optional, Tuple
from functional import pipe
import numpy as np
import pandas as pd
from sklearn.base import clone
from spdivik.distance import DistanceMetri... | pd.DataFrame(data) | pandas.DataFrame |
import os
import pandas as pd
from sklearn import metrics, svm
from sklearn.model_selection import train_test_split
# read data and create dataframes
length = 3100
coord_list = ['all', 'x', 'y', 'z']
# create global variables to store x,y,z and xyz data
for i in range(4):
globals()[f'df_UR5_{coord_list[i]}'] = p... | pd.read_csv(f"{home}/{folder}/{file}") | pandas.read_csv |
"""
Generate a report that specifies number of contents created in last week and overall across Live, Review and Draft.
"""
import sys, time
import os
import requests
import pandas as pd
from datetime import date, timedelta, datetime
from pathlib import Path
from string import Template
from time import sleep
from dat... | pd.DataFrame(tenant_list) | pandas.DataFrame |
# -*- coding: utf-8 -*-
'''
:author <NAME>
:licence MIT
'''
import pandas as pd
import time
def raw2meta_extract(fn):
"""
Reasds raw2 files including GPS and enginerring information
Parameters
----------
fn : string
Path and filenmae of *.raw2 file
Returns
-------
data : pandas DataFrame
CTD (Salinity, ... | pd.DataFrame(gps1_raw) | pandas.DataFrame |
import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
#Importing individual user data
user_1 = pd.read_csv('User_1.csv')
user_2 = | pd.read_csv('User_2.csv') | pandas.read_csv |
import h5py
import scipy.stats as st
from collections import defaultdict
import numpy as np
import pandas as pd
import copy
import lasagne
filename_whas = "data/whas/whas_train_test.h5"
filename_metabric = "data/metabric/metabric_IHC4_clinical_train_test.h5"
filename = filename_whas
datasets = defaultdict(dict)
with... | pd.concat([time, status, covariates], axis=1) | pandas.concat |
import copy
import logging
import os
import sys
from pathlib import Path
from typing import Tuple
import pandas as pd
import pytest
from simod.common_routines import compute_sequence_flow_frequencies, mine_gateway_probabilities_alternative, \
mine_gateway_probabilities_alternative_with_gateway_management
from sim... | pd.DataFrame(train) | pandas.DataFrame |
__author__ = '<NAME>'
from opengrid_dev.config import Config
config = Config()
import os
import sys
import json
import jsonpickle
import datetime as dt
import pandas as pd
from requests.exceptions import HTTPError
import warnings
from tqdm import tqdm
# compatibility with py3
if sys.version_info.major >= 3:
imp... | pd.concat(series, axis=1) | pandas.concat |
import os
import logging
import time
from pathlib import Path
import requests
import re
from concurrent import futures
import pandas as pd
from tqdm import tqdm
from build_eodhd_map import MAP_YAHOO, MAP_EODHD
_logger = logging.getLogger(__name__)
# Read eodhistoricaldata.com token fron environment -- or insert int... | pd.read_pickle(filename) | pandas.read_pickle |
"""Scraping and parsing amazon"""
__author__ = 'thor'
import os
from ut.util.importing import get_environment_variable
import ut as ms
import ut.dacc.mong.util
import pandas as pd
import numpy as np
import requests
import re
from BeautifulSoup import BeautifulSoup as bs3_BeautifulSoup
from datetime import timedelta
fr... | pd.DataFrame() | pandas.DataFrame |
import sys
import click
import pandas as pd
import numpy as np
def make_df(file, label):
df = | pd.read_csv(file) | pandas.read_csv |
import pandas as pd
from ..utils import constants, plot, utils
import numpy as np
from warnings import warn
from shapely.geometry import Polygon, Point
import geopandas as gpd
from .flowdataframe import FlowDataFrame
from skmob.preprocessing import routing
class TrajSeries(pd.Series):
@property
def _construc... | pd.core.dtypes.common.is_float_dtype(frame[constants.LONGITUDE].dtype) | pandas.core.dtypes.common.is_float_dtype |
import requests
import json
import pandas as pd
import numpy as np
import datetime as dt
import psycopg2 as pg
import pymongo as pm
import os
import eod_api
api = eod_api.api
e_date = (dt.datetime.now() - dt.timedelta(1)).strftime('%Y-%m-%d')
error_log = []
def get_db_exchanges():
con = pg.connect(database... | pd.DataFrame() | pandas.DataFrame |
import pandas as pd
import sys
import glob
import os
import re
import numpy as np
import logging
logging.basicConfig(stream=sys.stdout,
level=logging.INFO,
format='[%(asctime)s] %(message)s',
datefmt='%Y/%m/%d %H:%M:%S')
#inside pathx (MD)
def time_freq_fi... | pd.read_csv(filex) | pandas.read_csv |
import pandas as pd
import xgboost as xgb
from sklearn.preprocessing import OneHotEncoder
from sklearn.preprocessing import LabelEncoder
import numpy as np
from sklearn import metrics
pd.set_option('display.max_columns', None)
train = | pd.read_csv('./data/train.csv') | pandas.read_csv |
from numpy.fft import fft
import pickle_compat
pickle_compat.patch()
import pandas as pd
from sklearn import metrics
import pickle
import numpy as np
from sklearn import svm
from sklearn.model_selection import train_test_split
from sklearn.decomposition import PCA
from datetime import timedelta as td
Raw_CGMData1=pd... | pd.read_csv('Insulin_patient2.csv', low_memory=False) | pandas.read_csv |
import os
from pathlib import Path
import dotenv
import pandas as pd
import numpy as np
from sklearn.metrics import roc_auc_score
project_dir = Path(__file__).resolve().parents[2]
dotenv_path = project_dir / ".env"
dotenv.load_dotenv(str(dotenv_path))
path_clinical_info = Path(os.environ["CLINIC_INFO_PATH"])
# model... | pd.concat([clinical_df, volume_df], axis=1) | pandas.concat |
# -*- coding: utf-8 -*-
import io
import os
import sys
import copy
import json
import pickle
import random
import hashlib
import warnings
import threading
import concurrent.futures
import numpy as np
import pandas as pd
import plyvel
import requests
from PIL import Image
from tqdm import tqdm
from loguru import logger... | pd.read_csv(filename, index_col=["route_id"]) | pandas.read_csv |
import numpy as np
import keras
import tensorflow as tf
from matplotlib import pyplot as plt
import pandas as pd
from keras.layers.embeddings import Embedding
from keras.layers import concatenate, Lambda
import os, sys
from weather_model import Seq2Seq_MVE_subnets_swish, weather_conv1D, CausalCNN, RNN_builder, Seq2Seq... | pd.concat([series_targets, series_target]) | pandas.concat |
import pandas as pd
import pytest
import numpy as np
import dask.dataframe as dd
from dask.dataframe.utils import assert_eq
from dask.utils import ignoring
def mad(x):
return np.fabs(x - x.mean()).mean()
def rolling_functions_tests(p, d):
# Old-fashioned rolling API
assert_eq(pd.rolling_count(p, 3), dd... | pd.rolling_window(p, 3, 'boxcar') | pandas.rolling_window |
import bz2
import gzip
import lzma
import os
import re
import numpy as np
import pandas as pd
import xarray as xr
def untransform_varnames(varnames):
"""Map transformed variable names back to their originals.
Mainly useful for dealing with PyMC3 traces.
Example
-------
untransform_varnames(['et... | pd.read_csv(filepath, index_col=0, compression=ext) | pandas.read_csv |
"""Download the network from Netzschleuder:
https://networks.skewed.de
"""
import sys
import graph_tool.all as gt
import numpy as np
# %%
import pandas as pd
from scipy import sparse
from scipy.sparse.csgraph import connected_components
if "snakemake" in sys.modules:
net_name = snakemake.params["net_name"]
... | pd.DataFrame({"src": r, "trg": c}) | pandas.DataFrame |
"""
MIT License
Copyright (c) 2019 <NAME>
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distri... | pd.read_csv("../notebooks/data/auto-mpg.csv") | pandas.read_csv |
from pandas import read_csv,pivot_table,Series,to_numeric,concat
import sys
import json
import math
import os
import csv
import numpy as np
save_path = './'
class gen():
def __init__(self,uploads):
self.do(uploads)
def do(self,uploads):
self.Das=datas()
for upload in uploads:
... | read_csv(filename,sep=sep,header=None,encoding='latin_1',skiprows=3,skipinitialspace=True) | pandas.read_csv |
import re
import numpy as np
import pytest
from pandas import Categorical, CategoricalIndex, DataFrame, Index, Series
import pandas._testing as tm
from pandas.core.arrays.categorical import recode_for_categories
from pandas.tests.arrays.categorical.common import TestCategorical
class TestCategoricalAPI:
... | Index(["a", "b", "c", "d"]) | pandas.Index |
#!/usr/bin/env python
"""Tests for `openml_speed_dating_pipeline_steps` package."""
import unittest
from sklearn import datasets
import numpy as np
import pandas as pd
from pandas.api.types import is_numeric_dtype
from openml_speed_dating_pipeline_steps import (
openml_speed_dating_pipeline_steps
as pipelin... | is_numeric_dtype(transformed[col]) | pandas.api.types.is_numeric_dtype |
import time
import datetime
# import geojson
# import eventlet
import pandas as pd
import geopandas as gpd
from shapely.geometry import LineString
from typing import Optional
from pathlib import Path
from src.python_plots.plot_classes import PyPlot
from multiprocessing import Manager
from abc import ABCMeta, abstractm... | pd.read_csv(fleet_stat_f) | pandas.read_csv |
import os
from datetime import datetime
import pandas as pd
def import_raw(start_date,end_date,data_dir="../../../bleed-orange-measure-purple/data/raw/purpleair/",**kwargs):
"""
Imports the raw data from each device
Inputs:
- start_date: datetime corresponding to the file of interest
- end... | pd.DataFrame() | pandas.DataFrame |
import datetime
import numpy as np
import pandas as pd
from src.utils import update_dati,\
convert_date
lista_inquinanti = ['BENZENE', 'CO', 'NO2', 'NOX', 'NO', 'O3', 'PM10', 'PM2.5', 'SO2']
base_url_anno_corrente = 'http://www.arpalazio.net/main/aria/sci/annoincorso/chimici/RM/DatiOrari/RM... | pd.concat([old_df, df_final]) | pandas.concat |
__author__ = '<NAME>'
__email__ = '<EMAIL>'
__status__ = 'Development'
import numpy as np
import pandas as pd
import random
import math
from scipy.spatial.distance import cdist
from sklearn import metrics
from sklearn.cluster import KMeans
from sklearn.cluster import DBSCAN
from progress.bar import Bar
# read hillsl... | pd.DataFrame() | pandas.DataFrame |
# EIA_CBECS_Land.py (flowsa)
# !/usr/bin/env python3
# coding=utf-8
"""
2012 Commercial Buildings Energy Consumption Survey (CBECS)
https://www.eia.gov/consumption/commercial/reports/2012/energyusage/index.php
Last updated: Monday, August 17, 2020
"""
import io
import pandas as pd
import numpy as np
from flowsa.locati... | pd.DataFrame(df_raw_data[4:5]) | pandas.DataFrame |
#!/usr/bin/env python3
"""
Authors: <NAME>, <NAME>
Functionality implemented:
- Generates and aggregates polarities across headlines and conversations
"""
# Libraries and Dependencies
import os
from nltk.sentiment.vader import SentimentIntensityAnalyzer
import pandas as pd
from nltk.stem import WordNetLemmatizer
impo... | pd.read_csv('setup_csvs/polarized_stock_lex.csv') | pandas.read_csv |
from context import dero
import pandas as pd
from pandas.util.testing import assert_frame_equal
from pandas import Timestamp
from numpy import nan
import numpy
class DataFrameTest:
df = pd.DataFrame([
(10516, 'a', '1/1/2000', 1.01),
(10516, 'a'... | Timestamp('2000-01-25 00:00:00') | pandas.Timestamp |
#
# Collective Knowledge ()
#
#
#
#
# Developer:
#
cfg={} # Will be updated by CK (meta description of this module)
work={} # Will be updated by CK (temporal data)
ck=None # Will be updated by CK (initialized CK kernel)
import os
import sys
import time
import pandas as pd
import numpy as np
#default_repo_uoa = ''
... | pd.concat(dfs) | pandas.concat |
import pandas as pd
import toml
from bs4 import BeautifulSoup
import requests
# from rich import print_json
from pathlib import Path, PosixPath
from openpyxl import load_workbook
import xlrd
import zipfile
import itertools
import os
from loguru import logger
OTHER_VARS_TO_STORE = ["long_name", "code", "short_name", "m... | pd.to_numeric(x["value"]) | pandas.to_numeric |
# -*- coding: utf-8 -*-
import datetime as dt, IPython, pandas as pd, pyarrow as pa, pytest, requests, unittest
from builtins import object
from common import NoAuthTestCase
import graphistry
from mock import patch
triangleEdges = pd.DataFrame({'src': ['a', 'b', 'c'], 'dst': ['b', 'c', 'a']})
triangleNodes = pd.Da... | pd.DataFrame([]) | pandas.DataFrame |
import logging, matplotlib, os, sys, glob
import scanpy as sc
import matplotlib.pyplot as plt
from matplotlib import rcParams
from matplotlib import colors
import pandas as pd
from glbase3 import genelist
plt.rcParams['figure.figsize']=(8,8)
sc.settings.verbosity = 3
sc.set_figure_params(dpi=200, dpi_save=200)
matplotl... | pd.DataFrame(adata.uns['rank_genes_groups']['names']) | pandas.DataFrame |
import copy
import logging
import math
import random
import warnings
from typing import List, Tuple
import numpy as np
import pandas as pd
import torch
logger = logging.getLogger()
EXPL_LENGTHS_TRAIN_20 = [(1, 208),
(2, 299),
(3, 354),
(4, 37... | pd.read_csv(path, sep='\t', dtype=str) | pandas.read_csv |
import os
import time
import json
import numpy as np
import pandas as pd
import torch
from hydroDL import kPath
from hydroDL.app import waterQuality
from hydroDL.model import rnn, crit
caseName = 'refBasins'
ratioTrain = 0.8
rho = 365
batchSize = 100
nEpoch = 100
hiddenSize = 64
modelFolder = os.path.join(kPath.dirWQ... | pd.DataFrame(data=y, columns=varC) | pandas.DataFrame |
#!/usr/bin/env python
"""
Compute CCF of a list of observed spectra with a weighted binary mask.
"""
from __future__ import division
from __future__ import print_function
import argparse
import os
import sys
import textwrap
import ipdb
import matplotlib as mpl
import matplotlib.pyplot as plt
import numpy as np
import... | pd.DataFrame({'timeid': listimeid}, index=lisfilobs) | pandas.DataFrame |
import pandas as pd
from pandas.io.json import json_normalize
import requests
import backoff
ticker_df = | pd.read_csv('djia_symbols.csv') | pandas.read_csv |
import pdb
import unittest
import torch
import pandas as pd
import numpy as np
from agents.SACAgent import SACAgent
from cobs.model import Model
from test.test_config import state_name, sac_network_map, eplus_naming_dict, eplus_var_types, \
SatAction, BlindActionSingleZone, ThermActionSin... | pd.read_csv('test/agent_tests/saved_results/sac_no_blinds_obs.csv') | pandas.read_csv |
# pylint: disable-msg=E1101,W0612
from datetime import datetime, timedelta
import os
import operator
import unittest
import cStringIO as StringIO
import nose
from numpy import nan
import numpy as np
import numpy.ma as ma
from pandas import Index, Series, TimeSeries, DataFrame, isnull, notnull
from pandas.core.index... | assert_series_equal(hist, expected) | pandas.util.testing.assert_series_equal |
# Author: <NAME>
import itertools, glob, re
from functools import reduce
from operator import add
import pandas as pd
shared = '/home/berkeleylab/Model/storage'
# Maintain total_iters.txt to store iteration count info, also is it required since we are saving file names with iter count?
def initializers(what_type, wh... | pd.concat([prior_df, post_df], ignore_index=True) | pandas.concat |
import json
import io
import plotly.graph_objects as go
from plotly.subplots import make_subplots
import dash
from dash import html
from dash import dcc
import dash_bootstrap_components as dbc
import pandas as pd
import numpy as np
import plotly.express as px
from dash.dependencies import Output, Input, State
from date... | pd.DataFrame(mean_data + 2 * std_data, columns=['num']) | pandas.DataFrame |
import pandas as pd
import re
from scipy.sparse import csr_matrix
ratings = pd.read_csv("./data/ml-latest-small/ratings.csv")
movies = | pd.read_csv("./data/ml-latest-small/movies.csv") | pandas.read_csv |
import csv
import logging
import os
import tempfile
import time
from hashlib import sha256
from ipaddress import IPv4Address, ip_address
from pathlib import Path
from typing import Dict, List, Optional, Tuple, Union
import numpy as np
import pandas as pd
from imblearn.under_sampling import RandomUnderSampler
from pand... | is_string_dtype(pandas_data_type) | pandas.api.types.is_string_dtype |
import os
from datetime import date
from dask.dataframe import DataFrame as DaskDataFrame
from numpy import nan, ndarray
from numpy.testing import assert_allclose, assert_array_equal
from pandas import DataFrame, Series, Timedelta, Timestamp
from pandas.testing import assert_frame_equal, assert_series_equal
from pymo... | Timestamp('2008-10-23 05:53:11') | pandas.Timestamp |
import sys
import boto3
import re
from uuid import UUID
import pandas as pd
from datetime import date, timedelta
from tabulate import tabulate
def is_email_address(string):
return re.match(r"[^@]+@[^@]+\.[^@]+", string)
def is_uuid(uuid_to_test, version=4):
try:
uuid_obj = UUID(uuid_to_test, version... | pd.DataFrame(flat_user_cognito_data, index=[0]) | pandas.DataFrame |
"""
@brief test log(time=6s)
"""
import sys
import unittest
from logging import getLogger
import numpy
import pandas
from pyquickhelper.pycode import ExtTestCase, skipif_circleci, ignore_warnings
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from skl2onnx.common.data_t... | pandas.DataFrame(got['output_probability']) | pandas.DataFrame |
#!/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
... | numeric(temp_df["昨收价"], errors="coerce") | pandas.to_numeric |
import os
import sys
import re
import json
import yaml
import pandas as pd
import numpy as np
sys.path.append('../')
from load_paths import load_box_paths
try:
print(Location)
except NameError:
if os.name == "posix":
Location = "NUCLUSTER"
else:
Location = "Local"
datapath, projectpath, w... | pd.Timedelta(2,"days") | pandas.Timedelta |
import pickle
import random
import string
import warnings
import numpy as np
from numpy.testing import assert_allclose
import pandas as pd
import pytest
from scipy import stats
import linearmodels
from linearmodels.shared.exceptions import missing_warning
from linearmodels.shared.hypotheses import (
InapplicableT... | pd.testing.assert_frame_equal(df3, expected3) | pandas.testing.assert_frame_equal |
import numpy as np
import pandas as pd
import sys
from tqdm import tqdm
import h5py
from sklearn.metrics.pairwise import cosine_similarity
import pkg_resources
import re
import itertools
import os
import matplotlib.pyplot as plt
from sys import stdout ### GET rid of later
from .context import context_composite, contex... | pd.read_csv(x, sep='\t', index_col=0) | pandas.read_csv |
import random
import numpy as np
import pandas as pd
def remove_unlinked_triples(triples, linked_ents):
print("before removing unlinked triples:", len(triples))
new_triples = set()
for h, r, t in triples:
if h in linked_ents and t in linked_ents:
new_triples.add((h, r, t))
print("... | pd.merge(triple_df, triple_df, left_on='t', right_on='h') | pandas.merge |
import numpy as np
import pandas as pd
import hashlib
from pathlib import Path
from biom import parse_table
from biom import Table as BiomTable
from omicexperiment.util import parse_fasta, parse_fastq
def load_biom(biom_filepath):
with open(biom_filepath) as f:
t = parse_table(f)
return t
def is_bio... | pd.DataFrame(observation_to_otu_dict, index=observation_list) | pandas.DataFrame |
import numpy as np
import pandas as pd
from aif360.datasets import BinaryLabelDataset
from aif360.datasets.multiclass_label_dataset import MulticlassLabelDataset
from aif360.metrics import ClassificationMetric
def test_generalized_entropy_index():
data = np.array([[0, 1],
[0, 0],
... | pd.DataFrame(data, columns=['feat', 'label']) | pandas.DataFrame |
#tusr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Wed Jul 25 17:13:22 2018
@author: kitreatakataglushkoff
Kitrea's hand-written copied/adjusted version of the analyze_massredistribution.py,
which was last significantly edited Thursday July 18.
UPDATE - Oct 9, 2018 - Kitrea double-checked code, added some... | pd.read_csv(binnedcsv_fullfn) | pandas.read_csv |
from datetime import datetime
import numpy as np
import pandas as pd
import pytest
from numba import njit
import vectorbt as vbt
from tests.utils import record_arrays_close
from vectorbt.generic.enums import range_dt, drawdown_dt
from vectorbt.portfolio.enums import order_dt, trade_dt, log_dt
day_dt = np.timedelta64... | pd.Timedelta('1 days 00:00:00') | pandas.Timedelta |
# coding=utf-8
import collections
import pandas as pd
import tensorflow as tf
import _pickle as pickle
from absl import logging
from transformers import BertTokenizer
LABELS = []
class InputExample(object):
def __init__(self, text=None, labels=None):
# List of tokens
self.text = text
# ... | pd.DataFrame.from_dict(dataset) | pandas.DataFrame.from_dict |
# -*- coding: utf-8 -*-
"""
This module is EXPERIMENTAL, that means that tests are missing.
The reason is that the coastdat2 dataset is deprecated and will be replaced by
the OpenFred dataset from Helmholtz-Zentrum Geesthacht. It should work though.
This module is designed for the use with the coastdat2 weather data ... | pd.Series(coastdat_keys) | pandas.Series |
import re
import os
import pandas as pd
import numpy as np
def readRuns(parallel_runs_harddisk, time_step, NO_ITERATIONS):
"""
Read eplusmtr files in a folder and combine them in one dataframe, formatted based on time_step.
:param parallel_runs_harddisk: location of eplusmtr.csv files.
:param time_step... | pd.DateOffset(hours=-.75) | pandas.DateOffset |
'''Check the datasets for simulation'''
import os
from basis.file import downloadDatasets
existing_datasets = os.path.exists("haikou-experiments/datasets")
if existing_datasets == False:
print("Downloading datasets...")
print("If failed, you can download them from https://drive.google.com/file/d/1yi3aNhB6xc1vjs... | pd.read_csv("haikou-experiments/network/ODs_combined.csv") | pandas.read_csv |
import tensorflow as tf
import numpy as np
import logging
import matplotlib.pyplot as plt
import json
import os
import rnn
from reactions import QuadraticEval, ConstraintQuadraticEval, RealReaction
from logger import get_handlers
from collections import namedtuple
from sklearn.metrics.pairwise import euclidean_distan... | pd.read_csv('EtNH3Istateset.csv') | pandas.read_csv |
import copy
import logging
import pickle
import re
from datetime import datetime
from unittest.mock import patch
import dask.dataframe as dd
import numpy as np
import pandas as pd
import pytest
from woodwork.logical_types import (
URL,
Boolean,
Categorical,
CountryCode,
Datetime,
Double,
Em... | pd.DataFrame({"id": [1, 2, 3, 4, 5]}) | pandas.DataFrame |
# Perform tolerance sweep tolerance by ESM-SSP and well-characterized errors
# for an audience seeking to emulate from the full CMIP6 archive and for the
# scenarioMIP approach, for all ESMs
# For each ESM, loop over various tolerances and generate Ndraws = 500
# GSAT trajectories. Archives with and without each ta... | pd.read_csv(full_target_path) | pandas.read_csv |
from datetime import datetime
import numpy as np
import pandas as pd
import scorecardpy as sc
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from definitions import SEED
from definitions import TARGET_NAME, REPORT_DIR
from definitions import LOGGER, USE_PRECAL... | pd.concat([train_nofr_woe, val_nofr_woe]) | pandas.concat |
import time
import pandas as pd
import numpy as np
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:
(str) city - name o... | pd.to_datetime(df['End Time']) | pandas.to_datetime |
# license: Creative Commons License
# Title: Big data strategies seminar. Challenge 1. www.iaac.net
# Created by: <NAME>
#
# is licensed under a license Creative Commons Attribution 4.0 International License.
# http://creativecommons.org/licenses/by/4.0/
# This script uses pandas for data management for more informatio... | pd.read_csv('../data/opendatabcn/2016_distribucio_territorial_renda_familiar.csv') | pandas.read_csv |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.