prompt stringlengths 19 1.03M | completion stringlengths 4 2.12k | api stringlengths 8 90 |
|---|---|---|
#!usr/bin/env python
import pandas as pd
import argparse
import csv
parser=argparse.ArgumentParser()
#parser.add_argument("-flags", "--flags", dest="flags_input", help="Special alert flags")
parser.add_argument("-i", "--isolate", dest="isolate", help="isolate")
parser.add_argument("-cc", "--clonalcomplex", dest="cc_i... | pd.DataFrame(spaT, index=None, dtype=None) | 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]}) | pandas.DataFrame |
"""
In the memento task, the behavioral responses of participants were written to
log files.
However, different participants played different versions of the task, and
different versions of the task saved a different amount of variables as a
Matlab struct into the log file.
This file contains information on the variabl... | pd.DataFrame(probs) | pandas.DataFrame |
import pytest
import numpy as np
import pandas as pd
from hypothetical.descriptive import covar, pearson, spearman, var, std_dev, variance_condition, \
kurtosis, skewness, mean_absolute_deviation
from scipy.stats import spearmanr
from numpy.core.multiarray import array
class TestCorrelationCovariance(object):
... | pd.DataFrame(self.fa) | pandas.DataFrame |
import pandas as pd
import numpy as np
np.random.seed(0)
def print_unique(df):
print(np.unique(df[1], return_counts=True))
file_name = '/Volumes/CT500/Researches/Attention_OOD/data/isic/isic_train_0.txt'
df_train = pd.read_csv(file_name, header=None)
print_unique(df_train)
file_name = '/Volumes/CT500/Researches... | pd.concat([df_t, df_dict[f'{j}_t']]) | pandas.concat |
import sys
from io import StringIO
from PySide6.QtCore import *
from PySide6.QtGui import *
from PySide6.QtWidgets import *
from modules.settings.settings import SettingsManager
from modules.pseudo_id.pseudo_id import PseudoIDManager
from gms_uploader.modules.models.pandasmodel import PandasModel
from gms_uploader.mo... | pd.DataFrame(data) | pandas.DataFrame |
#必要なライブラリをインポート
from bs4 import BeautifulSoup
import requests
from time import sleep
import json
import pandas as pd
from tqdm import tqdm_notebook as tqdm
#スクレイピングに必要なパラメータを入力
start = 1 #初めのページ数
end = 1000 #終わりのページ数(SUUMOのサイトを見て、何ページまでデータがあるかを確認する)
place = '相模原' #(辞書urlsに入っている内の)読み込む地域
#後でformatでページ数を代入するので、urlの... | pd.DataFrame(reds_test) | pandas.DataFrame |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Fri Jan 26 15:39:02 2018
@author: joyce
"""
import pandas as pd
import numpy as np
from numpy.matlib import repmat
from stats import get_stockdata_from_sql,get_tradedate,Corr,Delta,Rank,Cross_max,\
Cross_min,Delay,Sum,Mean,STD,TsRank,TsMax,TsMin,DecayLinea... | pd.DataFrame(data_price) | pandas.DataFrame |
# Scraping
import json
import time
import pandas as pd
import requests
import sqlite3
import mpld3
import matplotlib.pyplot as plt
import FinanceDataReader as fdr
from bs4 import BeautifulSoup
from datetime import datetime
from datetime import datetime , timedelta
from dateutil.relativedelta import relativedelta
# De... | pd.DataFrame(article_list) | pandas.DataFrame |
"""
Adapted from Tybalt data_models:
https://github.com/greenelab/tybalt/blob/master/tybalt/data_models.py
"""
import os
import numpy as np
import pandas as pd
from scipy.stats.mstats import zscore
from sklearn import decomposition
from sklearn.preprocessing import StandardScaler, MinMaxScaler
import config as cfg
c... | pd.read_csv(output_data, sep='\t') | pandas.read_csv |
import json
import logging
import os
import sys
from pathlib import Path
from typing import Union
import fire
import pandas as pd
from sklearn.model_selection import StratifiedKFold
from smart_open import open
from tqdm import tqdm
from cord19.preprocessing.negative_sampling import get_cocitations
from cord19.utils i... | pd.DataFrame(normalized_cits_with_doi, columns=[doc_a_col, doc_b_col, 'citing_section']) | pandas.DataFrame |
# -*- 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.Series([], dtype="int") | pandas.Series |
'''
Reads in literature metallicities and makes new Fe/H basis
'''
import pickle
import sys
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from astroquery.simbad import Simbad
from . import *
class LitFehRaw():
'''
Read in Fe/H values from the literature, before making any transformati... | pd.read_csv(source_dir + "solano_1997_abundances.dat") | pandas.read_csv |
from delta.tables import DeltaTable
from notebookutils import mssparkutils
from pyspark.sql.types import StructType, StructField, StringType, IntegerType, DoubleType, ArrayType, TimestampType, BooleanType, ShortType, DateType
from pyspark.sql import functions as F
from pyspark.sql import SparkSession
from pyspark.... | pd.DataFrame(value) | pandas.DataFrame |
# Copyright 2020 The Q2 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
#
# https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed ... | pd.read_csv(args.incons_dodeca_f) | pandas.read_csv |
from .genometric_space import GenometricSpace
from .dataset.parser.parser import Parser
import pandas as pd
import warnings
import numpy as np
class MultiRefModel:
"""
GenometricSpace class to represent data that are mapped with multiple references
"""
def __init__(self):
"""
Con... | pd.DataFrame() | pandas.DataFrame |
import pandas as pd
import numpy as np
import re
import marcformat
class MarcExtractor(object):
tag_marc_file = 'MARC_FILE'
tag_filter_columns = 'FILTER_COLUMNS'
tag_marc_output_file = 'MARC_OUTPUT_FILE'
marcFile = ''
marcOutFile = ''
filteredColumns = []
df = pd.DataFrame()
df1 = pd.D... | pd.read_csv(self.marcFile, chunksize=self.chunkSize, encoding='latin1') | pandas.read_csv |
import matplotlib.pyplot as plt
import numpy as np
import itertools as itt
import pathlib as pl
import src.data.rasters
from src.data.load import load
from src.metrics.reliability import signal_reliability
from src.data.cache import make_cache, get_cache
from src.data import LDA as cLDA, dPCA as cdPCA
fr... | pd.DataFrame(df) | pandas.DataFrame |
# -*- coding: utf-8 -*-
import csv
import os
import platform
import codecs
import re
import sys
from datetime import datetime
import pytest
import numpy as np
from pandas._libs.lib import Timestamp
import pandas as pd
import pandas.util.testing as tm
from pandas import DataFrame, Series, Index, MultiIndex
from pand... | StringIO(data) | pandas.compat.StringIO |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Wed Nov 4 00:13:06 2020
@author: sahand
"""
from rake_nltk import Rake
import pandas as pd
import re
import numpy as np
from sklearn.feature_extraction.text import TfidfVectorizer
import nltk
from nltk.corpus import stopwords
nltk.download('stopwords')
st... | pd.notnull(pub_idx['keywords']) | pandas.notnull |
#
# 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.Timestamp(1) | pandas.Timestamp |
import os
import pandas as pd
from .utils.dataConverter import dataToList
class cleanerToCSV:
"""Accepts the path to the directory containing scripts
and converts the text after cleaning to CSV file in a given directory
"""
def __init__(self, directoryPath, savePath, nConversation=1):
"""Ini... | pd.DataFrame(data={"Text": self.strings}) | pandas.DataFrame |
"""
count step
"""
import os
import sys
import random
from collections import defaultdict
from itertools import groupby
import subprocess
import numpy as np
import pandas as pd
from scipy.io import mmwrite
from scipy.sparse import coo_matrix
import pysam
import celescope.tools.utils as utils
from celescope.tools.cel... | pd.Series.sum(x[x > 1]) | pandas.Series.sum |
import json
import dml
import prov.model
import datetime
import pandas as pd
import uuid
class masterList(dml.Algorithm):
contributor = 'ashwini_gdukuray_justini_utdesai'
reads = ['ashwini_gdukuray_justini_utdesai.massHousing', 'ashwini_gdukuray_justini_utdesai.secretary', 'ashwini_gdukuray_justini_utdesai.va... | pd.DataFrame(preDict) | pandas.DataFrame |
""" Tools for reading/writing BIDS data files. """
from os.path import join
import warnings
import json
import numpy as np
import pandas as pd
from bids.utils import listify
from .entities import NodeIndex
from .variables import SparseRunVariable, DenseRunVariable, SimpleVariable
BASE_ENTITIES = ['subject', 'sessi... | pd.read_csv(rf, sep='\t') | pandas.read_csv |
#!/usr/bin/env python
# coding: utf-8
# ### Bits and pieces for Shop Env Monitor
#
# Source: thingspeak
# In[183]:
import json
import thingspeak as thingspeak
import pandas as pd
import numpy as np
import datetime
import urllib.request
today = datetime.datetime.utcnow().strftime('%Y-%m-%dT00:00:00Z')
yesterday = ... | pd.DataFrame(bmp['feeds']) | pandas.DataFrame |
#!/usr/bin/env python
# -*- coding:utf-8 -*-
"""
Date: 2021/9/23 15:38
Desc: Drewry集装箱指数
https://www.drewry.co.uk/supply-chain-advisors/supply-chain-expertise/world-container-index-assessed-by-drewry
https://infogram.com/world-container-index-1h17493095xl4zj
"""
import pandas as pd
import requests
from bs4 import Beaut... | pd.to_datetime(temp_df["date"]) | pandas.to_datetime |
# -*- coding: utf-8 -*-
import pandas as pd
import numpy as np
from src import (
FEATURES_PRICE_MODEL_Q1,
FEATURES_REVENUE_MODEL_Q1,
PATH_DAILY_REVENUE,
PATH_LISTINGS,
REFERENCE_DATE,
)
from src.features.build_features import (
build_daily_features,
build_date_features,
build_listings_f... | pd.to_datetime("2021-03-01") | pandas.to_datetime |
# -*- python -*-
# -*- coding utf-8 -*-
#
# This file is part of GDSCTools software
#
# Copyright (c) 2015 - Wellcome Trust Sanger Institute
# All rights reserved
# Copyright (c) 2016 - Institut Pasteur
# All rights reserved
#
# File author(s): <NAME> <<EMAIL>>
# File author(s): <NAME> <<EMAIL>>
#
# Distributed... | pd.DataFrame({'name': X.columns, 'weight': model.coef_}) | pandas.DataFrame |
import dash
from dash import dcc, html, dash_table, callback
from dash.dependencies import Input, Output
import dash_bootstrap_components as dbc
import plotly.graph_objects as go
import plotly.graph_objects as go
import pandas as pd
df = pd.read_csv("Amazon.csv")
external_stylesheets = [dbc.themes.LUX]
dash_app = d... | pd.DataFrame.from_dict(data) | pandas.DataFrame.from_dict |
'''
MIT License
Copyright (c) 2020 Minciencia
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, di... | pd.concat([df_output.iloc[begRow:endRow], regionTotal], axis=0) | pandas.concat |
import numpy as np
import pandas as pd
import pdb
import os
import math
import argparse
'''
how to use
ex:
python3 /users/primasan/projects/muat/preprocessing/notebook/tcga/tcga_create_simplified_data.py --muat-dir '/users/primasan/projects/muat/' --tcga-dir '/scratch/project_2001668/data/tcga/alltcga/' --simplified-d... | pd.read_csv(pcawg_dir + pcawg_histology + '/' + onesamples) | pandas.read_csv |
import datetime
import os
today=datetime.date.today()
net_records = []
error_list=[]
try:
from NOKIA1 import *
net_records = net_records + records
except:
error_list.append("NOKIA")
try:
from lgmain import *
net_records = net_records + records
except:
error_list.append("LG"... | pd.DataFrame(net_records, columns = ['COUNTRY', 'COMPANY', 'MODEL', 'USP', 'DISPLAY', 'CAMERA', 'MEMORY', 'BATTERY', 'THICKNESS', 'PROCESSOR', 'EXTRAS/ LINKS']) | pandas.DataFrame |
"""
date: January 2021
author: <NAME>
contact: le<EMAIL>
"""
import os
import pandas as pd
import glob
import regex as re
def clean_vars(path, text):
file_id_clean = re.findall(r'\w{2}\d{4}', path)
clean_text = re.sub(r'\n|\t', ' ', text)
clean_text = re.sub(r'\s{2,}', ' ', clean_text)
if clean_text[... | pd.read_csv('metadata.csv') | pandas.read_csv |
### preprocessing
"""
code is taken from
tunguz - Surprise Me 2!
https://www.kaggle.com/tunguz/surprise-me-2/code
"""
import glob, re
import numpy as np
import pandas as pd
from sklearn import *
from datetime import datetime
import matplotlib.pyplot as plt
data = {
'tra': pd.read_csv('../input/air_visit_data.csv'... | pd.to_datetime(data[df]['reserve_datetime']) | pandas.to_datetime |
"""Models.
Changes affecting results or their presentation should also update
constants.py `change_date`,
"""
from __future__ import annotations
from datetime import date, datetime, timedelta
from logging import INFO, basicConfig, getLogger
from sys import stdout
from typing import Dict, Generator, Tuple, Sequence, ... | pd.DataFrame() | pandas.DataFrame |
from itertools import product
import numpy as np
import pandas as pd
import pytest
from cudf.core.dataframe import DataFrame, Series
from cudf.tests.utils import INTEGER_TYPES, NUMERIC_TYPES, assert_eq, gen_rand
params_sizes = [0, 1, 2, 5]
def _gen_params():
for t, n in product(NUMERIC_TYPES, params_sizes):
... | pd.Series([1, 2, np.nan, 4, 5]) | pandas.Series |
# standard libraries
import os
# third-party libraries
import pandas as pd
# local imports
from .. import count_data
THIS_DIR = os.path.dirname(os.path.abspath(__file__))
class TestCsvToDf:
"""
Tests converting a csv with various headers into a processible DataFrame
"""
def test_timestamp(self):
... | pd.DataFrame(target_list, columns=['session_start1', 'session_end1', 'name1', 'timestamp2', 'name2']) | pandas.DataFrame |
import pandas as pd
from .datastore import merge_postcodes
from .types import ErrorDefinition
from .utils import add_col_to_tables_CONTINUOUSLY_LOOKED_AFTER as add_CLA_column # Check 'Episodes' present before use!
def validate_165():
error = ErrorDefinition(
code = '165',
description = 'Data entry for moth... | pd.to_datetime(mis['MIS_START'], format='%d/%m/%Y', errors='coerce') | pandas.to_datetime |
import json
import pandas as pd
from quantamatics.core.APIClient import Session
from quantamatics.core.utils import QException, QLog, Singleton
from quantamatics.core.settings import MethodTypes, ParamsTypes
class APIGatewayClient(metaclass=Singleton):
def __init__(self):
self.session = Session()
... | pd.read_json(responseData['body'], orient='rows') | pandas.read_json |
import sys
import logging
import argparse
import pandas as pd
def compute_score(predictions, actual):
"""Look at 5% of most highly predicted movies for each user.
Return the average actual rating of those movies.
"""
df = | pd.merge(predictions, actual, on=['user','movie']) | pandas.merge |
import os, math
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
#from matplotlib.collections import PatchCollection
from sklearn import linear_model
from pandas.plotting import register_matplotlib_converters
register_matplotlib_converters()
from importlib import reload
# Constants
#files = ['tim... | pd.Series(df_ts.index, index=df_ts.index) | pandas.Series |
import pandas as pd
import seaborn as sns
import statsmodels.api as sm
import numpy as np
import matplotlib.pyplot as plt
import matplotlib
from numpy.polynomial.polynomial import polyfit
from scipy.stats import shapiro
from scipy.stats import ttest_ind as tt
from scipy.stats import spearmanr as corrp
import numpy as... | pd.read_csv('Gillan_Or_full_mf2_decay.csv',header=None) | pandas.read_csv |
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.DataFrame(self.lens,columns=['seqlen']) | pandas.DataFrame |
from __future__ import division
import os
import itertools
import numpy as np
import pandas as pd
import matplotlib as mpl
import matplotlib.pyplot as plt
import skbio
from scipy.stats import kruskal
from skbio.stats.power import _check_strs
from statsmodels.sandbox.stats.multicomp import multipletests
__author__ = ... | pd.Series(compare, index=order) | pandas.Series |
from matplotlib.path import Path
import numpy as np
import pandas as pd
import warnings
def parse_polygon_gate(events, channel_labels, gate):
"""
Extract events in given Polygon gate
:param events: NumPy array of events on which to apply the gate
:param channel_labels: dictionary of channel labels (k... | pd.DataFrame(sg_results) | pandas.DataFrame |
import ast
import re
from datetime import datetime
from pathlib import Path
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
import wandb
color_list = ['#1f77b4', '#ff7f0e', '#2ca02c', '#d62728', '#9467bd', '#8c564b', '#e377c2', '#7f7f7f', '#bcbd22', '#17becf']
def retrieve_values_from_name(fn... | pd.read_pickle(datapath) | pandas.read_pickle |
from __future__ import division #brings in Python 3.0 mixed type calculations
import numpy as np
import os
import pandas as pd
import sys
#find parent directory and import model
parentddir = os.path.abspath(os.path.join(os.path.dirname(__file__), os.path.pardir))
sys.path.append(parentddir)
from base.uber_model impo... | pd.Series(name="out_lq1_total_dose", dtype="float") | pandas.Series |
from __future__ import print_function
from authlib.client import OAuth2Session
import google.oauth2.credentials
import googleapiclient.discovery
import google_auth
import google_drive
from google_auth import build_credentials, get_user_info
# /index.py
import flask
from flask import Flask, request, jsonify, render_... | pd.read_csv(TESTDATA, sep=",") | pandas.read_csv |
#!/usr/bin/env python
"""
Calculating mean sentiment scores over a set time periods.
Parameters:
infile: str <path-to-images>
batch_size: int <batch-size-doc>
Usage:
sentiment.py --batch_size <batch-size-doc>
Example:
$ python sentiment.py --batch_size 300
"""
# load dependencies
from pathlib ... | pd.to_datetime(data["publish_date"], format="%Y%m%d") | pandas.to_datetime |
#!/usr/bin/env python
# coding: utf-8
# ### Importing modules
# In[1]:
import pandas as pd
import numpy as np
import spacy
from textblob import TextBlob
from statistics import mean, stdev
from sklearn.metrics import accuracy_score, precision_score, recall_score, confusion_matrix, roc_auc_score, roc_curve, precisio... | pd.DataFrame({'false_positives': X_test[(y_pred_class==1) & (y_test==0)]}) | pandas.DataFrame |
import numpy as np
from scipy import stats
import pandas as pd
__all__ = ["n_way_anova"]
def n_way_anova(df_f, groups_column, score_column):
factors = np.unique(df_f[groups_column])
print(factors)
results = | pd.DataFrame(columns=factors, index=factors) | pandas.DataFrame |
# Copyright (c) Microsoft Corporation.
# Licensed under the MIT License.
import abc
import sys
import copy
import time
import datetime
import importlib
from abc import ABC
from pathlib import Path
from typing import Iterable, Type
from concurrent.futures import ThreadPoolExecutor, ProcessPoolExecutor
import fire
impo... | pd.Timedelta(days=1) | pandas.Timedelta |
#
# created by <NAME> (IBSM, Freiburg)
#
#
import cupy as cp
import cupyx as cpx
import cudf
import cugraph
import anndata
import numpy as np
import pandas as pd
import scipy
import math
from scipy import sparse
from typing import Any, Union, Optional
import warnings
from scipy.sparse import issparse
from cuml.line... | pd.cut(df['means'], bins=n_bins) | pandas.cut |
"""
ABSOLUTELY NOT TESTED
"""
import time
import os
import datetime
from collections import namedtuple
import numpy as np
import pandas as pd
import sklearn.preprocessing
import torch
import torch.nn as nn
import torch.optim as optim
from dateutil.relativedelta import relativedelta
from simple_ts_forecast.models i... | pd.to_datetime(date) | pandas.to_datetime |
from pandas.testing import assert_frame_equal
import pandas as pd
from sparkmagic.utils.utils import coerce_pandas_df_to_numeric_datetime
def test_no_coercing():
records = [{u'buildingID': 0, u'date': u'6/1/13', u'temp_diff': u'12'},
{u'buildingID': 1, u'date': u'random', u'temp_diff': u'0adsf'}]
... | pd.DataFrame(records) | pandas.DataFrame |
import matplotlib.pyplot as plt
from pathlib import Path
import pandas as pd
import os
import numpy as np
def get_file_paths(file_directory):
file_paths = os.listdir(file_directory)
file_paths = list(filter(lambda f_path: os.path.isdir(file_directory / f_path), file_paths))
return file_paths
def plot_da... | pd.DataFrame() | pandas.DataFrame |
#!/usr/bin/env python
# Native library
import sys
import pickle
import argparse
import multiprocessing
from random import shuffle
import math
import tempfile
from operator import itemgetter
from io import StringIO
# Other
import numpy as np
import pandas as pd
# Features
import ms2pipfeatures_pyx_HCD
import ms2pipfea... | pd.DataFrame(columns=["spec_id", "peplen", "charge", "ion", "ionnumber", "mz", "target", "prediction"]) | pandas.DataFrame |
import sys
import os
import math
import copy
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
from scipy.stats import rankdata
import multiprocessing as mp
import logging
import scanpy as sc
import anndata as ad
from scipy.io import mmread,mmwrite
from scipy.sparse import csr... | pd.read_csv(fall_in_gene,sep='\t',header=None) | pandas.read_csv |
"""
Clean a DataFrame column containing text data.
"""
import re
import string
from functools import partial, update_wrapper
from typing import Any, Callable, Dict, List, Optional, Set, Union
from unicodedata import normalize
import dask.dataframe as dd
import numpy as np
import pandas as pd
from ..assets.english_sto... | pd.notna(text) | pandas.notna |
"""
This script reads the docking_benchmark_dataset.csv file generated by
01_generate_benchmark_dataset.py and calculates a similarity matrix over all structures using the
RMSD of the KLIFS binding pocket.
"""
from pathlib import Path
from typing import Iterable
from openeye import oechem
import pandas as pd
CACHE_D... | pd.read_csv("../data/docking_benchmark_dataset.csv", index_col=0) | pandas.read_csv |
#!/usr/bin/env python
# coding: utf-8
# In[ ]:
import os
import sys
import pandas as pd
import numpy as np
# In[ ]:
import matplotlib as mpl
import matplotlib.pyplot as plt
import matplotlib.font_manager as fm
import seaborn as sns
#%matplotlib inline
# In[ ]:
#file 불러오기
#file 불러오기
filepath = sys.argv[1]
... | pd.read_csv(filepath + "/" + filename, encoding='UTF-8') | pandas.read_csv |
# -*- 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... | Index(mi.values) | pandas.Index |
"""
@file
@brief Command line about validation of prediction runtime.
"""
import os
from io import StringIO
from collections import OrderedDict
import json
import numpy
from onnx import TensorProto
from pandas import DataFrame
from cpyquickhelper.numbers import measure_time
from onnxruntime import InferenceSession, Ses... | DataFrame(js) | pandas.DataFrame |
import xml.etree.ElementTree as ET # to parse XML
import numpy as np # To convert list to numpy array. Used for creating
# pandas dataframe column
import pandas as pd # used to create csv of parsed data
print ("Started reading xml file from xmlparse library...")
tree = ET.parse("./learners_cleaned.xml" )
pr... | pd.DataFrame(columns = ["learnerId","nationality","grade","level","topic","text"]) | pandas.DataFrame |
'''
Author: <NAME>
Create Time: 2021-10-14 19:35:38
Copyright: Copyright (c) 2021 <NAME>. See LICENSE for details
'''
from OpenFlows.Domain.ModelingElements.NetworkElements import IActiveElementsInput, IBaseLinksInput, IBasePolygonInput, IBasePolygonsInput, INetworkElements, IPointNodesInput
from OpenFlows.Water.Domai... | pd.Int64Dtype() | pandas.Int64Dtype |
'''
Created on May 16, 2018
@author: cef
significant scripts for calculating damage within the ABMRI framework
for secondary data loader scripts, see fdmg.datos.py
'''
#===============================================================================
# # IMPORT STANDARD MODS ---------------------------... | pd.isnull(row) | pandas.isnull |
import os, re
import argparse
import numpy as np
import pickle as pl
from os import walk
from gensim.models import Word2Vec
from nltk.tokenize import RegexpTokenizer
import pandas as pd
from tensorflow.contrib.keras import preprocessing
from tqdm import tqdm
from konlpy.tag import Twitter
twitter = Twitter()
from li... | pd.DataFrame({'label': label, 'doc': doc, 'length': length}) | pandas.DataFrame |
import os
import pandas as pd
import pytest
from pandas.testing import assert_frame_equal
from .. import read_sql
@pytest.fixture(scope="module") # type: ignore
def mysql_url() -> str:
conn = os.environ["MYSQL_URL"]
return conn
def test_mysql_without_partition(mysql_url: str) -> None:
query = "select... | pd.Series([1, 2, 3], dtype="float") | pandas.Series |
from glob import glob
import pandas as pd
import sastvd as svd
pd.set_option("display.max_columns", None)
# %% Phoenix
results = glob(str(svd.outputs_dir() / "phoenix/rq_results/*.csv"))
results2 = glob(str(svd.outputs_dir() / "phoenix_new/rq_results_new/*.csv"))
results += results2
res_df = pd.concat([ | pd.read_csv(i) | pandas.read_csv |
# import all the required files i.e. numpy , pandas and math library
from graphlib.financialGraph import Data
import numpy as np
import pandas as pd
from pandas import DataFrame , Series
import math
# All the indicators are defined and arranged in Alphabetical order
# ------------------> A <------------------------
... | pd.concat([bb, kc_], axis=1) | pandas.concat |
import datetime
import os
import time
import numpy as np
import pandas as pd
from coredotfinance.binance import dataframe_util, datetime_util
from coredotfinance.binance.api import (
api_24hr,
api_avg_price,
api_depth,
api_exchange_info,
api_klines,
)
from coredotfinance.binance.utils import get_... | pd.to_datetime(df["datetime"], unit="ms") | pandas.to_datetime |
# -*- coding: utf-8 -*-
"""
Functions for cleaning and processing the AHBA microarray dataset
"""
from pkg_resources import resource_filename
from nibabel.volumeutils import Recoder
import numpy as np
import pandas as pd
from scipy.spatial.distance import cdist
from . import io, utils
# AHBA structure IDs correspon... | pd.read_csv(coords) | pandas.read_csv |
# coding:utf-8
#
# The MIT License (MIT)
#
# Copyright (c) 2016-2020
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, c... | pd.DataFrame(xd.sig_list) | pandas.DataFrame |
# -*- coding: utf-8 -*-
# Copyright (c) 2018-2021, earthobservations developers.
# Distributed under the MIT License. See LICENSE for more info.
import logging
import operator
from abc import abstractmethod
from enum import Enum
from typing import Dict, Generator, List, Tuple, Union
import numpy as np
import pandas as... | pd.Series(parameter) | pandas.Series |
import pandas as pd
def get_df(filepath, filetype='infer', index=None):
if filetype == 'infer':
filetype = filepath.split('.')[-1]
# Read in file as DataFrame
if filetype == 'csv':
df = pd.read_csv(filepath)
elif filetype == 'pickle' or filetype == 'pkl':
df = pd.read_pickle(filepath)
else:
... | pd.merge(df1, df2, how=how) | pandas.merge |
# Handle Rcat serial io
import serial
import requests
import io
import threading
import time
import pandas as pd
import math
import urllib.parse
class SerialIO:
def __init__(self):
self.ser = None
self.dataBuffer = []
self.thread = None
self.active = False
self.lastcall = | pd.Timestamp.now() | pandas.Timestamp.now |
import warnings
warnings.simplefilter(action='ignore', category=FutureWarning)
import os
import sys
import threading
from queue import Queue
import pandas as pd
from datetime import datetime, timedelta
import time
import numpy as np
import json
import toml
import random
import names
import string
import itertools as ... | pd.date_range(start=self.start_dt, periods=self.hours, freq='H') | pandas.date_range |
import sklearn
from pprint import pprint
# Standard Imports (Data Manipulation and Graphics)
import numpy as np # Load the Numpy library with alias 'np'
import pandas as pd # Load the Pandas library with alias 'pd'
import seaborn as sns # Load the Seabonrn, graphics library with alias 'sns'
import copy
from ... | pd.DataFrame(data=[data], columns=df.columns, index=["Mean Values"]) | pandas.DataFrame |
import unittest
import pandas as pd
import pandas.util.testing as pt
import tia.util.fmt as fmt
def tof(astr):
return float(astr.replace(",", ""))
class TestFormat(unittest.TestCase):
def ae(self, expected, fct, value, **kwargs):
cb = fct(**kwargs)
actual = cb(value)
self.assertEqual... | pd.DataFrame(expected_bycol) | pandas.DataFrame |
#!/usr/bin/python
# -*- coding: utf-8 -*-
"""
Module to hold core processing/analysis functions for Ocean iodide (Oi!) project
Notes
----
ML = Machine Learning
target = the value aiming to be estimated or provided in training
feature = a induivual conpoinet of a predictor vector assigned to a target
( could be called ... | pd.DataFrame(index=model_names) | pandas.DataFrame |
# -*- 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... | tm.assert_series_equal(rs, xp) | pandas.util.testing.assert_series_equal |
from Modules.appLogger import application_logger
from Modules.DataLoader import predictionDataLoader
from Modules.SaveLoadModel import saveLoadModel
from Modules.DataPreprocessor import dataPreprocessor
import pandas as pd
class predictData:
"""
Class Name: predictData
... | pd.DataFrame(columns=['date','time','logs']) | pandas.DataFrame |
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... | tm.assert_frame_equal(result, expected) | pandas._testing.assert_frame_equal |
from __future__ import division, print_function
import os
import click
import numpy as np
import pandas as pd
def load_games(game_data_fname, remove_ties=False):
"""Load data containing results of each game and return a DataFrame.
Parameters
----------
game_data_fname : str, filename of Armchair An... | pd.read_csv(punt_data_fname, index_col=0) | pandas.read_csv |
import numpy as np
import pandas as pd
from numpy.testing import assert_array_equal
from pandas.testing import assert_frame_equal
from nose.tools import (assert_equal,
assert_almost_equal,
raises,
ok_,
eq_)
from rsmtool.p... | assert_frame_equal(df_new, df) | pandas.testing.assert_frame_equal |
import numpy as np
import pandas as pd
# Compute moving averages across a defined window. Used to compute regimes
# INTERPRETATION: The regime is the short MAV minus the long MAV. A positive value indicates
# a bullish trend, so we want to buy as soon as the regime turns positive.
# Therefore, we want to identify in o... | pd.to_datetime(transdat.index) | pandas.to_datetime |
import json
import gzip
import argparse
import pandas as pd
def main():
# Parse command line arguments
parser = argparse.ArgumentParser()
parser = argparse.ArgumentParser(description='Parse information from HPA json export and saves as CSV.')
parser.add_argument('-i', '--input', help='HPA JSON i... | pd.DataFrame(parsed_entries) | pandas.DataFrame |
# -*- coding: utf-8 -*-
"""
Tests of the `masci_tools.vis.data` module
"""
import pytest
from itertools import product
import numpy as np
import pandas as pd
import copy
USE_CDS = True
try:
from bokeh.models import ColumnDataSource
except ImportError:
USE_CDS = False
def test_normalize_list_or_array():
"... | pd.DataFrame(data=dict_data) | pandas.DataFrame |
from unittest.mock import MagicMock, patch
import numpy as np
import pandas as pd
import pytest
from sklearn.model_selection import StratifiedKFold
from evalml import AutoMLSearch
from evalml.automl.callbacks import raise_error_callback
from evalml.automl.pipeline_search_plots import SearchIterationPlot
from evalml.e... | pd.DataFrame(X) | pandas.DataFrame |
import numpy as np
import pandas as pd
from ..master_equation import master_equation as meq
#import MSI.master_equation.master_equation as meq
import copy
import re
import cantera as ct
class OptMatrix(object):
def __init__(self):
self.S_matrix = None
self.s_matrix = None
self.Y_matrix = N... | pd.read_csv(target_value_csv) | pandas.read_csv |
# pragma pylint: disable=missing-docstring,W0212,C0103
from datetime import datetime
from pathlib import Path
from unittest.mock import MagicMock, PropertyMock
import pandas as pd
import pytest
from arrow import Arrow
from filelock import Timeout
from freqtrade import OperationalException
from freqtrade.data.converte... | pd.DataFrame.from_records(trades, columns=labels) | pandas.DataFrame.from_records |
import numpy as np
import shutil
import pandas as pd
import os
import json
import re
from sklearn.model_selection import StratifiedKFold
RANDOM_SEED = 2018 # Set seed for reproduction
datapath = "./kkbox-music-recommendation-challenge/"
# !!! Directly using pd.read_csv() leads an error: #rows < 2296833
# songs_df = ... | pd.merge(train_with_user, right=songs_df, on="song_id", how="left") | pandas.merge |
import datetime
from collections import OrderedDict
import pandas as pd
from google.cloud import bigquery
CLIENT = None
PROJECT_ID = None
def insert_date_range(sql, date_range):
start, end = date_range
if start is None and end is None: return sql
if start is None:
return sql + ' WHERE `date` <= ... | pd.DataFrame(columns=['uid', covariate]) | pandas.DataFrame |
"""Python library for GCCR002"""
from contextlib import contextmanager
from datetime import datetime
import hashlib
from io import StringIO
from IPython.display import display as _display
from itertools import chain, product, combinations_with_replacement
import joblib
import json
import logging
import matplotlib.pypl... | pd.read_csv("data/processed/country-of-residence.csv", index_col=0) | pandas.read_csv |
"""
Module containing the core system of encoding and creation
of understandable dataset for the recommender system.
"""
import joblib
import pandas as pd
from recipe_tagger import recipe_waterfootprint as wf
from recipe_tagger import util
from sklearn import cluster
from sklearn.feature_extraction.text import TfidfVe... | pd.merge(orders, recipes, on="id") | pandas.merge |
from datetime import datetime
import logging
import typing
import hydra
import pandas as pd
from fetcher.utils import Fields
from fetcher.source_utils import fetch_source, process_source_responses
from fetcher.sources import build_sources
# Indices
TS = 'TIMESTAMP'
STATE = Fields.STATE.name
class Fetcher:
def ... | pd.Series(states_to_index, name=STATE) | pandas.Series |
# Author: <NAME>
# Email: <EMAIL>
import sklearn.utils as sk
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import pickle
import os
from glob import glob
from sklearn.ensemble import RandomForestRegressor
from sklearn.model_selection import train_test_split, GridSearchCV
from collections import... | pd.read_csv(out_dir + 'Y_Test.csv') | pandas.read_csv |
import numpy as np
import pandas as pd
import pytest
from pandas.testing import assert_frame_equal
@pytest.fixture
def df_checks():
"""fixture dataframe"""
return pd.DataFrame(
{
"famid": [1, 1, 1, 2, 2, 2, 3, 3, 3],
"birth": [1, 2, 3, 1, 2, 3, 1, 2, 3],
"ht1": [2.... | assert_frame_equal(result, single_val) | pandas.testing.assert_frame_equal |
"""
Module encapsulating Selection's method for Pivoting output rows
Copyright (C) 2016 ERT Inc.
"""
import ast
import pandas
import numpy
def count(collection):
"""
module alias, to rename Python 'len' builtin for pandas aggregation
"""
return len(collection)
def get_result(results_generator, pivot... | pandas.DataFrame(data_rows_generator, columns=input_header_row) | pandas.DataFrame |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.