prompt stringlengths 19 1.03M | completion stringlengths 4 2.12k | api stringlengths 8 90 |
|---|---|---|
# -*- coding: utf-8 -*-
"""
Created on Mon Nov 6 11:33:59 2017
解析天软数据格式
@author: ws
"""
import pandas as pd
_max_iter_stocks = 100
def _int2date(int_date):
if int_date < 10000000:
return pd.NaT
return pd.datetime(int_date//10000, int_date%10000//100, int_date%100)
def parseByStock... | pd.DataFrame() | pandas.DataFrame |
# Script for predicting Enamine 2M compounds using pre-extracted TPATF features
# This script does the following things:
# 1. Reads large csv files in chunks
# 2. For each of the chunks, create pre-defined number of processes and
# 3. In each of the processes, reads the features and evaluates using all the models
#... | pd.DataFrame.from_records(result, columns=labels) | pandas.DataFrame.from_records |
import numpy as np
import pytest
from pandas import (
DataFrame,
Index,
MultiIndex,
Series,
Timestamp,
date_range,
to_datetime,
)
import pandas._testing as tm
import pandas.tseries.offsets as offsets
class TestRollingTS:
# rolling time-series friendly
# xref GH13327
def set... | tm.assert_frame_equal(result, expected) | pandas._testing.assert_frame_equal |
import pandas as pd
from impedance.models.circuits import CustomCircuit
def getRaw(x):
return complex(x["Re"],x["Im"])
def getReal(x):
return x.real
def getImag(x):
return x.imag
def fitData(rawDF,circuit,initial):
circuit = circuit.replace("Q","CPE")
df=rawDF.copy()
freq = df["f"]
fr... | pd.DataFrame() | pandas.DataFrame |
import numpy as np
import pytest
import pandas as pd
from pandas import PeriodIndex
import pandas._testing as tm
def test_to_native_types():
index = PeriodIndex(["2017-01-01", "2017-01-02", "2017-01-03"], freq="D")
# First, with no arguments.
expected = np.array(["2017-01-01", "2017-01-02", "2017-01-03"... | tm.assert_numpy_array_equal(result, expected) | pandas._testing.assert_numpy_array_equal |
from scipy.signal import find_peaks
import matplotlib
matplotlib.rcParams['pdf.fonttype'] = 42
matplotlib.rcParams['ps.fonttype'] = 42
import matplotlib.pyplot as plt
import seaborn as sns
import numpy as np
import re
import os
import pandas as pd
from cell_cycle_gating.findpeaks import get_kde, findpeaks
from cell_cyc... | pd.read_table("%s/%s" % (batch, filename)) | pandas.read_table |
import numpy as np
import pandas as pd
TZ_LOOKUP = {
'America/Anchorage': 9,
'America/Chicago': 6,
'America/Denver': 7,
'America/Los_Angeles': 8,
'America/New_York': 5,
'America/Phoenix': 7,
'Pacific/Honolulu': 10
}
def load_results():
base = 's3://pvinsight.nrel/output/'
nrel_data... | pd.date_range(start=start, end=end, freq='5min') | pandas.date_range |
#!/usr/bin/env python3
import artistools as at
# import artistools.spectra
# import artistools.lightcurve.writebollightcurvedata
from pathlib import Path
import pandas as pd
import matplotlib.pyplot as plt
import os
def plot_hesma_spectrum(timeavg, axes):
hesma_file = Path("/Users/ccollins/Downloads/hesma_file... | pd.read_csv(pathtofiles / filename, delim_whitespace=True) | pandas.read_csv |
"""
Area Weighted Interpolation
"""
import numpy as np
import geopandas as gpd
from .vectorized_raster_interpolation import fast_append_profile_in_gdf
import warnings
from scipy.sparse import dok_matrix, diags
import pandas as pd
from tobler.util.util import _check_crs, _nan_check, _check_presence_of_crs
def area_... | pd.concat(dfs, axis=0) | pandas.concat |
import pytest
from pandas._libs.tslibs.frequencies import INVALID_FREQ_ERR_MSG, _period_code_map
from pandas.errors import OutOfBoundsDatetime
from pandas import Period, Timestamp, offsets
class TestFreqConversion:
"""Test frequency conversion of date objects"""
@pytest.mark.parametrize("freq", ["A", "Q", ... | Period(freq="D", year=2007, month=1, day=1) | pandas.Period |
"""Functions for plotting sipper data."""
from collections import defaultdict
import datetime
import matplotlib as mpl
import matplotlib.dates as mdates
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
from scipy import stats
import seaborn as sns
from sipper import SipperError
#---dates and s... | pd.isna(val) | pandas.isna |
# coding: utf-8
import numpy as np
import pandas as pd
import os
import time
import multiprocessing
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import roc_auc_score, accuracy_score
from sklearn.multiclass import OneVsRestClassifier
from sklearn import preprocessing
from utils import check_a... | pd.read_csv(file_path, sep=sep, header=0, names=['node', 'label']) | pandas.read_csv |
"""
a function to draw the bar plots in SI for evaluation based on the cases data from JHU
"""
import more_itertools
import datetime
from datetime import timedelta
import os
import json
import pandas as pd
import numpy as np
import glob
import matplotlib.pyplot as plt
from precomputing import read_c... | pd.DataFrame() | pandas.DataFrame |
import sys
import os
import yaml
import argparse
import numpy as np
import pandas as pd
import csv
import random
import stat
import glob
import subprocess
from statistics import mean
from pprint import pprint, pformat
import geopandas
from shapely.geometry import Point
from math import sin, cos, atan2, sqrt, pi
from ... | pd.read_csv("accessible_camp_ipc.csv") | pandas.read_csv |
import pytz
import pytest
import dateutil
import warnings
import numpy as np
from datetime import timedelta
from itertools import product
import pandas as pd
import pandas._libs.tslib as tslib
import pandas.util.testing as tm
from pandas.errors import PerformanceWarning
from pandas.core.indexes.datetimes import cdate_... | pd.DatetimeIndex(['2011-01-01', '2011-01-02'], freq=freq) | pandas.DatetimeIndex |
import numpy as np
import pytest
from pandas.core.dtypes.common import is_integer_dtype
import pandas as pd
from pandas import Categorical, CategoricalIndex, DataFrame, Series, get_dummies
import pandas._testing as tm
from pandas.core.arrays.sparse import SparseArray, SparseDtype
class TestGetDummies:
@pytest.f... | get_dummies(s_NA, drop_first=True, sparse=sparse) | pandas.get_dummies |
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
# (ax11, ax12, ax13, ax14, ax15, ax16, ax17, ax18),
# (ax21, ax22, ax23, ax24, ax25, ax26, ax27, ax28),
# (ax31, ax32, ax33, ax34, ax35, ax36, ax37, ax38),
# (ax41, ax42, ax43, ax44, ax45, ax46, ax47, ax48),
# (ax51, ax52, ax53, ax54, ax55... | pd.read_csv('ref2012rail.csv', index_col=0) | pandas.read_csv |
"""
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 |
import os
import unittest
import random
import sys
import site # so that ai4water directory is in path
ai4_dir = os.path.dirname(os.path.dirname(os.path.abspath(sys.argv[0])))
site.addsitedir(ai4_dir)
import scipy
import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split
from ai4wa... | pd.date_range('20110101', periods=examples, freq='D') | pandas.date_range |
# -*- coding: utf-8 -*-
import json
import base64
import datetime
import requests
import pathlib
import math
import pandas as pd
import flask
import dash
import dash_core_components as dcc
import dash_html_components as html
import plotly.plotly as py
import plotly.graph_objs as go
from dash.dependencies import Input,... | pd.Series(df["high"] + 2 * (PP - df["low"])) | pandas.Series |
#!/usr/bin/env python
from __future__ import print_function
import os
import sys
import nba_py
import sqlite3
import pandas as pd
def silverK(MOV, elo_diff):
"""Calculate K constant (Source:
https://www.ergosum.co/nate-silvers-nba-elo-algorithm/).
Args:
MOV - Margin of victory.
elo_diff... | pd.date_range("2015-10-27", "2016-06-02") | pandas.date_range |
# -*- coding: utf-8 -*-
# copyright: sktime developers, BSD-3-Clause License (see LICENSE file)
"""Unit tests for (dunder) composition functionality attached to the base class."""
__author__ = ["fkiraly"]
__all__ = []
import pandas as pd
from sklearn.preprocessing import StandardScaler
from sktime.transformations.co... | pd.DataFrame({"a": [1, 2], "b": [3, 4]}) | pandas.DataFrame |
# -*- coding: utf-8 -*-
""" Project : PyCoA
Date : april 2020 - march 2021
Authors : <NAME>, <NAME>, <NAME>
Copyright ©pycoa.fr
License: See joint LICENSE file
Module : coa.geo
About :
-------
Geo classes within the PyCoA framework.
GeoManager class provides translations between naming normalisations
of countrie... | pd.notnull(p_reg_flag["code_region"]) | pandas.notnull |
# pylint: disable-msg=W0612,E1101,W0141
import nose
from numpy.random import randn
import numpy as np
from pandas.core.index import Index, MultiIndex
from pandas import Panel, DataFrame, Series, notnull, isnull
from pandas.util.testing import (assert_almost_equal,
assert_series_equal... | assert_frame_equal(recons, df) | pandas.util.testing.assert_frame_equal |
import numpy as np
import pandas as pd
import sys
import pickle
import matplotlib.pyplot as plt
from matplotlib.backends.backend_qt5agg import FigureCanvasQTAgg as FigureCanvas
import pyqtgraph
from PyQt5.QtWidgets import *
from PyQt5.QtGui import *
from PyQt5.QtCore import *
from PyQt5.QtTest import *
from Model_modul... | pd.DataFrame(compared_db) | pandas.DataFrame |
# coding=utf-8
# Copyright 2018-2020 EVA
#
# 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 ... | pd.DataFrame() | pandas.DataFrame |
import ia_batch_utils as batch
import pandas as pd
def get_data(procid, name=""):
df = pd.DataFrame()
for i in procid:
new = batch.collect_data(i, '')
df = pd.concat([df,new])
df.to_csv(f"s3://eisai-basalforebrainsuperres2/test_stack_{name}.csv")
dupe_fields = [
'key',
'... | pd.merge(df, d, on='originalimage', how=how, suffixes=('', "_y")) | pandas.merge |
# Copyright 2018 <NAME> <EMAIL>
# 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 ... | pd.DataFrame() | pandas.DataFrame |
#!/usr/bin/env python3
import os, sys, argparse, warnings, csv
warnings.filterwarnings('ignore')
import subprocess
import numpy as np
import pandas as pd
from sklearn.decomposition import PCA
import matplotlib.pyplot as plt
import matplotlib.patches as patches
from matplotlib import colors
import matplotlib_venn
import... | pd.DataFrame(A2Z, columns=['COG']) | pandas.DataFrame |
#!/usr/bin/env python3
import json
import argparse
import pickle
from collections import defaultdict
import numpy as np
import pandas
from loom_reader import LoomReader
from cluster import cluster as get_clusters
from delaunay import DictDelaunay2d
from sklearn import decomposition
def octagon(poly):
'''
R... | pandas.DataFrame.from_dict(records, orient='index') | pandas.DataFrame.from_dict |
import os
import pandas as pd
from lxml import html, etree
from frankie import frankiefun, _htmlParse, transformations
@frankiefun("XPathRemove")
def _XPathRemove(doc, **kwargs):
xpath = kwargs['xpath']
parsedDoc = _htmlParse(doc)
element = parsedDoc.find(xpath)
if element is None:
return doc... | pd.DataFrame(data) | pandas.DataFrame |
import itertools
import pandas as pd
from pandas.testing import assert_series_equal
import pytest
from solarforecastarbiter.reference_forecasts import forecast
def assert_none_or_series(out, expected):
assert len(out) == len(expected)
for o, e in zip(out, expected):
if e is None:
assert... | assert_series_equal(out[2], dhi_exp) | pandas.testing.assert_series_equal |
# built-in
import os
import pickle
# third-party
import pandas as pd
import numpy as np
import pyedflib as pyedf
# local
import utils
def get_baseline_seizure_data(patients_info_dir, saving_dir):
list_patients = [patient_id for patient_id in os.listdir(patients_info_dir) if 'MSEL' in patient_id]
for patie... | pd.DataFrame() | pandas.DataFrame |
# pylint: disable=E1101,E1103,W0232
from datetime import datetime, timedelta
import numpy as np
import warnings
from pandas.core import common as com
from pandas.types.common import (is_integer,
is_float,
is_object_dtype,
... | zip(*arrays) | pandas.compat.zip |
# -*- coding: utf-8 -*-
from copy import deepcopy
import warnings
from itertools import chain, combinations
from collections import Counter
from typing import Dict, Iterable, Iterator, List, Optional, Tuple, Union
import numpy as np
import pandas as pd
from scipy.stats import (pearsonr as pearsonR,
... | pd.concat([preserved, active, inactive]) | pandas.concat |
from collections import deque
from datetime import datetime
import operator
import re
import numpy as np
import pytest
import pytz
import pandas as pd
from pandas import DataFrame, MultiIndex, Series
import pandas._testing as tm
import pandas.core.common as com
from pandas.core.computation.expressions import _MIN_ELE... | DataFrame({"X": val, "Y": val, "Z": val}, index=df.index) | pandas.DataFrame |
#!usr/bin/env python3
import pandas as pd
import numpy as np
#Set parameters
seed_number = 1234
#Import data
infile = "./Resources/TransitionMatrix.xlsx"
transition_matrix = pd.read_excel(infile, index_col=0)
transition_matrix.columns = range(transition_matrix.shape[1])
#Set Seed
np.random.seed(seed_number)
#Simulate... | pd.concat([bond_final_rating_AAA,bond_final_rating_AA,bond_final_rating_A,bond_final_rating_BBB,bond_final_rating_BB,bond_final_rating_B,bond_final_rating_CCC]) | pandas.concat |
import datetime
from datetime import timedelta
from distutils.version import LooseVersion
from io import BytesIO
import os
import re
from warnings import catch_warnings, simplefilter
import numpy as np
import pytest
from pandas.compat import is_platform_little_endian, is_platform_windows
import pandas.util._test_deco... | tm.assert_series_equal(result, ser) | pandas.util.testing.assert_series_equal |
# coding: utf-8
#
# The MIT License (MIT)
#
# Copyright (c) 2016-2018 yutiansut/QUANTAXIS
#
# 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 t... | pd.DataFrame([item for item in cursor]) | pandas.DataFrame |
import os
from pathlib import Path
import subprocess
import threading
import time
# Auxiliar packages
import json
import pandas as pd
# Widgets
import ipywidgets as widgets
import IPython
# Plotly
import plotly.graph_objs as go
from plotly import tools
# Jupy4Syn
from .Configuration import Configuration
from .ScanP... | pd.DataFrame() | pandas.DataFrame |
#!/usr/bin/env python
from __future__ import division, print_function
import matplotlib.pyplot as plt
import pandas as pd
import numpy as np
from pxl.styleplot import set_sns
import os
import argparse
from itertools import islice
R = 0.5375
D = R*2
nu = 1e-6
c = (0.04 + 0.06667)/2
H = 0.807
def clean_column_names(d... | pd.read_csv("processed/tsr_sweep.csv") | pandas.read_csv |
import math
import numpy as np
import pandas as pd
import sklearn.datasets
import os
import urllib.request
# X: input variables (Pandas Dataframe)
# Y: output variable (Numpy Array)
def boston_housing():
d = sklearn.datasets.load_boston()
df = | pd.DataFrame(data=d.data, columns=d.feature_names) | pandas.DataFrame |
#!/usr/bin/env python3
import pandas as pd
import numpy as np
import matplotlib as mpl
import matplotlib.pyplot as plt
import matplotlib.colors as colors
from mpl_toolkits.axes_grid1 import make_axes_locatable
from pandas import set_option
set_option("display.max_rows", 10)
pd.options.mode.chained_assignment = None
... | pd.DataFrame({'alpha':minalpha, 'layer1': minsize[0], 'layer2': minsize[1],
'layer3': minsize[2]}, index=[0]) | pandas.DataFrame |
import pandas as pd
import datetime as dt
from functools import wraps
def log_step(func):
@wraps(func)
def wrapper(*args, **kwargs):
tic = dt.datetime.now()
result = func(*args, **kwargs)
time_taken = str(dt.datetime.now() - tic)
# print(f"Ran step {func.__name__} shape={result... | pd.to_datetime(dataf['DateTime'], infer_datetime_format=True) | pandas.to_datetime |
import time
time_start = time.time()
import os
import argparse as ap
import pandas as pd
import functions
parser = ap.ArgumentParser()
parser.add_argument('-n', "--stockName", help="Name of Stock")
parser.add_argument('-v', "--visualize", help="Visualizer on/off")
args = vars(parser.parse_args())
if args["stockNam... | pd.DataFrame() | pandas.DataFrame |
# -*- coding: utf-8 -*-
import re
import warnings
from datetime import timedelta
from itertools import product
import pytest
import numpy as np
import pandas as pd
from pandas import (CategoricalIndex, DataFrame, Index, MultiIndex,
compat, date_range, period_range)
from pandas.compat import PY... | tm.assert_dict_equal(groups, exp) | pandas.util.testing.assert_dict_equal |
# coding: utf-8
# ## General information
#
# This kernel is dedicated to EDA of PetFinder.my Adoption Prediction challenge as well as feature engineering and modelling.
#
# 
# (a screenshot of the PetFinder.my site)
#
# In this dataset we have lots of information: tabular data, ... | pd.read_csv('../input/state_labels.csv') | pandas.read_csv |
import os
from sqlalchemy.types import Integer, Text, String, DateTime, Float
from sqlalchemy import create_engine
import pandas as pd
from configparser import ConfigParser # For configparser compatible formatting see: https://docs.python.org/3/library/configparser.html
import numpy as np
import logging
class DataHand... | pd.Timedelta(days=1) | pandas.Timedelta |
import random
import pandas as pd
from scipy.spatial.distance import cosine
from tqdm import tqdm
from preprocessing.duration_matrix import DurationSparseMatrix
DATA = 'data/'
POSTPROCESSING = 'postprocessing/'
def get_history_by_user(user_id: int) -> list:
df = pd.read_csv(f'{DATA}{POSTPROCESSING}watch_history... | pd.read_csv(f'{DATA}{POSTPROCESSING}content.csv', index_col='content_uid') | pandas.read_csv |
import cv2
import os
import numpy as np
import math
import time
from abc import abstractmethod, ABC
from pandas import DataFrame
def timeit(func):
'''
A decorator which computes the time cost.
'''
def wrapper(*args, **kw):
start = time.time()
print('%s starts...' % (func.__name__))
... | DataFrame(dataset) | pandas.DataFrame |
import time
import requests
import datetime as dt
import pandas as pd
import numpy as np
import os
import re
import zipfile
import pandas as pd
import itertools
from selenium import webdriver
from selenium.webdriver.firefox.options import Options
from bs4 import BeautifulSoup
from financePy import scraper as scr
from ... | pd.date_range(start_date,end_date) | pandas.date_range |
import glob
import os
import sys
# these imports and usings need to be in the same order
sys.path.insert(0, "../")
sys.path.insert(0, "TP_model")
sys.path.insert(0, "TP_model/fit_and_forecast")
from Reff_functions import *
from Reff_constants import *
from sys import argv
from datetime import timedelta, datetime
from ... | pd.to_datetime(today) | pandas.to_datetime |
import pandas as pd
import numpy as np
from copy import *
from bisect import *
from scipy.optimize import curve_fit
from sklearn.metrics import *
from collections import defaultdict as defd
import datetime,pickle
from DemandHelper import *
import warnings
warnings.filterwarnings("ignore")
####################... | pd.DataFrame() | pandas.DataFrame |
import random
import numpy as np
import pytest
import pandas as pd
from pandas import (
Categorical,
DataFrame,
NaT,
Timestamp,
date_range,
)
import pandas._testing as tm
class TestDataFrameSortValues:
def test_sort_values(self):
frame = DataFrame(
[[1, 1, 2], [3, 1, 0], ... | DataFrame({"a": d1, "b": d2}, index=[0, 1, 2, 3]) | pandas.DataFrame |
'''GDELTeda.py
Project: WGU Data Management/Analytics Undergraduate Capstone
<NAME>
August 2021
Class for collecting Pymongo and Pandas operations to automate EDA on
subsets of GDELT records (Events/Mentions, GKG, or joins).
Basic use should be by import and implementation within an IDE, or by editing
se... | pd.StringDtype() | pandas.StringDtype |
import glob
import os
import sys
# these imports and usings need to be in the same order
sys.path.insert(0, "../")
sys.path.insert(0, "TP_model")
sys.path.insert(0, "TP_model/fit_and_forecast")
from Reff_functions import *
from Reff_constants import *
from sys import argv
from datetime import timedelta, datetime
from ... | pd.to_datetime(omicron_start_date) | pandas.to_datetime |
import streamlit as st
import warnings # hides warning messages
warnings.filterwarnings('ignore')
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
#from imblearn.over_sampling import SMOTE
#import itertools
import math
from sklearn import metrics
from sklear... | pd.read_csv("Data_number_of_defaults.csv") | pandas.read_csv |
#In 1
from __future__ import print_function
from __future__ import division
import pandas as pd
import numpy as np
# from matplotlib import pyplot as plt
# import seaborn as sns
# from sklearn.model_selection import train_test_split
import statsmodels.api as sm
# just for the sake of this blog post!
from warnings... | pd.read_csv(data_path, index_col=[0, 1, 2]) | pandas.read_csv |
# -*- coding: utf-8 -*-
"""
Created on Tue Nov 28 22:42:57 2017
@author: 坤
"""
import os
import numpy as np
import pandas as pa
import math as Math
import sys
import pymysql
import dateutil
'''
过滤大震附近小震
参数 地址目录 时间 以及半径
'''
def findEqM(df,minz,maxz):
find=df[df['magnitude']>=int(minz)]
return find[find['ma... | pa.DataFrame() | pandas.DataFrame |
from __future__ import division, print_function
import time
from IPython.display import display
import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn import metrics
from sklearn.externals import joblib
from sklearn.co... | pd.DataFrame() | pandas.DataFrame |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Fri Jun 8 19:52:14 2018
@author: benji
"""
# Demo file for Spyder Tutorial
# <NAME>, University of Southampton, UK
import pandas as pd
def hello():
"""Print "Hello World" and return None"""
print("Hello World")
# main program starts here
def b... | pd.Series(['San Francisco', 'San Jose', 'Sacramento']) | pandas.Series |
import pandas as pd
import numpy as np
import os
from sklearn.pipeline import Pipeline, FeatureUnion
from sklearn.feature_extraction.text import CountVectorizer, TfidfTransformer
from sklearn.metrics import precision_recall_fscore_support
import xgboost as xgb
from tqdm import tqdm
import argparse
from pk_classifier.bo... | pd.DataFrame(pred_test == y_test.values, columns=['Result']) | pandas.DataFrame |
import datetime
import logging
import click
import pandas as pd
import tushare as ts
from tusharedb import config, db, util
api = ts.pro_api(token=config.TS_TOKEN)
logger = logging.getLogger(__name__)
def sync_daily():
sate = db.StateDb()
dates = [date for date in sate.list_daily()]
apis = ['daily', 'a... | pd.DatetimeIndex(df.trade_date) | pandas.DatetimeIndex |
import pytest
import numpy as np
import pandas as pd
from pandas import Categorical, Series, CategoricalIndex
from pandas.core.dtypes.concat import union_categoricals
from pandas.util import testing as tm
class TestUnionCategoricals(object):
def test_union_categorical(self):
# GH 13361
data = [
... | tm.assert_raises_regex(ValueError, msg) | pandas.util.testing.assert_raises_regex |
import pandas as pd
import bs4 as bs
# import urllib.request
# !pip install yfinance
import yfinance as yf
def get_etf_holdings(etf_symbol, shares):
#read the top 25 holdings in data frame
dfs = pd.read_html("https://ycharts.com/companies/{}/holdings".format(etf_symbol),header=0)
holdings ... | pd.DataFrame(columns=["Symbol", "Name", "Amount Owned"]) | pandas.DataFrame |
import datetime
import os
from typing import List, Dict, Optional
from fastapi import FastAPI
from fastapi.middleware.cors import CORSMiddleware
import pandas as pd
from pydantic import BaseModel
API_URL = os.environ.get("API_URL", None)
if API_URL is None:
raise ValueError("API_URL not known")
app = FastAPI()
a... | pd.read_json(f"{API_URL}/us_covid_variable_start_date") | pandas.read_json |
# -*- coding: utf-8 -*-
"""
Script to determine the optimal regression to use for pre-1998 69607.
"""
from core.ts.sw import malf7d, flow_stats, flow_reg, stream_nat
from core.ecan_io import flow_import, rd_henry, rd_hydstra_db, rd_ts
from pandas import concat
from numpy import nan, log, in1d
import seaborn as sns
fro... | concat([x1, t1], axis=0) | pandas.concat |
import os
import random
import argparse
from typing import Any, Dict, List
import pandas as pd
from generators import FakeGenerators
fake = FakeGenerators()
feed = | pd.DataFrame() | pandas.DataFrame |
import re
import socket
from datetime import datetime
from urlextract import URLExtract
import urllib.parse as urlparse
from urllib.parse import parse_qs
import click
import argparse
import csv
import os
from dateutil.parser import parse
import pandas as pd
from urllib.parse import unquote
import hashlib
... | pd.read_csv(file_name, sep='\t', error_bad_lines=False, names=names_arquivo) | pandas.read_csv |
# Import Libraries
import statistics
import numpy as np
import pandas as pd
import streamlit as st
# PREDICTION FUNCTION
def predict_AQI(city, week, year, multi_week, month):
if city == 'Chicago':
data = pd.read_csv("pages/data/chi_actual_pred.csv")
if multi_week:
result = []
... | pd.DataFrame(d) | pandas.DataFrame |
# -*- coding: utf-8 -*- %reset -f
"""
@author: <NAME>
"""
# Demonstration of generating samples restrected
# settings
file_name = 'virtual_resin_x.csv'
number_of_samples_generated = 10000
x_max_rate = 1.1 # this value is multiplied to the maximum value in dataset and is used as the upper limit for generated samples
... | pd.read_csv(file_name, index_col=0, header=0) | pandas.read_csv |
import re
from datetime import datetime
import nose
import pytz
import platform
from time import sleep
import os
import logging
import numpy as np
from distutils.version import StrictVersion
from pandas import compat
from pandas import NaT
from pandas.compat import u, range
from pandas.core.frame import DataFrame
im... | DataFrame({'TRUE_BOOLEAN': [True]}) | pandas.core.frame.DataFrame |
# Copyright 2022 <NAME>, <NAME>, <NAME>.
# Licensed under the BSD 2-Clause License (https://opensource.org/licenses/BSD-2-Clause)
# This file may not be copied, modified, or distributed
# except according to those terms.
import os
from datetime import date, datetime
from os import getcwd, listdir, mkdir, path
from shu... | pd.DataFrame(columns=["sample_name", "file", "type"]) | pandas.DataFrame |
#
# Copyright (C) 2021 The Delta Lake Project Authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law... | pd.testing.assert_frame_equal(pdf, expected) | pandas.testing.assert_frame_equal |
"""Merge two or more tables as data frames.
"""
import argparse
from functools import reduce
import pandas as pd
if __name__ == "__main__":
parser = argparse.ArgumentParser()
parser.add_argument("--tables", nargs="+", help="tables to concatenate")
parser.add_argument("--separator", default="\t", help="sep... | pd.read_csv(args.tables[i], sep=args.separator) | pandas.read_csv |
import pandas as pd
from OCAES import ocaes
import time
from joblib import Parallel, delayed, parallel_backend
# =====================
# Function to enable parameter sweep
# =====================
def parameterSweep(sweep_inputs, index):
# Record time to solve
t0 = time.time()
# create and run model
d... | pd.Series(index=entries) | pandas.Series |
import sys
import warnings
from itertools import combinations
import matplotlib.pyplot as plt
import pandas as pd
import holoviews as hv
hv.extension('bokeh')
hv.output(size=200)
warnings.filterwarnings("ignore", "Only Polygon objects", UserWarning)
warnings.simplefilter(action='ignore', category=FutureWarning)
pd.o... | pd.DataFrame(cnxns, columns=['region1', 'region2', 'total']) | pandas.DataFrame |
"""
High-level utilities and wrappers on top of high-level APIs of other libraries.
"""
import numpy as np
import pandas as pd
import sklearn.metrics
import sklearn.preprocessing
import tensorflow as tf
import lidbox.metrics
import lidbox.data.steps
TF_AUTOTUNE = tf.data.experimental.AUTOTUNE
def predictions_to_da... | pd.DataFrame.from_dict({"id": ids, "prediction": predictions}) | pandas.DataFrame.from_dict |
# -*- coding: utf-8 -*-
"""
Created on Mon Jul 14 13:08:38 2020
@author: Lajari
"""
import pandas as pd
from sklearn.base import TransformerMixin, BaseEstimator
from re import search
import nltk
nltk.download('stopwords')
nltk.download('wordnet')
from nltk import RegexpTokenizer
from nltk.corpus import stopwords
fr... | pd.to_datetime(X['RetrievedTime']) | pandas.to_datetime |
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
"""
we consider a list of integers going from 2^0 to 2^159, and we use sys.getsizeof to inspect how many bytes are actually used to store the integer
"""
import sys
int_sizes = {}
for i in range(160):
int_sizes[i] = sys.getsizeof(2 ** i)
int_si... | pd.Series(int_sizes) | pandas.Series |
import pandas as pd
import math
import sqlite3 as sql
def read_tables_info(con):
data = pd.read_sql_query('select * from tables_info',con,index_col='index')
return data
def is_table_exists(cursor,table_name):
cursor.execute('select count(*) from sqlite_master where type="table" and name="'+table_name+'"'... | pd.read_sql_query(sql_str,con) | pandas.read_sql_query |
# Analysis of *rXiv clusters
# %%
import logging
import re
from datetime import datetime
import altair as alt
import pandas as pd
import statsmodels.api as sm
from numpy.random import choice
from scipy.spatial.distance import cityblock
from statsmodels.api import OLS, Poisson, ZeroInflatedPoisson
from eurito_indicat... | pd.get_dummies(reg_data["cluster"]) | pandas.get_dummies |
# -*- coding: utf-8 -*-
"""
Created on Sat Oct 22 21:44:29 2016
@author: Carrie
"""
#Program will:
# Parse json file with tweets from Seattle for the last week,
# 10 million public geotagged tweets every day, which is about 120 per second
import json, time, pandas as pd
from datetime import datetime, timedel... | pd.DataFrame() | pandas.DataFrame |
from datetime import datetime
from math import sqrt, nan
import pandas as pd
def lowVol(market, last_nyears=1, num_pf=30, interval='d'):
''' Portfolio selection based on low volatility (annualized)
args:
last_nyears: int
num_pf: number of stocks included in the portfolio
interval: time ... | pd.Series() | pandas.Series |
from os.path import join
import numpy as np
import pandas as pd
import geopandas as gpd
import matplotlib.pyplot as plt
from src import utils as cutil
def convert_non_monotonic_to_nan(array):
"""Converts a numpy array to a monotonically increasing one.
Args:
array (numpy.ndarray [N,]): input array
... | pd.read_excel(health_jan_file, sheet_name=None) | pandas.read_excel |
from datetime import datetime
import numpy as np
import pytest
import pandas as pd
from pandas import (
DataFrame,
Index,
MultiIndex,
Series,
_testing as tm,
)
def test_split(any_string_dtype):
values = Series(["a_b_c", "c_d_e", np.nan, "f_g_h"], dtype=any_string_dtype)
... | Series({0: ["split", "once"], 1: ["split", "once_too!"]}) | pandas.Series |
import pandas as pd
import pytest
import torch
import greattunes.utils
from greattunes.data_format_mappings import tensor2pretty_covariate
@pytest.mark.parametrize("method, tmp_val",
[
["functions", 1.0],
["iterative", 2.0]
... | pd.DataFrame({"covar0": [0.1], "covar1": [2.5], "covar2": [12], "covar3": [0.22]}) | pandas.DataFrame |
# ----------------------------------------------------------------------------
# Copyright (c) 2020, <NAME>.
#
# Distributed under the terms of the Modified BSD License.
#
# The full license is in the file LICENSE, distributed with this software.
# -----------------------------------------------------------------------... | pd.read_csv(diffs, index_col=0, sep='\t') | pandas.read_csv |
import pandas as pd
# Dataframe
data = pd.DataFrame({
'kelas': 6*['A'] + 6*['B'],
'murid': 2*['A1'] + 2*['A2'] + 2*['A3'] + 2*['B1'] + 2*['B2'] + 2*['B3'],
'pelajaran': 6*['math','english'],
'nilai': [90,60,70,85,50,60,100,40,95,80,60,45]
}, columns=['kelas','murid','pelajaran','nilai'])
# Pivoting dataframe
da... | pd.melt(data_pivot, id_vars='kelas', value_vars=['math']) | pandas.melt |
'''recurring_spend.py docstring
Author: <NAME>
'''
import os
import glob
import datetime as dt
import pickle
import numpy as np
import pandas as pd
from google.cloud import bigquery
from googleapiclient.discovery import build
from google_auth_oauthlib.flow import InstalledAppFlow
from google.auth.transport.requests ... | pd.concat(df_list) | pandas.concat |
# %matplotlib inline
import os
import numpy as np
import pandas as pd
import matplotlib
matplotlib.use('TkAgg')
import matplotlib.pyplot as plt
from sklearn.ensemble import RandomForestClassifier
from keras.models import Sequential, Model
from keras.layers import Dense, Input
from keras import optimizers
import keras... | pd.read_csv(ind_data_paths['A']['train'], index_col='id') | pandas.read_csv |
"""plotting utilities that are used to visualize the curl, divergence."""
import numpy as np, pandas as pd
import anndata
from anndata import AnnData
from typing import List, Union, Optional
from .scatters import scatters
from .scatters import docstrings
from .utils import (
_matplotlib_points,
save_fig,
... | pd.DataFrame(J, index=regulators, columns=effectors) | pandas.DataFrame |
"""
Web scrape Alcoholics Anonymous website for meeting details
========================================
This file web scrapes information about Alcoholics Anonymous
meetings in Great Britain, including location, time and
duration
Requirements
------------
:requires: bs4
:requires: urllib
:requires: selenium
... | pd.merge(meetings_df, postcode_lookup, left_on='postcodes', right_on='pcds', how='left') | pandas.merge |
import matplotlib.pyplot as plt
import pandas as pd
import seaborn as sns
import numpy as np
from collections import OrderedDict
from utils.canvas import canvas
def odict2prop_list(odict):
store = []
for key, value in odict.iteritems():
max_prop = np.max(value.prop, axis=-1)
uid = np.unique(ma... | pd.DataFrame(arr) | pandas.DataFrame |
import pandas as pd
import sys
from pathlib import Path
fileName = sys.argv[1]
cvf = Path("./ChildResults/FinalCV_"+str(fileName))
gwf = Path("./ChildResults/FinalGW_"+str(fileName))
phf = Path("./ChildResults/FinalPhG_" + str(fileName))
dif = Path("./ChildResults/FinalDi_"+str(fileName))
mcapf = Path("./ChildResults... | pd.DataFrame(columns=['#CHROM','POS','ID','REF','ALT','QUAL','FILTER','INFO','FORMAT','GT','Likelihood']) | pandas.DataFrame |
import numpy as np
import pandas as pd
from typing import Mapping, List, Tuple
from collections import defaultdict, OrderedDict
import matplotlib.pyplot as plt
import matplotlib as mpl
from sklearn.linear_model import LinearRegression, Lasso
from sklearn.ensemble import RandomForestClassifier
from sklearn.ensemble impo... | pd.DataFrame() | pandas.DataFrame |
#! /usr/bin/env python
import sys, os
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column, Integer, create_engine, MetaData
from sqlalchemy import Table, ForeignKey
from sqlalchemy.orm import sessionmaker, relationship
from sqlalchemy.dialects.postgresql import *
from sqlalchemy.sql.ex... | pd.to_numeric(dataframe[i], errors='coerce') | pandas.to_numeric |
#!/usr/bin/env python
# coding: utf-8
# **[Machine Learning Home Page](https://www.kaggle.com/learn/intro-to-machine-learning)**
#
# ---
#
# # Introduction
# Machine learning competitions are a great way to improve your data science skills and measure your progress.
#
# In this exercise, you will create and submi... | pd.read_csv(iowa_file_path) | pandas.read_csv |
name = 'nfl_data_py'
import pandas
import numpy
import datetime
def import_pbp_data(years, columns=None, downcast=True):
"""Imports play-by-play data
Args:
years (List[int]): years to get PBP data for
columns (List[str]): only return these columns
downcast (bool): convert float64... | pandas.DataFrame() | pandas.DataFrame |
import statistics
import numpy as np
import pandas as pd
import scipy.stats as scs
from numpy import ndarray
from sklearn import preprocessing
from sklearn.preprocessing import MinMaxScaler
from sklearn.svm import SVR
from Common.Measures.Time.TimeSpan import TimeSpan
from Common.Readers.Engine.PandaEngine import Pan... | pd.DataFrame() | pandas.DataFrame |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.