prompt stringlengths 19 1.03M | completion stringlengths 4 2.12k | api stringlengths 8 90 |
|---|---|---|
"""
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 importlib.resources
import pandas as pd
import ... | pd.BooleanDtype() | pandas.BooleanDtype |
import pandas as pd
from sklearn.model_selection import KFold
from sklearn.preprocessing import LabelEncoder
from copy import deepcopy
import re
import sys
sys.path.insert(0, './code')
import dataloader # noqa: E402
class AmtTrainHandler():
def __init__(self):
self.ylabels = [
"2", "6", "10"... | pd.concat([tmp_train, train_feat], axis=1) | pandas.concat |
#!/usr/bin/env python
'''
Parses input/output formats,
manages transformations
'''
import csv
import re
import sys
from numpy import array
import numpy as np
import pandas as pd
from pandas import *
from . import config
from . import distance
from . import store
from . import stats
from . import HSIC
def wrap_feat... | pd.DataFrame(self.orginal_dataset2, index = self.outName2, columns = self.outHead2, dtype=float) | pandas.DataFrame |
# Copyright 2020 Google LLC
#
# 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
#
# https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in w... | pd.DataFrame(l, columns=['Name', 'IoU', 'F-Score (tau)', 'Chamfer']) | pandas.DataFrame |
# -*- coding: utf-8 -*-
"""
Created on Tue Sep 14 10:59:05 2021
@author: franc
"""
import os
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from pathlib import Path
import json
from collections import Counter, OrderedDict
import math
import torchtext
from torchtext.data import get_tokenizer
... | pd.DataFrame({'spanish': ["chingue"], 'english': ["skunk"]}) | pandas.DataFrame |
"""
Extract basic statistical features from data
"""
import pandas as pd
from utils.timer import Timer
# -------------------------------------------------------------------------------------------------
TRAIN_FILE = 'data/train_preliminary/train.pkl'
TEST_FILE = 'data/test/test.pkl'
TRAIN_STAT_FEAT = 'data/train_feat/... | pd.qcut(test_stat_basic['time_nunique'], q=10) | pandas.qcut |
#
# Licensed to the Apache Software Foundation (ASF) under one or more
# contributor license agreements. See the NOTICE file distributed with
# this work for additional information regarding copyright ownership.
# The ASF licenses this file to You under the Apache License, Version 2.0
# (the "License"); you may not us... | pd.Index(["A", "B", "C"], name="index") | pandas.Index |
"""Unit tests for orbitpy.coveragecalculator.gridcoverage class.
``TestGridCoverage`` class:
* ``test_execute_0``: Test format of output access files.
* ``test_execute_1``: Roll Circular sensor tests
* ``test_execute_2``: Yaw Circular sensor tests
* ``test_execute_3``: Pitch Circular sensor tests
* ``test_execute_4``... | pd.read_csv(out_file_access, skiprows = [0,1,2,3]) | pandas.read_csv |
# import the required libraries:
# import os, sys
from keras.models import Model
from keras.layers import Input, LSTM, GRU, Dense, Embedding
from keras.preprocessing.text import Tokenizer
from keras.preprocessing.sequence import pad_sequences
# from keras.utils import to_categorical
import numpy as np
# import pickle
... | pd.DataFrame({'english':eng_len, 'french':fren_len}) | pandas.DataFrame |
"""
File name: models.py
Author: <NAME>
Date created: 21.05.2018
This file contains the Model metaclass object that is used for implementing
the given models. It contains a class object for each individual model type.
"""
import os
import pickle
from abc import ABCMeta, abstractmethod
from typing import Dict, List, ... | pd.get_dummies(self.y_tr) | pandas.get_dummies |
# -*- coding: utf-8 -*-
"""
Created on Mon Sep 23 15:45:51 2019
@author: lucia
"""
import pandas as pd
inputCSV = | pd.read_csv("./IdiomasCSV.csv") | pandas.read_csv |
# feature generation & selection
# sample
# full
# kaggle 0.14481
# minimize score
import os
import json
import sys # pylint: disable=unused-import
from time import time
import csv
from pprint import pprint # pylint: disable=unused-import
from timeit import default_timer as timer
import lightgbm as lgb
import numpy ... | pd.set_option('display.max_columns', None) | pandas.set_option |
#!/usr/bin/env python
"""
@author: cdeline
bifacial_radiance.py - module to develop radiance bifacial scenes, including gendaylit and gencumulativesky
7/5/2016 - test script based on G173_journal_height
5/1/2017 - standalone module
Pre-requisites:
This software is written for Python >3.6 leveraging many Anaconda... | pd.DatetimeIndex(data_ymd) | pandas.DatetimeIndex |
# Copyright 1999-2021 Alibaba Group Holding Ltd.
#
# 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 a... | pd.RangeIndex(10) | pandas.RangeIndex |
import os
import numpy as np
import pandas as pd
from sklearn.ensemble import RandomForestClassifier
# Boiling
filename = '009Boiling-2018-02-15-labeled.csv'
data = os.path.join(os.getcwd(), 'api_vlad/data/new/', filename)
data1 = pd.read_csv(data, delimiter = ',')
filename = '010Boiling-2018-02-16-labeled.csv'
data ... | pd.concat([data1, data2, data3, data4], ignore_index=True) | pandas.concat |
# -*- encoding:utf-8 -*-
import pandas as pd
import numpy as np
import datetime
# from datetime import datetime
dire = '../../data/'
start = datetime.datetime.now()
orderHistory_train = pd.read_csv(dire + 'train/orderHistory_train.csv', encoding='utf-8')
orderFuture_train = pd.read_csv(dire + 'train/orderFuture_train... | pd.read_csv(dire + 'train/userComment_train.csv', encoding='utf-8') | pandas.read_csv |
from datetime import datetime, timedelta
import numpy as np
import pandas as pd
import geopandas as gpd
import multiprocessing as mp
import re
from typing import List
from enums import Properties, Organization
from os import path
def __add_features_to_geo_dataframe(df):
df["geometry"] = df.geometry.simplify(toler... | pd.merge(station_gaps_df, station_join_df, on="StationCode", how="left") | pandas.merge |
import pandas as pd
from app import cache
from model.ynab_api import api
@cache.memoize()
def get_categorized_transactions(budget_id, hierarchy, category_names):
transactions_df = api.get_transactions(budget_id)
transactions_df = pd.merge(transactions_df, hierarchy,
left_on="ca... | pd.DataFrame(df) | pandas.DataFrame |
import networkx as nx
import numpy as np
from cleaning import *
import pandas as pd
from networkx.algorithms.community import greedy_modularity_communities
import os
import concurrent.futures
from concurrent.futures import ThreadPoolExecutor
import itertools
def centrality(adj , node_dict, type):
G = nx.convert_ma... | pd.DataFrame() | pandas.DataFrame |
from __future__ import division
from datetime import datetime
import sys
if sys.version_info < (3, 3):
import mock
else:
from unittest import mock
import pandas as pd
import numpy as np
import random
from nose.tools import assert_almost_equal as aae
import bt
import bt.algos as algos
def test_algo_name():... | pd.DataFrame(index=dts, columns=['c1', 'c2'], data=100) | pandas.DataFrame |
#!/usr/bin/python3.8
# -*- coding: utf-8 -*-
import numpy as np
import pickle
import time
import datetime
import pandas as pd
import Klines
def compute_features(kline_dictionary, btc_price, cmc_frame):
pump_list = pd.read_csv("./data/coin-pump.csv")
rm_key = []
for symbol in kline_dictionary.keys():
kline_dict... | pd.to_datetime(temp_df.index) | pandas.to_datetime |
"""
Copyright 2019 <NAME>.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing,
software distribut... | pd.Timestamp(2019, 5, 24) | pandas.Timestamp |
import os
import json
import argparse
import numpy as np
import pandas as pd
from scipy import sparse
from joblib import Parallel, delayed
from temprel.models import relevance
from temprel.rdkit import smiles_to_fingerprint, templates_from_smarts_list
from temprel.evaluate.diversity import diversity
from temprel.evalu... | pd.DataFrame.from_dict(acc, orient='index', columns=model.metrics_names) | pandas.DataFrame.from_dict |
#!/usr/bin/python
import os, math
import pandas as pd
import numpy as np
np.random.seed(42)
import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.autograd import Variable
import torch.optim as optim
torch.manual_seed(42)
from sklearn.metrics import roc_auc_score
from sklearn.model_selection i... | pd.read_csv("../../../data/brain/coordinates.csv", index_col=0) | pandas.read_csv |
from ..multiagentenv import MultiAgentEnv
import numpy as np
import pandapower as pp
from pandapower import ppException
import pandas as pd
import copy
import os
from collections import namedtuple
from .pf_res_plot import pf_res_plotly
from .voltage_barrier.voltage_barrier_backend import VoltageBarrier
def convert(d... | pd.read_csv(demand_path, index_col=None) | pandas.read_csv |
import pytest
import numpy as np
import pandas as pd
from sklearn.utils.validation import FLOAT_DTYPES
from sklearn.utils import estimator_checks
from sklego.common import flatten
from sklego.preprocessing import ColumnCapper
from tests.conftest import transformer_checks, general_checks
@pytest.mark.parametrize("te... | pd.DataFrame({'a': [np.nan, np.nan, np.nan], 'b': [11, 12, 13]}) | pandas.DataFrame |
"""Utility functions for evaluating model outputs."""
import logging
import re
from collections import defaultdict
from pathlib import Path
from typing import Dict, Tuple, Union
import numpy as np
import pandas as pd
from ms3 import Parse
import harmonic_inference.utils.harmonic_constants as hc
import harmonic_infere... | pd.DataFrame(labels_list) | pandas.DataFrame |
import re
import numpy as np
import pytest
from pandas import DataFrame, Series
import pandas.util.testing as tm
@pytest.mark.parametrize("subset", ["a", ["a"], ["a", "B"]])
def test_duplicated_with_misspelled_column_name(subset):
# GH 19730
df = DataFrame({"A": [0, 0, 1], "B": [0, 0, 1], "C": [0, 0, 1]})
... | tm.assert_series_equal(result, expected) | pandas.util.testing.assert_series_equal |
import cPickle
import os
import sys
import scipy as sc
import operator
import numpy as np
import pandas as pd
from scipy import sparse
import xgboost as xgb
from sklearn import model_selection, preprocessing, ensemble
from sklearn.metrics import log_loss
from sklearn.feature_extraction.text import TfidfVecto... | pd.concat([testIdSTCKNET,out_df3],axis=1) | pandas.concat |
import pandas as pd
import pandas_profiling as pdp
def read_csv_to_df(file_name):
try:
df = | pd.read_csv(file_name) | pandas.read_csv |
#!/usr/bin/env python
# coding: utf-8
# ## Topic: Apriori algorithm, generate and print out all the association rules.
#
# #### Name: <NAME>
#
# #### Subject: CS 634 Data mining
#
# ## Loading Libraries
# In[1]:
#importing all libraries
import pandas as pd
import numpy as np
import csv
from itertools import com... | pd.read_csv(file) | pandas.read_csv |
#######
# Here we'll make a scatter plot with fake data that is
# intentionally denser on the left, with overlapping data points.
# We'll use Selection Data to uncover the difference.
######
import dash
import dash_core_components as dcc
import dash_html_components as html
from dash.dependencies import Input, Output
im... | pd.concat([df1,df2,df3]) | pandas.concat |
import torch
import pandas as pd
from datetime import datetime
import torch.nn.functional as F
import torch.nn as nn
import numpy as np
from utils import haversine_np, get_perp
from ml import FFNet
class ETAInf:
def __init__(self, path_to_model, path_to_features, path_to_embs):
self.model = FFNet(152, Fals... | pd.read_csv(self.wfile, delimiter=";") | pandas.read_csv |
import os
import copy
import pytest
import numpy as np
import pandas as pd
import pyarrow as pa
from pyarrow import feather as pf
from pyarrow import parquet as pq
from time_series_transform.io.base import io_base
from time_series_transform.io.numpy import (
from_numpy,
to_numpy
)
from time_series_transfor... | pd.testing.assert_frame_equal(testData,expandTime_remove,check_dtype=False) | pandas.testing.assert_frame_equal |
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="W", year=2007, month=3, day=31) | pandas.Period |
import matplotlib.pyplot as plt
from sklearn.linear_model import LinearRegression
from sklearn.preprocessing import PolynomialFeatures
import numpy as np
from pylab import rcParams
##########################################################################################
# Designed and developed by <NAME>
# Date : 11 ... | pd.to_numeric(batsman['Runs']) | pandas.to_numeric |
# Copyright (c) 2020, NVIDIA CORPORATION.
import numpy as np
import pandas as pd
import pytest
import cudf
from cudf.core import DataFrame, Series
from cudf.tests.utils import (
INTEGER_TYPES,
NUMERIC_TYPES,
assert_eq,
assert_exceptions_equal,
)
def test_series_replace():
a1 = np.array([0, 1, 2... | pd.DataFrame({"A": ["a", "bc", "cde", "fghi"]}) | pandas.DataFrame |
# Copyright 2021 <NAME>. All Rights Reserved.
#
# 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 agree... | pd.DataFrame.from_records(results) | pandas.DataFrame.from_records |
import pandas as pd
import pytest
from pandas.testing import assert_frame_equal
from sklearn.pipeline import Pipeline
from hcrystalball.feature_extraction import HolidayTransformer
@pytest.mark.parametrize(
"X_y_with_freq, country_code, country_code_column, country_code_column_value, extected_error",
[
... | pd.DataFrame(expected, index=X.index) | pandas.DataFrame |
import datetime as dt
import numpy as np
import pathlib
import pandas as pd
from functools import partial
from .deprecations import deprecated_kwargs
from . import utils
from copy import deepcopy
from collections import OrderedDict
from collections.abc import Iterable
from openpyxl import load_workbook
from openpyxl.... | pd.ExcelWriter(path, engine='openpyxl', **kwargs) | pandas.ExcelWriter |
import pandas as pd
import pickle
import gensim
import gensim.corpora as corpora
from gensim.utils import simple_preprocess
import numpy as np
import datetime as dt
from LDA import remove_stopwords, lemmatization, make_bigrams, sent_to_words
import warnings
warnings.filterwarnings("ignore",category=DeprecationWarning... | pd.merge(users,interests, left_on='uid', right_on='uid', how='left') | pandas.merge |
import pandas as pd
from pandas import Period, offsets
from pandas.util import testing as tm
from pandas.tseries.frequencies import _period_code_map
class TestFreqConversion(tm.TestCase):
"Test frequency conversion of date objects"
def test_asfreq_corner(self):
val = Period(freq='A', year=2007)
... | Period(freq='W', year=2007, month=1, day=7) | pandas.Period |
import numpy as np
import pandas as pd
import xarray as xr
import typing as tp
NdType = tp.Union[np.ndarray, pd.DataFrame, xr.DataArray, pd.Series]
NdTupleType = tp.Union[
tp.Tuple[NdType],
tp.Tuple[NdType, NdType],
tp.Tuple[NdType, NdType, NdType],
tp.Tuple[NdType, NdType, NdType, NdType],
]
XR_TIME_... | pd.Series(np_result, index=nd_args[0].index) | pandas.Series |
"""Module containg test of chela modules"""
import sys
sys.path.append('chela/')
import chela
import pandas as pd
import numpy as np
import pytest
@pytest.mark.parametrize('basic_check_formula',
[
'',
'1',
... | pd.DataFrame() | pandas.DataFrame |
import warnings
import numpy as np
import pandas as pd
import re
import string
@pd.api.extensions.register_dataframe_accessor('zookeeper')
class ZooKeeper:
def __init__(self, pandas_obj):
# validate and assign object
self._validate(pandas_obj)
self._obj = pandas_obj
# define incor... | pd.notna(self._obj[i_col]) | pandas.notna |
from pyspark.sql import SparkSession
from pyspark.sql.functions import *
from MergeDataFrameToTable import MergeDFToTable
import numpy as np
import pandas as pd
from sklearn import cluster
spark = SparkSession.builder.enableHiveSupport().getOrCreate()
"""
outbound_data
"""
#----------------------------... | pd.DataFrame(full) | pandas.DataFrame |
"""Create figure 7 for paper."""
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
import os
import matplotlib.ticker as ticker
# Import global path and file variables
from settings import *
# read result of the same metric
# select the result on the two rows which represen... | pd.concat(df, axis=1) | pandas.concat |
# -*- coding: utf-8 -*-
import pytest
import numpy as np
from pandas.compat import range
import pandas as pd
import pandas.util.testing as tm
# -------------------------------------------------------------------
# Comparisons
class TestFrameComparisons(object):
def test_df_boolean_comparison_error(self):
... | pd.Period('2015-06', freq='M') | pandas.Period |
# AUTOGENERATED! DO NOT EDIT! File to edit: notebooks/04_Create_Acs_Indicators_Original.ipynb (unless otherwise specified).
__all__ = ['racdiv', 'pasi', 'elheat', 'empl', 'fam', 'female', 'femhhs', 'heatgas', 'hh40inc', 'hh60inc', 'hh75inc',
'hhchpov', 'hhm75', 'hhpov', 'hhs', 'hsdipl', 'lesshs', 'male', 'n... | pd.DataFrame() | pandas.DataFrame |
from IPython import get_ipython
get_ipython().magic('reset -sf')
import os, shutil
import re
import csv
from utils import bigrams, trigram, replace_collocation
from tika import parser
import timeit
import pandas as pd
from nltk.stem import PorterStemmer
import numpy as np
import pickle
import random
from scipy import ... | pd.Series(docs) | pandas.Series |
# Arithmetic tests for DataFrame/Series/Index/Array classes that should
# behave identically.
# Specifically for Period dtype
import operator
import numpy as np
import pytest
from pandas._libs.tslibs.period import IncompatibleFrequency
from pandas.errors import PerformanceWarning
import pandas as pd
from pandas impo... | tm.assert_index_equal(result, expected) | pandas.util.testing.assert_index_equal |
#!/usr/bin/python
import sys, getopt
import os
import pandas as pd
import numpy as np
import pyquaternion as pyq
from pyquaternion import Quaternion
from scipy import signal
from scipy.spatial.transform import Slerp
from scipy.spatial.transform import Rotation as R
def main(argv):
inputfile = ''
calfile = ''
... | pd.DataFrame() | pandas.DataFrame |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Sun Aug 26 16:16:58 2018
@author: rugantio
"""
import pandas as pd
df = pd.read_csv('./exploit.csv')
df['date'] = | pd.to_datetime(df['date']) | pandas.to_datetime |
import abc
import time, random
import pandas as pd
import os
import numpy as np
import benchutils as utils
import knowledgebases
from sklearn.feature_selection import SelectKBest, f_classif
from sklearn.preprocessing import StandardScaler
from sklearn.ensemble import RandomForestClassifier
from mlxtend.feature_selectio... | pd.DataFrame() | pandas.DataFrame |
from distutils.version import LooseVersion
from warnings import catch_warnings
import numpy as np
import pytest
from pandas._libs.tslibs import Timestamp
import pandas as pd
from pandas import (
DataFrame,
HDFStore,
Index,
MultiIndex,
Series,
_testing as tm,
bdate_range,
concat,
d... | tm.makeTimeDataFrame() | pandas._testing.makeTimeDataFrame |
import io
import json
import glob
import os
from PIL import Image
import xml.etree.ElementTree as ET
import tensorflow as tf
import numpy as np
import cv2
import pandas as pd
class DataAnnotator(object):
def __init__(self, classes):
self.classes = classes # array of class labels
def list_to_csv(self, annotation... | pd.DataFrame(annotations, columns=columns) | pandas.DataFrame |
import unittest
import pandas as pd
from runpandarun.dataset import Dataset, RESAMPLE_METHODS, RESAMPLE_INTERVALS
from runpandarun.store import Datastore
from runpandarun.storage import Storage
class Test(unittest.TestCase):
def setUp(self):
self.store = Datastore('./example/config.yml')
def test_i... | pd.concat([df1, df2]) | pandas.concat |
__author__ = '<NAME>'
import zipfile
import re
import pandas as pd
import numpy as np
from .. import data_helper as dh
def test_lahman_download(data_dir):
"""Verify the Lahman Data was downloaded, unzipped and reogranized."""
lahman_dir = data_dir / 'lahman'
raw_dir = lahman_dir / 'raw'
wrangled_dir ... | pd.UInt8Dtype() | pandas.UInt8Dtype |
# Arithmetic tests for DataFrame/Series/Index/Array classes that should
# behave identically.
# Specifically for Period dtype
import operator
import numpy as np
import pytest
from pandas._libs.tslibs.period import IncompatibleFrequency
from pandas.errors import PerformanceWarning
import pandas as pd
from pandas impo... | pd.Period("2012-01", freq="M") | pandas.Period |
#!/home/sunnymarkliu/softwares/anaconda3/bin/python
# _*_ coding: utf-8 _*_
"""
@author: SunnyMarkLiu
@time : 17-12-22 下午7:23
"""
from __future__ import absolute_import, division, print_function
import os
import sys
module_path = os.path.abspath(os.path.join('..'))
sys.path.append(module_path)
# remove warnings
im... | pd.to_datetime(history['orderTime'], unit='s') | pandas.to_datetime |
### keras playground 2.0 LSTM (univariate)###
import os
import pickle
import pandas as pd
import numpy as np
from keras.models import Sequential, load_model
from keras.layers import Dense, Activation, BatchNormalization, Dropout, \
LeakyReLU, LSTM
from keras import losses
from keras ... | pd.DataFrame() | pandas.DataFrame |
import collections
import os
import geopandas as gpd
import numpy as np
import pandas as pd
import requests
from datetime import datetime, timedelta
from typing import Tuple, Dict, Union
import pytz
from pandas.core.dtypes.common import is_string_dtype, is_numeric_dtype
from hydrodataset.data.data_base import DataSour... | pd.read_csv(gage_id_file, sep=",", dtype={0: str}) | pandas.read_csv |
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... | pd.DataFrame({"a": [1, 5, 10], "left_val": ["a", "b", "c"]}) | pandas.DataFrame |
import os
import numpy as np
import pandas as pd
import datetime as dt
import exchange_calendars
from dataclasses import dataclass, fields
from dateutil.tz import tzlocal, gettz
from dateutil.tz.tz import tzfile
from trader.common.logging_helper import setup_logging
logging = setup_logging(module_name='data')
from p... | pd.DataFrame([], columns=self.columns) | pandas.DataFrame |
#
# Copyright 2018 Quantopian, Inc.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in wr... | pd.Timedelta(1, "D") | pandas.Timedelta |
import multiprocessing
import time
import os
import glob
import json
import requests
import logging
import pandas as pd
import numpy as np
import configparser
from functools import partial
from elasticsearch import Elasticsearch
from daggit.core.io.io import Pandas_Dataframe, File_Txt
from daggit.core.io.io import Rea... | pd.DataFrame() | 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... | tm.assert_isinstance(result, DatetimeIndex) | pandas.util.testing.assert_isinstance |
# -*- coding: utf-8 -*-
"""
These the test the public routines exposed in types/common.py
related to inference and not otherwise tested in types/test_common.py
"""
from warnings import catch_warnings, simplefilter
import collections
import re
from datetime import datetime, date, timedelta, time
from decimal import De... | inference.is_list_like(obj) | pandas.core.dtypes.inference.is_list_like |
import numpy as np
import pandas as pd
from collections import defaultdict
import re
import csv
from bs4 import BeautifulSoup
import sys
import os
import multiprocessing as mp
os.environ['KERAS_BACKEND']='theano'
import keras
from keras.preprocessing.text import Tokenizer
from keras.preprocessing.sequence import pad_se... | pd.read_csv(server+"features/Empath_features1.csv") | pandas.read_csv |
# -*- coding: utf-8 -*-
"""
Created on Wed Apr 11 12:26:22 2018
@author: Jesus
"""
import pandas as pd
import geopandas as gpd
import datetime
import matplotlib
import matplotlib.pyplot as plt
import os
import imageio
from natsort import natsorted
import urllib.request as urllib2
from bs4 import Beaut... | pd.to_datetime(df[['year', 'month', 'day']]) | pandas.to_datetime |
import numpy as np
import scipy.stats as sp
import os
import pandas as pd
import h5py
import bokeh.io as bkio
import bokeh.layouts as blay
import bokeh.models as bmod
import bokeh.plotting as bplt
from bokeh.palettes import Category20 as palette
from bokeh.palettes import Category20b as paletteb
import plot_results a... | pd.DataFrame(freq_dict) | pandas.DataFrame |
#!/usr/bin/env python
import os
import sys
import pandas as pd
# This script finds all stressors in both files and only retain the items in base machine.
if len(sys.argv) != 4:
raise Exception("./merge.py <base machine name> <reference machine name> <destination folder>")
base_machine = sys.argv[1]
ref_machine ... | pd.merge(df_base, df_ref, how='inner', left_on='name', right_on=column_prefix+'name') | pandas.merge |
import sys
from pathlib import Path
import pandas as pd
from astropy.io import fits
try:
from tqdm.auto import tqdm
except ImportError:
TQDM_NOT_FOUND = True
else:
TQDM_NOT_FOUND = False
def find_best_header(path):
hdul = fits.open(path)
best_hdu = None
while hdul:
hdu = hdul.pop(0)
... | pd.Series(headerdict) | pandas.Series |
''' Datasets
This file contains definitions for our CIFAR, ImageFolder, and HDF5 datasets
'''
import os
import os.path
import sys
from PIL import Image
import numpy as np
from tqdm import tqdm, trange
import matplotlib.pyplot as plt
import random
import pandas as pd
from multiprocessing import Pool
# f... | pd.DataFrame(columns=columns) | pandas.DataFrame |
from datetime import datetime
import numpy as np
import pytest
import pandas as pd
from pandas import (
Categorical,
CategoricalIndex,
DataFrame,
Index,
MultiIndex,
Series,
qcut,
)
import pandas._testing as tm
def cartesian_product_for_groupers(result, args, names, fill... | tm.assert_frame_equal(result, expected) | pandas._testing.assert_frame_equal |
#coding:utf-8
from PyQt5 import QtWidgets, QtWidgets
from PyQt5.QtGui import QImage, QPixmap
from PyQt5.QtWidgets import *
from PyQt5.QtCore import *
import sys
import cv2
import os
import cv2
import numpy as np
import time
import os
from PIL import Image, ImageDraw, ImageFont
import scipy.misc
import pickle
import d... | pd.read_excel(dirName, sheet_name=self.sheetName) | pandas.read_excel |
# Standard
import threading
# Numerical
import numpy as np
import pandas as pd
from scipy.stats import binom_test
from joblib import Parallel, delayed
# Graphical
from matplotlib import pyplot as plt
from matplotlib.colors import LinearSegmentedColormap
import seaborn as sns
# Local repo
from tree_explainer.utilitie... | pd.concat((df['root'], df[features_order]), axis=1) | pandas.concat |
#-*- coding:utf-8 -*-
from sklearn.feature_extraction.text import CountVectorizer
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.metrics.pairwise import euclidean_distances
from sklearn.metrics.pairwise import cosine_similarity
from sklearn.metrics import adjusted_rand_score
from sklearn.me... | pd.DataFrame(data=mat3,index=df1_index,columns=df1_index) | pandas.DataFrame |
import pandas as pd
import os
import re
from pathlib import Path
from utilities.generic.file_finder import FileFinder
def list_diff(li1, li2):
"""Returns the subset of lists that are present in li1 but absent in li2.
Args:
li1: The first list (a superset of li2).
li2: The second ... | pd.read_csv(v, sep=";", names=["t", "sample", "val"]) | pandas.read_csv |
from __future__ import division
from datetime import datetime
import sys
if sys.version_info < (3, 3):
import mock
else:
from unittest import mock
import pandas as pd
import numpy as np
from nose.tools import assert_almost_equal as aae
import bt
import bt.algos as algos
def test_algo_name():
class Tes... | pd.DataFrame(index=dts, columns=['c1', 'c2'], data=100.) | pandas.DataFrame |
import numpy as np
import pandas as pd
import pandas.util.testing as tm
import pytest
import os
from time import sleep
import pathlib
import dask
import dask.dataframe as dd
from dask.utils import tmpfile, tmpdir, dependency_depth
from dask.dataframe.utils import assert_eq
def test_to_hdf():
pytest.importorskip... | tm.assert_frame_equal(df, out[:]) | pandas.util.testing.assert_frame_equal |
#!/usr/bin/env python3
import sys
import pandas as pd
import numpy as np
import json
from datetime import datetime
from hashlib import md5
import os.path as path
import argparse
import os.path as path
import pysolr
from uuid import uuid1
DEBUG = True
filename = 'output/PATH_005'
filename = 'output/PATH_147'
filename... | pd.to_datetime(this_frame['Time of Extract'] + this_frame['Date of Extract'], format='%H%M%d%m%y') | pandas.to_datetime |
#!/usr/bin/env python
# -*- coding: utf-8 -*
import os
import csv
import pandas as pd
import numpy as np
import dask.dataframe as dd
from dask.diagnostics import ProgressBar
from sklearn.preprocessing import scale
from scipy.stats import ks_2samp
from .utils import CSV_READ_FORMAT, CSV_WRITE_FORMAT
from .utils impor... | pd.Series({'ks_test': ks, 'pvalue': pvalue}) | pandas.Series |
#!/usr/bin/env python
# coding: utf-8
# In[1]:
from datetime import datetime, timedelta
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
import seaborn as sns
import tensorflow as tf
from IPython.display import HTML
from matplotlib import animation
from sklearn.preprocessing import MinMaxScale... | pd.DataFrame(df_log) | pandas.DataFrame |
"""
Randen: Random DataFrame Generator
A small utility to generate random dataframes for testing, benchmarking etc. purposes
Supported dataframe types:
- string
- datetime
- char
- int
- float
- bool
- mix(provide column types)
TODO:
- Add Null ratio support
- Add Documentat... | pd.DataFrame() | pandas.DataFrame |
import pandas as pd
from bs4 import BeautifulSoup as s
import requests
from selenium import webdriver
from selenium.webdriver.common.by import By
from webdriver_manager.chrome import ChromeDriverManager
import time
import random
r = requests.get('https://www.goodreads.com/search?utf8=%E2%9C%93&q=harry+potter&search_ty... | pd.read_csv('lightning.csv') | pandas.read_csv |
"""
This function calculates statistical values and performs multivariate
statistics. The values from the **results.csv** file are used for this.
A PCA and an LDA are performed. Corresponding plots are created for this.
:info: In the calculate function, parameters of the measurements can be deleted
from the evaluat... | pd.DataFrame() | pandas.DataFrame |
"""
Module contains tools for collecting data from various remote sources
"""
import warnings
import tempfile
import datetime as dt
import time
from collections import defaultdict
import numpy as np
from pandas.compat import(
StringIO, bytes_to_str, range, lmap, zip
)
import pandas.compat as compat
from pandas... | zip(urls, names) | pandas.compat.zip |
"""Tests for the sdv.constraints.tabular module."""
import uuid
import numpy as np
import pandas as pd
import pytest
from sdv.constraints.errors import MissingConstraintColumnError
from sdv.constraints.tabular import (
Between, ColumnFormula, CustomConstraint, GreaterThan, Negative, OneHotEncoding, Positive,
... | pd.Series([True, False, False]) | pandas.Series |
import unittest
import pandas as pd
import numpy as np
from pandas.testing import assert_frame_equal
from msticpy.analysis.anomalous_sequence import sessionize
class TestSessionize(unittest.TestCase):
def setUp(self):
self.df1 = pd.DataFrame({"UserId": [], "time": [], "operation": []})
self.df1_... | pd.to_timedelta(4, "min") | pandas.to_timedelta |
from __future__ import print_function
import boto3
import os, sys
import json
from neptune_python_utils.gremlin_utils import GremlinUtils
from neptune_python_utils.endpoints import Endpoints
from gremlin_python.process.graph_traversal import __
from gremlin_python.process.traversal import Column
from io import BytesIO... | pd.DataFrame.from_dict(input_event, orient='index') | pandas.DataFrame.from_dict |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import pytest
import pandas as pd
import pandas_should # noqa
class TestEqualAccessorMixin(object):
def test_equal_true(self):
s1 = pd.Series([1, 2, 3])
s2 = pd.Series([1, 2, 3])
assert s1.should.equal(s2)
def test_equal_false(self):
... | pd.Series([1, 2, 3]) | pandas.Series |
import pytest
import pandas as pd
import numpy as np
from pandas.testing import assert_frame_equal
from finmarketpy.economics.techindicator import TechParams, TechIndicator
tech_params = TechParams(fillna=True, atr_period=14, sma_period=3,
green_n=4, green_count=9, red_n=2, red_count=13... | assert_frame_equal(df, expected_df) | pandas.testing.assert_frame_equal |
# reading stat files
import pandas as pd
df = pd.read_stata("files/disarea.dta")
print(df.describe())
print(df.head())
print(df.iloc[0:, 2:10])
import matplotlib.pyplot as plt
pd.DataFrame.boxplot(df[['disa1', 'disa2']])
plt.show()
| pd.DataFrame.hist(df[['disa10']]) | pandas.DataFrame.hist |
import numpy as np
import pytest
from pandas._libs import groupby as libgroupby
from pandas._libs.groupby import (
group_cumprod_float64,
group_cumsum,
group_mean,
group_var,
)
from pandas.core.dtypes.common import ensure_platform_int
from pandas import isna
import pandas._testing as tm... | group_cumsum(actual, data, labels, ngroups, is_datetimelike) | pandas._libs.groupby.group_cumsum |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Tue Sep 15 16:19:07 2020
@author: kezeng
"""
from sklearn.base import TransformerMixin,BaseEstimator
from statsmodels.stats.outliers_influence import variance_inflation_factor
import statsmodels.formula.api as smf
import statsmodels.api as sm
from statsmod... | pd.cut(col,[-np.inf]+breaks_cut+[np.inf],labels=points+[points_sp],right=False,ordered=False).astype(dtype) | pandas.cut |
import tiledb, numpy as np
import json
import sys
import os
import io
from collections import OrderedDict
import warnings
from tiledb import TileDBError
if sys.version_info >= (3,3):
unicode_type = str
else:
unicode_type = unicode
unicode_dtype = np.dtype(unicode_type)
# TODO
# - handle missing values
# - ha... | pandas.read_csv(csv_file, **kwargs) | pandas.read_csv |
"""Deep Averaging Networks for text classification
- pytorch, spacy, deep averaging networks
- GloVe word embeddings, frozen and fine-tuned weights
- S&P Key Developments
<NAME>
License: MIT
"""
# jupyter-notebook --NotebookApp.iopub_data_rate_limit=1.0e12
import numpy as np
import os
import time
import re
import csv... | pd.MultiIndex.from_product([['Actual'], labels]) | pandas.MultiIndex.from_product |
import pandas as pd
import os
import random
from tqdm import tqdm
import pickle
import numpy as np
from collections import defaultdict, Counter
from prettytable import PrettyTable
import itertools
import scipy.sparse as sp
"""
-------------------------------------------------------------------
Functions of the prelim... | pd.concat([edges_ab, edges_ba, edges_aa, edges_bb]) | pandas.concat |
import numpy as np
import glob
import pandas as pd
import os
from netCDF4 import Dataset
import socket
atlas_name = "meanstate" # or "eape"
hostname = socket.gethostname()
if (hostname[:8] == "datarmor") or (hostname[::2][:3] == "rin"):
# login node is datarmor3
# computational nodes are rXiYnZ
gdac = "/... | pd.DataFrame(columns=argodb_keys) | pandas.DataFrame |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.