prompt stringlengths 19 1.03M | completion stringlengths 4 2.12k | api stringlengths 8 90 |
|---|---|---|
#%% [markdown]
# # Matching when including the contralateral connections
#%% [markdown]
# ## Preliminaries
#%%
import datetime
import os
import time
from pathlib import Path
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
import seaborn as sns
from giskard.plot import adjplot, matched_stripplot,... | pd.DataFrame(rows) | pandas.DataFrame |
import numpy as np
import pandas as pd
from scipy.stats import pearsonr,spearmanr
from scipy.stats import entropy as kl
from sklearn.metrics import roc_auc_score, f1_score, mean_squared_error
from math import sqrt
import os
import multiprocessing as mp
def get_annotator_ensemble_baseline(annotations, k, agg_function... | pd.concat(d_ts) | pandas.concat |
'''
@Author: mendeslbruno
Date: 2021-01-26
Descr: Performs some simple analyzes for several actions of the index SP500.
'''
import pandas as pd
import yfinance as yf
import streamlit as st
import datetime as dt
import plotly.graph_objects as go
from plotly.subplots import make_subplots
snp500 = | pd.read_csv("datasets/SP500.csv") | pandas.read_csv |
import torch
import os
import torch.nn as nn
import torch.nn.functional as F
from tqdm import tqdm
import torchvision
import math
import numpy as np
import pandas as pd
from .adversarial import fgsm_image, fgsm_k_image, boundary_attack_image
from tqdm import tqdm, trange
import time
import copy
from sklearn.metrics imp... | pd.DataFrame(cm, index=labels, columns=labels) | pandas.DataFrame |
import re
import os
import string
from read import *
import pandas as pd
from pandas import ExcelWriter, ExcelFile
import numpy as np
import matplotlib.pyplot as plt
import spacy
from nltk.corpus import stopwords
import nltk
from sklearn.linear_model import LinearRegression
from sklearn.cross_validation import train_te... | pd.DataFrame(df) | pandas.DataFrame |
# coding: utf-8
# # Example 01: Basic Queries
#
# Retrieving data from Socrata databases using sodapy
# ## Setup
# In[1]:
import os
import pandas as pd
import numpy as np
from sodapy import Socrata
# ## Find some data
#
# Though any organization can host their own data with Socrata's tools, Socrata also hosts s... | pd.DataFrame.from_dict(chatt_results) | pandas.DataFrame.from_dict |
"""
Import spatio-temporal data
"""
import glob
from random import choice, sample
from typing import List, Tuple
from cartopy.mpl.ticker import LongitudeFormatter, LatitudeFormatter
import cartopy.crs as ccrs
import matplotlib.patches as patches
import matplotlib.pyplot as plt
from matplotlib import colors
import nu... | pd.concat(frames, ignore_index=True) | pandas.concat |
import requests
import deeptrade
import pandas as pd
class StockPrice():
def __init__(self):
self.head = {'Authorization': "Token %s" %deeptrade.api_key}
def by_date(self,date,dataframe=False):
"""
:parameters:
- date: a day date in the format %YYYY-%MM-%DD
- datafram... | pd.DataFrame(g) | pandas.DataFrame |
import pandas as pd
chrom_sizes = pd.Series(
{1: 249250621,
10: 135534747,
11: 135006516,
12: 133851895,
13: 115169878,
14: 107349540,
15: 102531392,
16: 90354753,
17: 81195210,
18: 78077248,
19: 59128983,
2: 243199373,
20: 63025520,
21: 48129895,
... | pd.DataFrame(null_sets) | pandas.DataFrame |
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import os
import time
from sklearn.model_selection import train_test_split
import string
import nltk
from nltk.corpus import stopwords
plt.style.use(style='seaborn')
#%matplotlib inline
df=pd.read_csv('all-data.csv',encoding = "ISO-88... | pd.concat([df1,df2],axis=1) | pandas.concat |
#!/usr/bin/env python
'''
Calculates the total number of character occurances at each position within the set of sequences passed.
'''
from __future__ import division
import argparse
import numpy as np
import sys
import pandas as pd
import mpathic.qc as qc
import mpathic.io as io
from mpathic import SortSeqError
def m... | pd.concat([poss,temp_df],axis=1) | pandas.concat |
import os
from unittest import TestCase
import annotator
import commons
from annotator.annot import Annotator
import experiments.alpha_eval_one as aone
import math
import pandas as pd
class AlphaOneTest(TestCase):
def test_compute_class_alpha_accuracy(self):
arr = [
["abc1.txt", 0, 0, 0.1, 0.... | pd.DataFrame(arr, columns=['fname', 'colid', 'fsid', 'from_alpha', 'to_alpha']) | pandas.DataFrame |
import csv
from io import StringIO
import os
import numpy as np
import pytest
from pandas.errors import ParserError
import pandas as pd
from pandas import (
DataFrame,
Index,
MultiIndex,
NaT,
Series,
Timestamp,
date_range,
read_csv,
to_datetime,
)
import pandas._testing as tm
impo... | tm.assert_frame_equal(df, result) | pandas._testing.assert_frame_equal |
#!/usr/bin/env python
"""
Module Docstring
"""
__author__ = "<NAME>"
__version__ = "0.1.0"
__license__ = "MIT"
filters = ['all', 'to', 'from', 'ghosted']
def get_chat_history(message_filter:str, Heading:str = 'Users', username:str = ''):
""" Main entry point of the app """
import pandas as pd
import heat... | pd.to_datetime(df['Date'], yearfirst=True) | pandas.to_datetime |
# *****************************************************************************
# Copyright (c) 2020, 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.Series(right) | pandas.Series |
# # Imports
# import pandas as pd
# from matplotlib import pyplot as plt
# import numpy as np
# from sklearn.feature_selection import SelectKBest
# from sklearn.feature_selection import chi2
# from sklearn.ensemble import RandomForestRegressor
# from sklearn.cross_validation import cross_val_score, ShuffleSplit
... | pd.read_csv(fantasy_data_file) | pandas.read_csv |
import pandas as pd
import os, sys, pickle
from keras import models
from keras import layers
from keras import optimizers
from keras.callbacks import ModelCheckpoint
from keras.utils import multi_gpu_model
import tensorflow as tf
import subprocess, argparse
from get_model import *
from get_generators import *
n_GPUs ... | pd.to_datetime('2014-12-31') | pandas.to_datetime |
import pandas as pd
import numpy as np
import math
import re
import matplotlib.pyplot as plt
import matplotlib.gridspec as gridspec
import matplotlib as mpl
import matplotlib.patches as mpatches
import matplotlib.pyplot as plt
import matplotlib.ticker as ticker
from matplotlib.patches import Rectangle
import io
from ... | pd.to_datetime(fluids_in['time'], unit='ms') | pandas.to_datetime |
from datetime import (
datetime,
timedelta,
)
import numpy as np
import pytest
from pandas._libs.tslibs.ccalendar import (
DAYS,
MONTHS,
)
from pandas._libs.tslibs.period import INVALID_FREQ_ERR_MSG
from pandas.compat import is_platform_windows
from pandas import (
DatetimeIndex,
Index,
S... | DatetimeIndex(["01/01/1999", "1/4/1999", "1/5/1999"]) | pandas.DatetimeIndex |
from os.path import isfile
from pandas import read_csv, DataFrame
class DB:
def __init__(self, csv_path: str):
self.data: DataFrame
self.csv_path = csv_path
if isfile(self.csv_path):
self.data = read_csv(csv_path, memory_map=True)
else:
open(self.csv_path, ... | read_csv(self.csv_path, memory_map=True) | pandas.read_csv |
# QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
# Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
#
# 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 Licen... | pd.to_datetime(df.index, unit='s') | pandas.to_datetime |
from selenium import webdriver
from selenium.webdriver.common.keys import Keys
from selenium.webdriver.chrome.options import Options
from bs4 import BeautifulSoup
import pandas as pd
import time
from datetime import date
import re
def is_time_format(str_input):
try:
time.strptime(str_input, '%H:%M')
... | pd.DataFrame(all_info_dict) | pandas.DataFrame |
import os
import sys
import glob
import random
import numpy as np
np.random.seed(23087)
import pandas as pd
import tensorflow as tf
from keras import backend as k
from keras.utils import np_utils
from keras.optimizers import Adam
from keras.models import Sequential, load_model
from matplotlib import pyplot as plt
from ... | pd.DataFrame.transpose(conf_matrix) | pandas.DataFrame.transpose |
import sys
import time
import pandas as pd
import numpy as np
import copyreg, types
from tqdm import tqdm
import matplotlib as mpl
import matplotlib.pyplot as plt
import seaborn as sns
plt.style.use('seaborn-talk')
plt.style.use('bmh')
#plt.rcParams['font.family'] = 'DejaVu Sans Mono'
plt.rcParams['font.size'] = 9.5
... | pd.Timedelta(days=1) | pandas.Timedelta |
import json
import boto3 as bt
import pandas as pd
from io import StringIO
import mechanize
from lxml import etree
import numpy as np
from datetime import date
import re
import time
import os
def lambda_handler(event, context):
start_time = time.time()
client = bt.client(
's3',
... | pd.concat([full_advert_data, basic_new_data], sort=False) | pandas.concat |
from flask import Flask
from flask import request
import pandas as pd
app = Flask(__name__)
DATA_FILE_NAME = "client_rate.json"
@app.route("/")
def default():
return "FIRST PROJECT - we have " + str(len(get_client_rates())) + " clients in total."
def get_client_rates():
df = pd.read_json(DATA_FILE_NAME)
... | pd.DataFrame.from_dict(rates) | pandas.DataFrame.from_dict |
from datetime import datetime
from decimal import Decimal
import numpy as np
import pytest
import pytz
from pandas.compat import is_platform_little_endian
from pandas import CategoricalIndex, DataFrame, Index, Interval, RangeIndex, Series
import pandas._testing as tm
class TestFromRecords:
def test_from_record... | DataFrame.from_records(arr2) | pandas.DataFrame.from_records |
import os
from datetime import datetime as dt
from datetime import timedelta as td
from uuid import uuid4
import json
import pandas as pd
import numpy as np
from kivy.app import App
from kivy.uix.screenmanager import ScreenManager, Screen
from kivy.config import Config
from kivy.uix.boxlayout import BoxLayout
from ki... | pd.read_csv(instance.ids["file_name"].text) | pandas.read_csv |
import cleaning_string
import codecs
import pandas as pd
import subprocess
import nltk
import re as regex
import string
import collections
from nltk.stem.wordnet import WordNetLemmatizer
from nltk.wsd import lesk
from nltk.corpus import wordnet
import operator
import numpy as np
from nltk.stem.snowball... | pd.read_csv(csv_file, usecols=[0, 1]) | pandas.read_csv |
import pandas as pd
from sklearn import cluster
from sklearn import metrics
import matplotlib.pyplot as plt
from sklearn.manifold import TSNE
def k_means(data_set, output_file, png_file, t_labels, score_file, set_name):
model = cluster.KMeans(n_clusters=4, max_iter=100, n_jobs=4, init="k-means++")
model.fit(d... | pd.DataFrame(t_sne_db_2.embedding_, index=second_set.index) | pandas.DataFrame |
# HELPER FUNCTIONS FOR ATTENTION AND MEMORY ANALYSES
import os
import pickle
import pandas as pd
from matplotlib import pyplot as plt
import ast
import json
import re
from datetime import datetime
import time
import hypertools as hyp
import numpy as np
from matplotlib import patches as patches
import seaborn as sb
... | pd.read_csv(subdir+'/'+f) | pandas.read_csv |
import requests
import json
import pandas as pd
def get_espn_info(season, espn_league_id, cookies = None):
r = requests.get('https://fantasy.espn.com/apis/v3/games/ffl/seasons/{}/segments/0/leagues/{}'.format(season, espn_league_id),
params={ 'view': ['mTeam', 'mRoster', 'mSettings']},
... | pd.DataFrame() | pandas.DataFrame |
# %% markdown
# Portfolio Optimization - Risk
# %% add path
if __name__ == '__main__' and __package__ is None:
import sys, os.path
sys.path
# append parent of the directory the current file is in
inputfilename1 = r"C:\Users\<NAME>\Documents\Onedrive\Python scripts\_01 Liam Stock Analysis Project\stock_a... | pd.DataFrame(prices) | pandas.DataFrame |
import os
from unittest.mock import patch
import numpy as np
import pandas as pd
import pytest
from skopt.space import Real
from evalml.pipelines import BinaryClassificationPipeline, ComponentGraph
@pytest.fixture
def test_pipeline():
class TestPipeline(BinaryClassificationPipeline):
component_graph = [... | pd.DataFrame(f_i, columns=["feature", "importance"]) | pandas.DataFrame |
import traceback
import argparse
import re # regular expressions
import gzip
import pandas as pd
'''
Load RNA sequence into memory.
Reads a FASTA.gz file from GeneCode.
Parses the transcript id (TID) from the FASTA defline.
Returns a Pandas dataframe with columnts tid, class, sequence, seqlen.
Typical input files fro... | pd.concat((df1,df2,df3,df4),axis=1) | pandas.concat |
###what's left: find data path, save raw results (predictions) save efficiency calculations, check imports are correct
import pickle
import sys
path_to_save = sys.argv[1]
import tensorflow as tf
import pandas as pd
import numpy as np
# Keras
import keras
import keras.backend as K
from keras.models import Sequential... | pd.concat([baseline_result,baseline_sub_result],axis =1) | pandas.concat |
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
import pickle
pd.set_option('display.max_columns', 100)
pd.options.mode.chained_assignment = None
train_path = '../input/forest-cover-type-prediction/train.csv'
test_path = '../input/forest-cover-type-prediction/test.csv'
subm... | pd.read_csv(train_path, index_col=0) | pandas.read_csv |
"""
Module for interacting with the NHL's open but undocumented API.
"""
import streamlit as st
import pandas as pd
from pandas.io.json import json_normalize
import requests as rqsts
## data ingestion
def get_seasons(streamlit=False):
""" returns all seasons on record """
seasons_response = rqsts.get('https://... | json_normalize(game) | pandas.io.json.json_normalize |
# Authors: dodoarg <<EMAIL>>
from typing import List, Optional, Union
import pandas as pd
from pandas.api.types import is_datetime64_any_dtype as is_datetime
from pandas.api.types import is_numeric_dtype as is_numeric
from sklearn.base import BaseEstimator, TransformerMixin
from sklearn.utils.validation import check_... | is_numeric(X.index) | pandas.api.types.is_numeric_dtype |
#IMPORT LIBRARIES
import requests
import pandas as pd
import boto3
import re
import os
from datetime import datetime
import selenium
from selenium import webdriver
from bs4 import BeautifulSoup
from secrets import access_key, secret_access_key
#Create User-Agent for requests
headers = { 'User-Age... | pd.DataFrame([city_url2,sortby,results_restaurants, restaurant_name]) | pandas.DataFrame |
"""Test script that saves results from 26 vehicles currently in master branch of FASTSim as of 17 December 2019 for 3 standard cycles.
From command line, pass True (default if left blank) or False argument to use JIT compilation or not, respectively."""
import pandas as pd
import time
import numpy as np
import re
imp... | pd.DataFrame.from_dict(dict_diag) | pandas.DataFrame.from_dict |
#!/usr/bin/env python
# coding: utf-8
# -------------------------------------------------------------------
# **TD DSA 2021 de <NAME> - rapport de <NAME>**
# ------------------------- -------------------------------------
# # Analyse descriptive
# ## Setup
# In[5]:
get_ipython().system('pip install textbl... | pd.Series(neutral_text_prepro) | pandas.Series |
# -*- coding: utf-8 -*-
"""
Methods to perform coverage analysis.
@author: <NAME> <<EMAIL>>
"""
import pandas as pd
import numpy as np
import geopandas as gpd
from typing import List, Optional
from shapely import geometry as geo
from datetime import datetime, timedelta
from skyfield.api import load, wgs84, EarthSatel... | pd.Timestamp(start) | pandas.Timestamp |
import os
import pandas as pd
import numpy as np
import rasterio
from mapBiomas_dictionaries import year_band
def reclassified_pixels(year):
band = year_band.get(year)
open_band = wp_raster.read(band)
pixels = np.count_nonzero(open_band)
converted = open_band * (open_band != wp_raster.read(band - 1))... | pd.DataFrame(columns=column_names) | pandas.DataFrame |
from unittest import TestCase
import pandas as pd
import numpy as np
import pandas_validator as pv
from pandas_validator.core.exceptions import ValidationError
class BaseSeriesValidatorTest(TestCase):
def setUp(self):
self.validator = pv.BaseSeriesValidator(series_type=np.int64)
def test_is_valid_wh... | pd.Series([0., 1., 2.1]) | pandas.Series |
# -*- encoding: utf-8 -*-
from json import encoder
import multiprocessing
import time
import json
import yaml
import os
import math
import numpy as np
import pandas as pd
from pandas import DataFrame as df
from itertools import product
from random import random, choice, seed
from typing import Tuple
from deap import... | pd.merge(df_summary, df_results, how="inner", on="name") | pandas.merge |
# This Python 3 environment comes with many helpful analytics libraries installed
# It is defined by the kaggle/python docker image: https://github.com/kaggle/docker-python
# For example, here's several helpful packages to load in
import numpy as np # linear algebra
import pandas as pd # data processing, CSV file I/O... | pd.concat([train_df[[col]], test_df[[col]]]) | pandas.concat |
import pandas as pd
import numpy as np
s = pd.Series(['丁一', '王二', '张三'])
print(s)
a = pd.DataFrame([[1, 2], [3, 4], [5, 6]])
print(f'\n{a}')
b = pd.DataFrame([[1, 2], [3, 4], [5, 6]], columns=['date', 'score'], index=['A', 'B', 'C'])
print(f'\n{b}')
c = | pd.DataFrame() | pandas.DataFrame |
# -*- coding: utf-8 -*-
import contextlib
import datetime
import hypothesis.extra.numpy as hyp_np
import hypothesis.strategies as hyp_st
import numpy as np
import pandas as pd
from kartothek.core.uuid import gen_uuid_object
try:
from freezegun.api import real_date as date
except ImportError:
from datetime ... | pd.concat([not_nested, nested_types], axis=1) | pandas.concat |
# -*- coding: utf-8 -*-
"""System transmission plots.
This code creates transmission line and interface plots.
@author: <NAME>, <NAME>
"""
import os
import logging
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import matplotlib.cm as cm
import matplotlib.colors as mcolors
import matplotlib.d... | pd.DataFrame() | pandas.DataFrame |
# TODO decide whether include MAX PV and MAX ST or the percentage of area usage
import pandas as pd
import os
def create_decentral_overview(components_csv_data):
# defining columns of the sheet including decentralized components
decentral_columns = ["Building", "PV 1", "Max. PV 1", "PV 2", "Max. PV 2... | pd.DataFrame(columns=decentral_columns) | pandas.DataFrame |
from enum import Enum
from random import random
import pandas
from aisoccer.team import *
class Game:
def __init__(self, blue_brain, red_brain, game_length=Constants.GAME_LENGTH, quiet_mode=False, record_game=False):
self.quiet_mode = quiet_mode
self.game_length = game_length
self.teams ... | pandas.DataFrame(self.move_df) | pandas.DataFrame |
"""dfenriching
This module illustrate examples that enrich a dataset using pandas.
"""
import pandas as pd
df = pd.read_csv('scooter.csv')
# Take a subset of the data
new = pd.DataFrame(df['start_location_name'].value_counts().head())
new.reset_index(inplace=True)
new.columns=['address', 'count']
print("First entri... | pd.read_csv('geocodestreet.csv') | pandas.read_csv |
import os
import pandas as pd
BASE_DIR = os.path.dirname(os.path.abspath(__file__))
DATA_DIR = os.path.join(BASE_DIR, 'data')
CACHE_DIR = os.path.join(BASE_DIR, 'cache')
os.makedirs(CACHE_DIR, exist_ok=True)
new_dataframes = []
csv_files = [x for x in sorted(os.listdir(DATA_DIR), reverse=True) if x.endswith(".csv")]... | pd.concat(new_dataframes) | pandas.concat |
import unittest
import numpy as np # type: ignore
import pandas as pd # type: ignore
from gpxpy.gpx import GPXTrackPoint, GPXTrackSegment # type: ignore
from gpx_data_utils import (
gpx_point_to_array,
gpx_segment_to_array,
gpx_segment_from_array
)
from gpx_stats import convert_path_to_feature, smo... | pd.DataFrame(self.segments_as_arrays[i]) | pandas.DataFrame |
import numpy as np
import pandas as pd
import dash_html_components as html
import dash_core_components as dcc
import dash_bootstrap_components as dbc
def spinner_graph(*args, **kwargs):
return dbc.Spinner(dcc.Graph(*args, **kwargs))
def add_quarters(df):
df['Quarter'] = | pd.to_datetime(df['DT_FIM_EXERC']) | pandas.to_datetime |
import pandas as pd
import torch
from torch.utils.data import Dataset
from tqdm import tqdm
from evaluation.tasks.auto_task import AutoTask
class CrowSPairsDataset(Dataset):
def __init__(self):
super().__init__()
# TODO: maybe implement using HuggingFace Datasets
# https://huggingface.co... | pd.read_csv(url) | pandas.read_csv |
from donbot import Donbot
from lxml import html, cssselect
from getvotes import GetVotes
import numpy as np
import pandas as pd
import texthero as hero
obj = GetVotes(username="skitter30", password="*")
target_user = "Auro"
#City that never sleeps, BoTC, White flag, Newbie 1900, Mini 2040
threads = {
... | pd.DataFrame([[post, threads['alignment'][ind], threads['name'][ind]] for post in posts]) | pandas.DataFrame |
import os
import subprocess
from math import floor
from textwrap import dedent
import pandas as pd
import numpy as np
from plotnine import *
from qiime2 import (
Artifact,
Metadata
)
from qiime2.plugins.taxa.methods import collapse
from qiime2.plugins.feature_table.methods import rarefy
from scripts.qiime2_helper.m... | pd.Series(abundance_collapsed_df["Taxon"]) | pandas.Series |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
# ============================================================================================= #
# DS_generator.py #
# Author: <NAME> ... | pd.unique(DTI['Gene'].values) | pandas.unique |
# Created Date: 12/09/2018
# Modified Date:
#
# Implements the Early Warning Alert Algorithm of Fire Crisis Classification module
# based on the forecasting weather data from FMI. It calculates the Fire Weather Index
# of Canadian Rating System.
# Also, it calculates the Fire Overall Crisis Level (PFRCL_Predicted Fire ... | pd.DataFrame(columns=['FWI_lin', 'FWI_near', 'FWI_cubic', 'FWI_max', 'FWI_min', 'FWI_std', 'FWI_mean']) | pandas.DataFrame |
"""Tests for `mllaunchpad.resource` module."""
# Stdlib imports
import json
import logging
import os
from collections import OrderedDict
from random import random
from unittest import mock
# Third-party imports
import numpy as np
import pandas as pd
import pytest
# Project imports
from mllaunchpad import resource as... | pd.DataFrame(args1) | pandas.DataFrame |
import pandas as pd
from pathlib import Path
from datetime import datetime
url="https://www.dshs.state.tx.us/coronavirus/TexasCOVID19DailyCountyFatalityCountData.xlsx"
#get data from 2020, 2021, and 2022: could be cleaned more
df_2020 = pd.read_excel(url,sheet_name=0, index_col=0,parse_dates=[0])
df_2020 = df_2020[1:... | pd.to_datetime(df_all.date, format='%m/%d/%Y') | pandas.to_datetime |
import streamlit as st
from bs4 import BeautifulSoup
import requests
import pandas as pd
import re
import ast
import base64
def local_css(file_name):
with open(file_name) as f:
st.markdown(f'<style>{f.read()}</style>', unsafe_allow_html=True)
local_css("style.css")
st.write("""
# Steam Community Market -... | pd.to_datetime(final_df['timestamp'],format='%b %d %Y %H') | pandas.to_datetime |
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.date_range("1999-12-31", freq="A-DEC", periods=7) | pandas.date_range |
# category: ["region","city","parent_category_name","category_name","user_type","image_top_1","param_1","param_2","param_3"]("user_id"?)
# 1. category base count features
# 2. category embedding.
from utils import *
import pandas as pd
import gc
train = pd.read_csv("../input/train.csv", parse_dates = ["activation_date"... | pd.merge(train, d, on=[col, "dayofweek"], how="left") | pandas.merge |
import numpy as np
import pandas as pd
from sklearn.ensemble import ExtraTreesClassifier
from cause.plotter import Plotter
from cause.predictor import ClassificationSet
class Breakdown():
def __init__(self, data, weights, algos, name):
self.__data = data
self.__weights = weights
self.__... | pd.DataFrame(columns=["order", "value", "name"]) | pandas.DataFrame |
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()
new_expect = pd.DataFrame()
new_expect["Some Feature"] = [3, 4, 5]
new_expect["Answer... | pd.DataFrame() | pandas.DataFrame |
import pandas as pd
from iexfinance.base import _IEXBase
from iexfinance.utils import _handle_lists, no_pandas
from iexfinance.utils.exceptions import IEXSymbolError, IEXEndpointError
class StockReader(_IEXBase):
"""
Base class for obtaining data from the Stock endpoints of IEX.
"""
# Possible option... | pd.DatetimeIndex(df["date"]) | pandas.DatetimeIndex |
import sys
import numpy as np
import pandas as pd
import tensorflow as tf
from sklearn.preprocessing import StandardScaler
from Phase2Vec import Phase2Vec
from Atom2Vec.Atom2Vec_encoder import Atom2Vec
from AtomicModel import Endtoend
from utils import *
def get_phases(datafile=None, phases=None, mode='classify', maxl... | pd.DataFrame({'phases': test}) | pandas.DataFrame |
from evalutils.exceptions import ValidationError
from evalutils.io import CSVLoader, FileLoader, ImageLoader
import json
import nibabel as nib
import numpy as np
import os.path
from pathlib import Path
from pandas import DataFrame, MultiIndex
import scipy.ndimage
from scipy.ndimage.interpolation import map_coordinates,... | DataFrame() | pandas.DataFrame |
import math
import copy
import numpy as np
import pandas as pd
import scipy.interpolate as interp
import scipy.fftpack as fft
from .base import QualityControlBaseAccessor
from .utils import *
#=============================General Accessors==============================#
@pd.api.extensions.register_series_accessor("qc... | pd.Series(out_dict, name=self._obj.name) | pandas.Series |
# -*- coding: utf-8 -*-
import pytest
import numpy as np
import pandas as pd
from .example import replace_all_nulls_with_value
@pytest.fixture
def df_none_missing():
""" return a 3x3 dataframe with no missing values """
cols = ['a', 'b', 'c']
data = [[0, 1, 0], [0, 0, 1], [1, 1, 1]]
return pd.DataFra... | pd.notnull(new_df.values) | pandas.notnull |
import datetime
import numpy as np
import pytest
import pytz
import pandas as pd
from pandas import Timedelta, merge_asof, read_csv, to_datetime
import pandas._testing as tm
from pandas.core.reshape.merge import MergeError
class TestAsOfMerge:
def read_data(self, datapath, name, dedupe=False):
path = da... | tm.assert_frame_equal(result, expected) | pandas._testing.assert_frame_equal |
import arcpy
import pandas as pd
import ppa_input_params as p
import npmrds_data_conflation as ndc
def get_wtdavg_truckdata(in_df, col_name):
len_cols = ['{}_calc_len'.format(dirn) for dirn in p.directions_tmc]
val_cols = ['{}{}'.format(dirn, col_name) for dirn in p.directions_tmc]
wtd_dict = dict(zip... | pd.isnull(in_df[dirval][0]) | pandas.isnull |
# -*- coding: utf-8 -*-
# @File : plot_utils.py
# @Author : <NAME>
# @Time : 2021/10/29 下午9:56
# @Disc :
import matplotlib.pyplot as plt
import seaborn as sns
import pandas as pd
import numpy as np
import os
from xgboost.sklearn import XGBModel
from typing import List
from sklearn.metrics import roc_curve, cl... | pd.Series(model.feature_importances_, index=feature_cols) | pandas.Series |
import pandas as pd
import csv
def save_table_dict_csv(fn, table_dict):
fn_csv = fn + '.csv'
with open(fn_csv, 'w') as csvfile:
writer = csv.DictWriter(csvfile,
fieldnames=table_dict.keys(),
lineterminator='\n')
writer.writeheader... | pd.DataFrame(table_dict) | pandas.DataFrame |
import calendar
from ..utils import search_quote
from datetime import datetime, timedelta
from ..utils import process_dataframe_and_series
import rich
from jsonpath import jsonpath
from retry import retry
import pandas as pd
import requests
import multitasking
import signal
from tqdm import tqdm
from typing import (Dic... | pd.concat(dfs, axis=0, ignore_index=True) | pandas.concat |
import os
import csv
import pandas as pd
import numpy as np
import librosa
import tqdm
def load_audio_file(path):
audio_data, sample_rate = librosa.load(path)
return audio_data, sample_rate
def extract_features(audio_data, sample_rate):
sig_mean = np.mean(abs(audio_data))
sig_std = np.std(audio_dat... | pd.DataFrame(data=features, index=df.index) | pandas.DataFrame |
import numpy as np
import pandas as pd
from PyEMD import EMD, Visualisation
import scipy
import math
import scipy.io
import scipy.linalg
import sklearn.metrics
import sklearn.neighbors
from sklearn import metrics
from sklearn import svm
import matplotlib.pyplot as plt
import torch
from torch import nn
from torch.uti... | pd.read_csv('../TCA_traffic/data/siteM4_2168B_20210101_20210131.csv') | pandas.read_csv |
from lxml import etree
import requests
from io import BytesIO
import pandas
from zipfile import ZipFile
popoular_name_url = "https://uscode.house.gov/popularnames/popularnames.htm"
table3_zip_url = "https://uscode.house.gov/table3/table3-xml-bulk.zip"
if __name__ == "__main__":
print("Downloading Popular Name Li... | pandas.DataFrame.from_records(res) | pandas.DataFrame.from_records |
# -*- coding: utf-8 -*-
"""
@author: <NAME>
"""
import pandas as pd
import numpy as np
from sklearn.feature_selection import SelectKBest, f_classif
from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier
class FeatureImportance:
def __init__(self, df, resp):
self.dataframe = df
self... | pd.DataFrame({'Predictors': self.predictors, 'RF': self._rf_imp}) | pandas.DataFrame |
import pandas as pd
import numpy as np
import mapping as mp
from . import strategy
def get_relative_to_expiry_instrument_weights(dates, root_generics, expiries,
offsets, all_monthly=False,
holidays=None):
"""
Generate ... | pd.offsets.MonthEnd(1) | pandas.offsets.MonthEnd |
from nlpsummarize import nlp
import pandas as pd
def test_init_1():
"""
Test initialization of the class NLPFrame
"""
initial_df = nlp.NLPFrame({'text_col' : ['Today is a beautiful Monday and I would love getting a coffee. However, startbucks is closed.','It has been an amazing day today!']}, index ... | pd.DataFrame() | pandas.DataFrame |
# -*- coding: utf-8 -*-
"""
api.py
Provides the API for papermill
"""
from __future__ import unicode_literals
import os
import IPython
from IPython.display import display as ip_display, Markdown
import pandas as pd
from six import string_types
from .exceptions import PapermillException
from .iorw import load_notebo... | pd.DataFrame(columns=['filename', 'cell', 'value', 'type']) | pandas.DataFrame |
import datetime
import re
from warnings import (
catch_warnings,
simplefilter,
)
import numpy as np
import pytest
from pandas._libs.tslibs import Timestamp
import pandas as pd
from pandas import (
DataFrame,
HDFStore,
Index,
Int64Index,
MultiIndex,
RangeIndex,
... | ensure_clean_store(setup_path) | pandas.tests.io.pytables.common.ensure_clean_store |
import time
import requests
import numpy as np
import pandas as pd
from tradingfeatures import apiBase
from tradingfeatures.apis.bitfinex.base import bitfinexBase
class bitfinexShortLong(bitfinexBase):
def __init__(self):
super(bitfinexShortLong, self).__init__()
self.name = 'bitfinex_shortlong'... | pd.DataFrame(data, columns=self.columns) | pandas.DataFrame |
import pandas as pd
import numpy as np
import pytest
from sklearn.base import clone
from sklearn.pipeline import Pipeline
from sklearn.model_selection import GridSearchCV
from sklearn.linear_model import LogisticRegression
from pandas_transformers.transformers import PandasOneHotEncoder, PandasTfidfVectorizer
class ... | pd.Series([0, 0, 1], dtype=np.uint8) | pandas.Series |
#Modules to install via pip pandas,ipynb
import os
import sys
import time
from lib import trace_classification
sys.path.append('../')
import os
import pandas as pd
import numpy as np
import json
#Modules to install via pip pandas,ipynb
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import jso... | pd.DataFrame(d) | pandas.DataFrame |
import click
import logging
import signal
import time
import code
import os
import re
import subprocess
import pdb
import glob
import IPython
import bpython
import collections
import pandas as pd
from config import user_config
from typing import Optional, List, Dict, Callable, Union
from pprint import pformat
from .ba... | pd.DataFrame() | pandas.DataFrame |
from __future__ import print_function
from datetime import datetime, timedelta
import numpy as np
import pandas as pd
from pandas import (Series, Index, Int64Index, Timestamp, Period,
DatetimeIndex, PeriodIndex, TimedeltaIndex,
Timedelta, timedelta_range, date_range, Float64Index... | tm.assert_numpy_array_equal(idx.asi8, idx3.asi8) | pandas.util.testing.assert_numpy_array_equal |
# -*- coding: utf-8 -*-
# pylint: disable-msg=W0612,E1101
import itertools
import warnings
from warnings import catch_warnings
from datetime import datetime
from pandas.types.common import (is_integer_dtype,
is_float_dtype,
is_scalar)
from pandas.compat... | Series([0, 2, 4]) | pandas.core.api.Series |
import numpy as np
import pandas as pd
import os
import sys
sys.path.append('/home/akagi/github/RIPS_kircheis/RIPS')
import rect_grid
import cable
acsr = [ u'Bittern', u'Bluebird', u'Bluejay', u'Bobolink', u'Bunting',
u'Canary', u'Cardinal', u'Chickadee', u'Chukar', u'Cochin',
u'Co... | pd.concat([acsr_df.loc[50], cable_i.models['acsr'].T], axis=1) | pandas.concat |
import csv
import logging
import json
import math
import random
import re
import time
import urllib.request
from pathlib import Path
import sys
import pandas as pd
import get_edgar.common.my_csv as mc
logger = logging.getLogger(__name__)
EDGAR_PREFIX = "https://www.sec.gov/Archives/"
SEC_PREFIX = "https://www.sec.go... | pd.DateOffset(months=mperiods) | pandas.DateOffset |
import os
import sdg
import yaml
import pandas as pd
skip_values_in_columns = [
'GeoCode',
'Group',
]
skip_column_names = [
'GeoCode',
'Group',
'Units'
]
translations_should_include = {}
translation_columns = {}
data_pattern = os.path.join('data', '*-*.csv')
data_input = sdg.inputs.InputCsvData(... | pd.isna(disaggregations[column]) | pandas.isna |
""" analyze.py - experiment analysis script"""
import music_trees as mt
from collections import OrderedDict
import glob
from pathlib import Path
import random
from itertools import combinations, permutations
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from natsort import natsorted
from scip... | pd.DataFrame() | pandas.DataFrame |
# -*- coding: utf-8 -*-
"""
Functions for importing mssql data.
"""
import pandas as pd
import numpy as np
from datetime import datetime
from pdsql.util import create_engine, get_pk_stmt, compare_dfs
try:
from geopandas import GeoDataFrame
from shapely.wkb import loads
from pycrs import parse
except Import... | pd.to_datetime(to_date, errors='coerce') | pandas.to_datetime |
# -*- coding: utf-8 -*-
__author__ = "gao"
import pandas as pd
from AmazingQuant.data_center.mongosconn import MongoConn
from AmazingQuant.constant import DatabaseName, Period, RightsAdjustment
import AmazingQuant.utils.data_transfer as data_transfer
class GetData(object):
def __init__(self):
self.conn... | pd.DataFrame(result_dict) | pandas.DataFrame |
# 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 os
import shutil
import time
from copy import copy
import pandas as pd
import numpy as np
from tqdm import tqdm
from datetime import datetime
from pathlib import Path
from glob import glob
import libs... | pd.read_csv(pathList[0]) | pandas.read_csv |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.