prompt stringlengths 19 1.03M | completion stringlengths 4 2.12k | api stringlengths 8 90 |
|---|---|---|
#!/usr/local/bin/python
""" Mess-around project to learn more python.
I organize my card collection according to price. The $TRADE_BOX_THRESHOLD is for cards kept in my trade box. I adjust this whenever the trade box gets full.
$1-$TRADE_BOX_THRESHOLD cards are kept in a separate less accessed box. Anything under $1... | pandas.notnull(row["OldCount"]) | pandas.notnull |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time : 2019-05-22 17:45
# @Author : erwin
import datetime
import time
import pandas as pd
from component.demo_opentsdb.opentsdb_conn import OpenTSDBClient
from machine_learning.similarity.dtw.hierarchical_helper import HierarchicalHelper
from common.pickle_helper imp... | pd.set_option('display.max_colwidth', 1000) | pandas.set_option |
#!/usr/bin/env python
# ipdb> import os; os._exit(1)
# call as: python convert_mat_to_excel.py
# =======================================
# Version 0.1
# 30 March, 2019
# michael.taylor AT reading DOT ac DOT uk
# =======================================
import os
import os.path
import glob
import optparse
from o... | pd.DataFrame(x, columns=x_cols, index=t) | pandas.DataFrame |
import pandas as pd
import numpy as np
import sys, getopt
import os
from os import path
import collections
def process_kp_baseline_survey(data_dictionary_filename, data_filename, output_folder):
print('input dd =', data_dictionary_filename)
print('input df =', data_filename)
print('output dir =', o... | pd.DataFrame(ipaq_scores) | pandas.DataFrame |
"""
Monte Carlo-type tests for the BM model
Note that that the actual tests that run are just regression tests against
previously estimated values with small sample sizes that can be run quickly
for continuous integration. However, this file can be used to re-run (slow)
large-sample Monte Carlo tests.
"""
import numpy... | pd.concat([endog1_M, f2, endog2_M], axis=1) | pandas.concat |
'''
Plots for my first-year (and beyond) figurative violence in the media project.
Author: <NAME> <<EMAIL>>
Date: April 01, 2017
'''
import matplotlib.pyplot as plt
import matplotlib.dates as pltdates
import pandas as pd
import seaborn as sns
from datetime import date, datetime, timedelta
from .analysis import rela... | pd.DatetimeIndex([d0, d1, d2, d3, d4, d5]) | pandas.DatetimeIndex |
# -*- 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... | lib.infer_dtype(arr) | pandas._libs.lib.infer_dtype |
import builtins
from io import StringIO
from itertools import product
from string import ascii_lowercase
import numpy as np
import pytest
from pandas.errors import UnsupportedFunctionCall
import pandas as pd
from pandas import (
DataFrame, Index, MultiIndex, Series, Timestamp, date_range, isna)
import pandas.cor... | pd.DataFrame([{"a": 1, "b": i[0]}, {"a": 1, "b": i[1]}]) | pandas.DataFrame |
# -*- coding: utf-8 -*-
"""
@file:utils.py
@time:2019/6/1 21:57
@author:Tangj
@software:Pycharm
@Desc
"""
import os
import numpy as np
from sklearn.base import BaseEstimator, TransformerMixin
from sklearn.metrics import roc_auc_score
from time import time
import random
import pandas as pd
def frame_to_dict(train):
... | pd.concat([train1, train2]) | pandas.concat |
import altair as alt
import pandas as pd
from sys import argv
import numpy as np
df = | pd.read_csv(argv[1], keep_default_na=False) | pandas.read_csv |
# -*- coding: utf-8 -*-
# Global imports
from __future__ import unicode_literals
import os
import glob
import pickle
import argparse as ap
import pandas as pd
import numpy as n
import multiprocessing as mp
# Plot imports
import matplotlib.pyplot as plt
import matplotlib
matplotlib.use("tkagg")
import seaborn as sns
... | pd.read_csv(report, sep=" ") | pandas.read_csv |
# -*- coding: utf-8 -*-
import datetime
import time
from sqlalchemy.sql import func
import pandas as pd
import math
data=pd.read_csv('上证50_daily.csv',index_col=0)
t=data.index
f=0
jiange=30
res=[]
import datetime
# def get_day_nday_ago(date,n):
# t = time.strptime(date, "%Y-%m-%d")
# y, m, d = t[0:3]
# D... | pd.DataFrame(res,index=[0]) | pandas.DataFrame |
# -*- coding: utf-8 -*-
"""
Created on Mon Jun 15 14:26:29 2020
@author: skyhigh
"""
import pandas as pd
columns =['matth','english','science']
indexs = ['John','Julia',"Mary","Henry"]
datas=[[80,70,90],[88,87,99],[77,66,76],[90,98,96]]
df = | pd.DataFrame(datas,columns=columns,index=indexs) | pandas.DataFrame |
# http://www.vdh.virginia.gov/coronavirus/
from bs4 import BeautifulSoup
import csv
from datetime import datetime
from io import StringIO
import os
import requests
import pandas as pd
# Remove empty rows
def filtered(rows):
return [x for x in rows if "".join([(x[y] or "").strip() for y in x]) != ""]
def run_VA(a... | pd.to_datetime(v_df[date_col]) | pandas.to_datetime |
import copy
from GTac_Data import gtac_data
from data_gen import raw_data_byts_checkout_2, collect_DataPoints
# from data_collect_fingers_five import COLUMNS_RAW_FINGER_DATA, MAG_NUM, COL_INDEX
from gtac_config import COLUMNS_RAW_FINGER_DATA, MAG_NUM, COL_INDEX
# from Handover import collect_DataPoints, find_location,... | pd.DataFrame(columns=COLUMNS_RAW_FINGER_DATA) | pandas.DataFrame |
import pandas as pd
import json, os
from datetime import timedelta
f = open('data/game_def.json')
game_def = json.load(f)
def getHardwareLog(start_date, end_date, hwlogpath):
df = pd.read_csv(hwlogpath, header=[1])
df['Time'] = pd.to_datetime(df['Time']).dt.tz_localize("America/New_York")
mask = (df['Ti... | pd.Timedelta(seconds=trial['times'][idxLevel[1]]) | pandas.Timedelta |
import os
import speedtest
import time
import sys
import shutil
import pandas as pd
from pythonping import ping
import argparse
import logging
import traceback
import configparser
from PyQt5.QtCore import pyqtSignal, QObject
from modules.visuals import InteractivePlots
class Communicate(QObject):
GUI_signal = py... | pd.DataFrame(columns=["date", "min", "max", "avg", "url"]) | pandas.DataFrame |
# ---
# jupyter:
# jupytext:
# formats: ipynb,py:percent
# text_representation:
# extension: .py
# format_name: percent
# format_version: '1.3'
# jupytext_version: 1.9.1
# kernelspec:
# display_name: udl
# language: python
# name: udl
# ---
# %% [markdown]
# # Sentiment ... | pd.Series([0,0,0,0,1,1,1,1]) | pandas.Series |
from numpy import *
import pandas as pd
| pd.set_option('precision',2) | pandas.set_option |
import numpy as np
import pandas as pd
from datetime import datetime, timedelta
import pytest
import vectorbt as vbt
from vectorbt.utils.config import merge_dicts
seed = 42
# ############# base.py ############# #
class MyData(vbt.Data):
@classmethod
def download_symbol(cls, symbol, shape=(5, 3), start_dat... | pd.Int64Index([0, 1], dtype='int64', name='symbol') | pandas.Int64Index |
import sys
import pandas
from decisionengine_modules.glideinwms.transforms.grid_figure_of_merit import GridFigureOfMerit
grid_entries = ["g1", "g2", "g3", "g4", "g5"]
running = [5, 10, 15, 20, 200]
max_allowed = [10, 10, 10, 2000, 500]
idle = [20, 3, 4, 5, 6]
max_idle = [10, 10, 10, 10, 10]
entries = {
"EntryNa... | pandas.DataFrame(entries) | pandas.DataFrame |
import pandas as pd
import numpy as np
import scipy
import seaborn as sns
import matplotlib.pyplot as plt
import os
from functools import reduce
from statsmodels.tsa.stattools import coint
sns.set(style='white')
# Retrieve intraday price data and combine them into a DataFrame.
# 1. Load downloaded prices from folder... | pd.DataFrame() | pandas.DataFrame |
import numpy as np
import pandas as pd
import pdb
import os
import math
import argparse
if __name__ == '__main__':
#edit the directory
muat_dir = '/users/primasan/projects/muat/'
metadata = pd.read_csv(muat_dir + 'extfile/metadata_icgc_pcawg.tsv',sep='\t',index_col=0)
dictMutation = pd.read_csv(muat_... | pd.DataFrame(pd_all) | pandas.DataFrame |
# -*- coding: utf-8 -*-
"""
Created on Sun Apr 11 22:34:12 2021
@author: orkun
"""
import numpy as np
import pandas as pd
from sklearn.impute import SimpleImputer
from pandas.api.types import is_numeric_dtype
from sklearn import preprocessing
from PyQt5.QtWidgets import QMessageBox
from PyQt5.QtCore import QSize
from ... | pd.DataFrame(self.dataframe[col_name]) | pandas.DataFrame |
import pandas as pd
import numpy as np
import re
#===============================================================================
def cleandots(x,mark):
if str(x) == mark : # The mark was a '.' in HW 3 use case.
return np.NaN
else:
return str (x)
def cleandotsincolumn (series,mark):
return ... | pd.reset_option('display.max_columns') | pandas.reset_option |
# -*- coding: utf-8 -*-
"""
Tools for calculating the fatigue damage equivalent PSD. Adapted and
enhanced from the CAM versions.
"""
from types import SimpleNamespace
import itertools as it
import multiprocessing as mp
import numpy as np
import scipy.signal as signal
import pandas as pd
from pyyeti import cyclecount, ... | pd.Series(SRSmax, index=index) | pandas.Series |
import datetime
import logging
import json
import requests
from pandas import json_normalize
import pandas as pd
from google.cloud import storage
from anyway.parsers.waze.waze_db_functions import (
insert_waze_alerts,
insert_waze_traffic_jams,
enrich_waze_alerts_ended_at_timestamp,
enrich_waze_traffic_... | pd.to_datetime(waze_df["pubMillis"], unit="ms") | pandas.to_datetime |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Sat May 23 03:54:38 2020
@author: lukepinkel
"""
import numpy as np
import scipy as sp
import scipy.stats
import pandas as pd
from .linalg_operations import _check_shape
def get_param_table(params, se_params, degfree=None, index=None,
p... | pd.DataFrame(arr, index=index, columns=[parameter_label, 'SE']) | pandas.DataFrame |
from datetime import datetime
startTime = datetime.now()
import json
import glob
import os
import pandas as pd
import tensorflow as tf
import tensorflowjs as tfjs
from tensorflow import keras
from sklearn.model_selection import train_test_split
import requests
EPOCHS = 9
CLASSES = 2
"""
Build and return the Keras mod... | pd.read_csv(path, skipinitialspace=True, low_memory=False) | pandas.read_csv |
# coding: utf-8
# In[3]:
import pandas as pd
train = pd.read_csv('train.csv')
test = pd.read_csv('test.csv')
# In[4]:
import matplotlib.pyplot as plt
import seaborn as sns
sns.set() # setting seaborn default for plots
# In[5]:
train_test_data = [train, test] # combining train and test dataset
for dataset... | pd.DataFrame([Pclass1, Pclass2, Pclass3]) | pandas.DataFrame |
from bokeh.sampledata.us_states import data as stateBorders
from bokeh.sampledata.us_counties import data as counties
from COVID.extract import COVID_counts
import pandas as pd
import numpy as np
import pickle
# stateBorders['D.C.'] = stateBorders.pop('DC')
stateBorders= | pd.DataFrame(stateBorders) | pandas.DataFrame |
# -*- coding: utf-8 -*-
"""
Created on Tue Feb 4 22:47:56 2020
@author: nipunn
"""
def outlying_rows(filename):
mydataset= | pd.read_csv(filename) | pandas.read_csv |
import IPython
import base64
import cv2
import json
import numpy as np
import pandas as pd
import pravega.grpc_gateway as pravega
from matplotlib import pyplot as plt
import time
def ignore_non_events(read_events):
for read_event in read_events:
if len(read_event.event) > 0:
yield read_event
... | pd.to_datetime(df[self.timestamp_col], unit='ms', utc=True) | pandas.to_datetime |
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_almost_equal(result, expected) | pandas._testing.assert_almost_equal |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from __future__ import absolute_import
import json
import os
import torch
import pandas as pd
import numpy as np
def save_csv_log(opt, head, value, is_create=False, file_name='test'):
if len(value.shape) < 2:
value = np.expand_dims(value, axis=0)
df = | pd.DataFrame(value) | pandas.DataFrame |
import streamlit as st
import numpy as np
import pandas as pd
import plotly.graph_objects as go
from datetime import datetime
import requests
class DataFetcher:
def __init__(self):
self.url_brazil_general = 'https://covid19-brazil-api.now.sh/api/report/v1/brazil/'
self.url_brazil_states = 'https://... | pd.Timedelta(hours=3) | pandas.Timedelta |
from pandas.util import hash_pandas_object
import hashlib
import pandas as pd
import random
random.seed(42)
import numpy as np
import psutil
import time
ROWS = 20000000
DATA = [random.random() for _ in range(ROWS)]
def mem_use():
mem_profile = psutil.virtual_memory()
print("Memory Usage = {} | percent ... | pd.concat(genera,axis=1) | pandas.concat |
from scipy.stats import mannwhitneyu,wilcoxon
import numpy as np
from scipy.io import mmread
import pandas as pd
X = mmread('RFiles/all_data.mtx')
X = X.tocsr()
celllabels = np.load('Notebooks/meta/celllabels.npy')
isCSF = np.load('Notebooks/meta/isCSF.npy')
isMS = np.load('Notebooks/meta/isMS.npy')
logX = np.log10... | pd.DataFrame([clusterid,stat,pvalue],index=['clusterid','stat','pvalue']) | pandas.DataFrame |
from __future__ import annotations
from collections import abc
from datetime import datetime
from functools import partial
from itertools import islice
from typing import (
TYPE_CHECKING,
Callable,
Hashable,
List,
Tuple,
TypedDict,
Union,
cast,
overload,
)
import warnings
import nu... | is_integer_dtype(values) | pandas.core.dtypes.common.is_integer_dtype |
import json
import sys
import pandas as pd
from pandas import DataFrame
from db.sql import dal
from flask import request
import tempfile
import tarfile
import csv
import shutil
import subprocess
from flask import send_from_directory
from annotation.main import T2WMLAnnotation
from db.sql.kgtk import import_kgtk_datafra... | pd.read_excel(request.files['file'], dtype=object, header=None) | pandas.read_excel |
from sklearn.manifold import TSNE
from clustering import silhouette as sil
from data_processing import MulticlusteringExperimentUtils as expUtils
# Keep the clustering experiments that involve outliers here
from clustering.KMeansVariations import kMeans_baseline, kMeans_baseline_high_iteration, kMeans_baseline_random_... | pd.DataFrame(feature_set_outliers_removed) | pandas.DataFrame |
from numpy import *
import pandas as pd
import datetime
from datetime import timedelta
def sum_duplicated():
fields = ['DATE', 'DAY_OFF', 'WEEK_END', 'DAY_WE_DS', 'ASS_ASSIGNMENT', 'CSPL_RECEIVED_CALLS' ] # selectionne les colonnes à lire
x=pd.read_csv("data/train_2011_2012_2013.csv", sep=";", usecols=fields) ... | pd.DataFrame() | pandas.DataFrame |
#%%
# ANCHOR IMPORTS
import sys
import pandas as pd, numpy as np
import pickle
import re
from sklearn import feature_extraction , feature_selection
from scipy.sparse import csr_matrix, hstack
from sklearn.feature_extraction.text import CountVectorizer
from sklearn.feature_extraction import DictVectorizer
from skl... | pd.concat(featList, axis=1) | pandas.concat |
"""
Copyright 2020 The Secure, Reliable, and Intelligent Systems Lab, ETH Zurich
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 appl... | pd.MultiIndex.from_tuples(product, names=["steps", "names", "prices", "samples"]) | pandas.MultiIndex.from_tuples |
#!/usr/bin/env python
# coding: utf-8
# In[2]:
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
pd.options.display.max_columns = None
# In[3]:
df = pd.read_csv('full_data.csv')
# In[4]:
df.head()
# Since i got the data from lolchess.gg, i only got informations o... | pd.set_option('display.max_rows', None) | pandas.set_option |
# pylint: disable=E1101,E1103,W0232
from datetime import datetime, timedelta
from pandas.compat import range, lrange, lzip, u, zip
import operator
import re
import nose
import warnings
import os
import numpy as np
from numpy.testing import assert_array_equal
from pandas import period_range, date_range
from pandas.c... | Index([], name='Foo') | pandas.core.index.Index |
from datetime import datetime, timedelta
import inspect
import numpy as np
import pytest
from pandas.core.dtypes.common import (
is_categorical_dtype,
is_interval_dtype,
is_object_dtype,
)
from pandas import (
Categorical,
DataFrame,
DatetimeIndex,
Index,
IntervalIndex,
MultiIndex... | tm.assert_frame_equal(result2, original) | pandas.util.testing.assert_frame_equal |
# -*- coding: utf-8 -*-
"""
Created on Fri Aug 14 13:52:36 2020
@author: diego
"""
import os
import sqlite3
import numpy as np
import pandas as pd
import plots as _plots
import update_prices
import update_companies_info
pd.set_option("display.width", 400)
pd.set_option("display.max_columns", 10)
pd.options.mode.chai... | pd.DateOffset(months=12) | pandas.DateOffset |
# Testing array.blend
import utipy as ut
import numpy as np
import pandas as pd
def test_blend_list():
x1 = [1, 2, 3, 4, 5, 6]
x2 = [2, 3, 4, 5, 6, 7]
blended0 = ut.blend(x1, x2, amount=0)
blended1 = ut.blend(x1, x2, amount=1)
blended05 = ut.blend(x1, x2, amount=.5)
assert blended0 == x1
... | pd.Series([2, 3, 4, 5, 6, 7]) | pandas.Series |
from dataProcessing import *
from sklearn.ensemble import RandomForestClassifier
from sklearn.ensemble import IsolationForest
import pandas as pd
import pickle
from RandomForestCounterFactual import *
def checkSamples(
datasetFileName,
unscaledFactualsFileName,
unscaledCounterFactualsFileName,
... | pd.DataFrame() | pandas.DataFrame |
# import hashlib
# import random
# import json
import binascii
import json
import traceback
import uuid
import numpy as np
import datetime
import Crypto
import Crypto.Random
from Crypto.Random import get_random_bytes
# from Crypto.Hash import SHA
from Crypto.PublicKey import RSA
from Crypto.Cipher import ... | pd.Series({'public_key':public_key,'name':name}) | pandas.Series |
"""Run the file manually to find all angle data."""
import math
import numpy as np
import pandas as pd
from lilypadz.helper.constant import TOAD_HOP
def convert_xyz_to_kinematic(xyz_data: pd.DataFrame) -> pd.DataFrame:
"""Calculate three kinematic variables from the XYZ data.
:param xyz_data: xyz data of a ... | pd.read_csv(f"{name}/{hop}/xyz.csv") | pandas.read_csv |
#
# Copyright 2016 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.Timestamp('2015-01-07 14:35', tz='UTC') | pandas.Timestamp |
# -*- coding: utf-8 -*-
from typing import Optional, Union
import pandas as pd
from mando import command
from tstoolbox import tsutils
try:
from typing import Literal
except ImportError:
from typing_extensions import Literal
try:
from mando.rst_text_formatter import RSTHelpFormatter as HelpFormatter
exce... | pd.Timestamp(DEFAULT_END_DATE) | pandas.Timestamp |
from __future__ import absolute_import, division, print_function
import pytest
from datetime import datetime, timedelta
import numpy as np
import pandas as pd
import pandas.util.testing as tm
from pandas import DataFrame, Series
from string import ascii_lowercase
from blaze.compute.core import compute
from blaze ... | Series(['1999-12-31', '2000-06-25'], dtype='M8[ns]', name='s') | pandas.Series |
import pandas as pd
import numpy as np
import os
from sklearn.linear_model import Ridge
from sklearn.model_selection import cross_val_score
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_squared_error
mos_data=pd.read_csv('data.csv')[['streaming_log','mos']]
data=[]
for l i... | pd.merge(mos_data, agg_data, on='streaming_log') | pandas.merge |
from __future__ import absolute_import, division, print_function
import json
import logging
import math
import os
import random
import warnings
from dataclasses import asdict
from multiprocessing import cpu_count
import numpy as np
import pandas as pd
import torch
from scipy.stats import pearsonr
from sklearn.metrics... | pd.DataFrame(training_progress_scores) | pandas.DataFrame |
from datetime import (
datetime,
timedelta,
)
from importlib import reload
import string
import sys
import numpy as np
import pytest
from pandas._libs.tslibs import iNaT
import pandas.util._test_decorators as td
from pandas import (
NA,
Categorical,
CategoricalDtype,
Index,
Interval,
... | CategoricalDtype(None, ordered=True) | pandas.CategoricalDtype |
from db.DBConnector import execute_query
from utils.log import log_init, log_close, log
import time
from os import path
from pathlib import Path
import pandas as pd
import matplotlib.pyplot as plt
import numpy as np
# the ids are not included as they are the same for every table: id : long
classMetricsEntities = ["cl... | pd.read_csv(file_path) | pandas.read_csv |
#!/usr/bin/env python3
'''
FILE: nav01_parser.py
DESCRIPTION: Nav01 parser class for raw output from a Furuno GP-90D GPS reciever
Data file contains GGA/ZDA/VTG NMEA0183 sentences with no additional
information added.
BUGS:
NOTES:
AUTHOR: <NAME>
COMPA... | pd.merge_asof(data, zda_df, on="lineno") | pandas.merge_asof |
'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
RMDL: Random Multimodel Deep Learning for Classification
* Copyright (C) 2018 <NAME> <<EMAIL>>
* Last Update: May 3rd, 2018
* This file is part of RMDL project, University of Virginia.
* Free to use, change, share and distribute source code of RMD... | pd.Series(shuffle_csv["class"]) | pandas.Series |
import os
import logging
from collections import defaultdict
import pandas as pd
from fol.foq_v2 import (concate_n_chains, copy_query,
negation_sink,
binary_formula_iterator,
concate_iu_chains,
parse_formula,
... | pd.DataFrame(data_dict) | pandas.DataFrame |
import json
import pandas as pd
import numpy as np
from sklearn.preprocessing import StandardScaler
from sklearn.neighbors import NearestNeighbors
def cluster(cohort_submissions: dict) -> list:
"""
Splits given dict into clusters of 4 based on their ranked complexity
The 'remainder problem' of needing t... | pd.DataFrame.from_dict(cohort_submissions, orient="index") | pandas.DataFrame.from_dict |
# To add a new cell, type '# %%'
# To add a new markdown cell, type '# %% [markdown]'
# %%
# first, REMEMBER to activate cryptoalgowheel-S2 environment!
# %%
import datetime
import os
import sys
import backtrader as bt
import numpy as np
import pandas as pd
import matplotlib
import PyQt5
# %%
#*****WARNING: REVISE... | pd.to_datetime(from_datetime) | pandas.to_datetime |
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter
import torch
from mbpert.loss import reg_loss_interaction, reg_loss_r, reg_loss_eps
from mbpert.mbpert import MBPertDataset, MBPert
import seaborn as sns
import matplotlib.pyplot as plt
import pandas as pd
import numpy as np
from ... | pd.DataFrame(data={'pred': x_pred_test, 'true': x_ss_test, 'value': 'x'}) | pandas.DataFrame |
from __future__ import print_function, absolute_import, division
import pandas as pd
import numpy as np
import argparse
import json
import math
import re
import os
import sys
import csv
import socket # -- ip checks
import seaborn as sns
import matplotlib.pyplot as plt
from jinja2 import Environment, PackageLoader
#... | pd.merge(dt, df_s1, on='_column', how='inner') | pandas.merge |
### ETL script for generating input tables to model
### main point: ETL JHU covid-19 case and mortality data
# todo: refactor
## HERE! -> not handled here in python -> Serial Interval Table -> would be worthwhile to reproduce the R for that here
## "serial interval table" <--> that discretized gamma distribution
## s... | pd.read_csv(jhu + deaths_csv) | pandas.read_csv |
import json
import logging
import pandas as pd
import requests
from gamestonk_terminal import config_terminal as cfg
from gamestonk_terminal.decorators import log_start_end
from gamestonk_terminal.rich_config import console
logger = logging.getLogger(__name__)
api_url = "https://api.glassnode.com/v1/metrics/"
GLAS... | pd.to_datetime(df["t"], unit="s") | pandas.to_datetime |
import pandas as pd
import matplotlib.pyplot as plt
import statistics
from datetime import datetime
import copy
import json
import numpy as np
from os import listdir
from os.path import isfile, join
import unknown
import baseline
import known_approx as kapprox
import mary_optimal as mary
dirs = ['/localdisk1/DOT/flig... | pd.concat(dfs) | pandas.concat |
import pandas as pd
import numpy as np
d= pd.read_csv(snakemake.input[0], sep= '\t', header=0, compression= 'gzip')
d= d.loc[~d['#chrom'].str.contains('_'), :]
d['a1']= d.alts.str.split(',').str[0]
d['a2']= d.alts.str.split(',').str[1]
d['#chrom']= d['#chrom'].str.replace('chr', '')
d['POS']= np.where(d.ref.str.len() ... | pd.concat([d, df]) | pandas.concat |
from context import dero
import pandas as pd
from pandas.util.testing import assert_frame_equal
from pandas import Timestamp
from numpy import nan
import numpy
class DataFrameTest:
df = pd.DataFrame([
(10516, 'a', '1/1/2000', 1.01),
(10516, 'a'... | Timestamp('2000-01-06 00:00:00') | pandas.Timestamp |
"""Python Script Template."""
import os
import pandas as pd
H_PARAMS = "hparams.json"
STATISTICS = "statistics.json"
def get_name(h_params):
"""Get experiment name from hyper parameter json file."""
protagonist_name = h_params.protagonist_name[0]
if protagonist_name in ["MVE", "Dyna", "STEVE"]:
... | pd.DataFrame() | pandas.DataFrame |
import argparse
import sys
import pandas as pd
def process_command_line():
"""
Parse command line arguments
`argv` is a list of arguments, or `None` for ``sys.argv[1:]``.
Return a Namespace representing the argument list.
"""
# Create the parser
parser = argparse.ArgumentParser(prog='mm... | pd.read_csv(perf_curve_pred_filename) | pandas.read_csv |
import numpy as np
import pytest
from pandas import Categorical, Series
import pandas._testing as tm
@pytest.mark.parametrize(
"keep, expected",
[
("first", Series([False, False, False, False, True, True, False])),
("last", Series([False, True, True, False, False, False, False])),
(Fa... | Categorical(input1, categories=cat_array, ordered=ordered) | pandas.Categorical |
from datetime import datetime
import numpy as np
import pytest
import pandas.util._test_decorators as td
from pandas.core.dtypes.base import _registry as ea_registry
from pandas.core.dtypes.common import (
is_categorical_dtype,
is_interval_dtype,
is_object_dtype,
)
from pandas.core.dtypes.dtypes import (... | tm.assert_index_equal(rs.index, rng) | pandas._testing.assert_index_equal |
"""Assay information class"""
import os
import yaml
import pandas as pd
from .example_filetype_format import FileTypeFormat
from . import process_functions
class Assayinfo(FileTypeFormat):
"""Assay information file type"""
_fileType = "assayinfo"
_process_kwargs = ["newPath", "databaseSynId"]
def... | pd.isnull(i) | pandas.isnull |
import pandas as pd
import xlsxwriter
array = [['a1', 'a2', 'a3'],
['a4', 'a5', 'a6'],
['a7', 'a8', 'a9'],
['a10', 'a11', 'a12', 'a13', 'a14']]
months = ['jan', 'feb', 'mar', 'apr', 'may']
df = | pd.DataFrame(array, columns=months) | pandas.DataFrame |
import mne
import pandas as pd
from my_settings import *
reject = dict(grad=4000e-13, # T / m (gradiometers)
mag=4e-12, # T (magnetometers)
eeg=180e-6 #
)
result = | pd.DataFrame() | pandas.DataFrame |
import json
import pandas as pd
import sys
from tl.file_formats_validator import FFV
from tl.exceptions import UnsupportTypeError
from concurrent.futures import ThreadPoolExecutor
from itertools import repeat
class Utility(object):
def __init__(self, es, output_column_name: str = 'retrieval_score',
... | pd.DataFrame(candidates_format) | 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... | Series([0.4, np.nan, np.nan], index=exp_idx, name='s') | pandas.core.api.Series |
##
drive_path = 'c:/'
import numpy as np
import pandas as pd
import os
import sys
import matplotlib.pyplot as plt
from scipy.stats import ks_2samp
from scipy.stats import anderson_ksamp
from scipy.stats import kruskal
from scipy.stats import variation
from scipy import signal as sps
import seaborn as sns
import glob
im... | pd.DataFrame([]) | pandas.DataFrame |
# --------------
# Importing header files
import numpy as np
import pandas as pd
from scipy.stats import mode
import warnings
warnings.filterwarnings('ignore')
#Reading file
bank_data = | pd.read_csv(path) | pandas.read_csv |
# import sys, os
# sys.path.append( os.path.join( os.path.dirname( __file__ ), '..' ) )
import numpy as np
import pandas as pd
from . import ConfusionMatrix
y_true = [1,1,3,1]
y_pred = [1,2,2,1]
labels = [1,2,3]
names = ['foo','bar','baz']
def test_create_cmat():
'''
Check that constructing method, called w... | pd.Series([3,0,1], index=names ) | pandas.Series |
from collections import defaultdict
import csv
import pandas.compat as compat
from pandas import DataFrame
from pandas_datareader.base import _BaseReader
_yahoo_codes = {'symbol': 's', 'last': 'l1', 'change_pct': 'p2', 'PE': 'r',
'time': 't1', 'short_ratio': 's7'}
class YahooQuotesReader(_BaseReade... | compat.itervalues(_yahoo_codes) | pandas.compat.itervalues |
#!/usr/bin/env python3
from argparse import ArgumentParser
from collections import defaultdict
import os
import sys
import matplotlib
matplotlib.use('pdf')
matplotlib.rcParams['pdf.fonttype'] = 42
matplotlib.rcParams['ps.fonttype'] = 42
matplotlib.rcParams['font.size'] = 12
import matplotlib.pyplot as plt
import numpy... | pd.merge(df, check, how="left", on=["dataset", "id"]) | pandas.merge |
import streamlit as st
import pandas as pd
from pyvis.network import Network
import networkx as nx
import matplotlib.pyplot as plt
import bz2
import pickle
import _pickle as cPickle
import pydot
import math
import numpy as num
def decompress_pickle(file):
data = bz2.BZ2File(file, 'rb')
data = cPickle.load(data)
re... | pd.DataFrame() | pandas.DataFrame |
from datetime import datetime, timedelta, timezone
import random
from tabnanny import check
import unittest
import pandas as pd
import pytz
if __name__ == "__main__":
from pathlib import Path
import sys
sys.path.insert(0, str(Path(__file__).resolve().parents[2]))
from datatube.dtype import check_dtypes
... | pd.DataFrame(ALL_DATA) | pandas.DataFrame |
import streamlit as st
import pandas as pd
import altair as alt
import numpy as np
from streamlit_option_menu import option_menu
import xgboost as xgb
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_squared_error
from sklearn.model_selection import cross_val_score, KFold
from sklea... | pd.cut(x=state['avgSalary'], bins=[0,50,100,150,200, 250, 300], labels=category) | pandas.cut |
"""
This module contains all US-specific data loading and data cleaning routines.
"""
import datetime
import requests
import pandas as pd
import numpy as np
from .. import data
idx = pd.IndexSlice
def get_raw_covidtracking_data(run_date: pd.Timestamp):
""" Gets the current daily CSV from COVIDTracking """
i... | pd.Timestamp("2020-06-03") | pandas.Timestamp |
import numpy as np
import pandas as pd
import pytest
from blocktorch.problem_types import (
ProblemTypes,
detect_problem_type,
handle_problem_types,
is_binary,
is_classification,
is_multiclass,
is_regression,
is_time_series,
)
@pytest.fixture
def correct_problem_types():
# Unit te... | pd.Series([1, 0, 1, 0, 0, 1]) | pandas.Series |
# To add a new cell, type '#%%'
# To add a new markdown cell, type '#%% [markdown]'
#%%
from IPython import get_ipython
#%%
import os
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import io
import base64
from matplotlib import animation
from matplotlib import cm
from matplotlib.pyplot import... | pd.DataFrame() | pandas.DataFrame |
import pytest
import pandas as pd
from getdera import utils
from pandas.testing import assert_frame_equal
from getdera.dera import process
# TESTCASES
TEST_DATA_PATH = 'getdera/tests/data'
TESTCASES = {
'process_tag': [
{'args': (f'{TEST_DATA_PATH}',
'risk',
'tag',... | assert_frame_equal(result, expected) | pandas.testing.assert_frame_equal |
#!/usr/bin/env python
# coding: utf-8
# # day6 宿題
# 作成：松島亮輔
#
# 課題：住宅販売価格を予測する
# In[1]:
get_ipython().run_line_magic('matplotlib', 'inline')
#グラフをnotebook内に描画させるための設定
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from sklearn import linear_model
from sklearn.decomposition import PCA #主成分分... | pd.DataFrame(Y) | pandas.DataFrame |
# -*- coding: utf-8 -*-
import sys
# import io
from collections import OrderedDict
from tabulate import tabulate
import decimal
from decimal import Decimal
import itertools
import numbers
import string
import numpy as np
from scipy import stats
import pandas as pd
#import seaborn as sns
import matplotlib as mpl
impor... | pd.DataFrame(columns=['LATITUDE_SOUTH_180']) | pandas.DataFrame |
# Copyright (c) 2018-2021, NVIDIA CORPORATION.
import array as arr
import datetime
import io
import operator
import random
import re
import string
import textwrap
from copy import copy
import cupy
import numpy as np
import pandas as pd
import pyarrow as pa
import pytest
from numba import cuda
import cudf
from cudf.c... | pd.Index([0, 1, 2, 8, 11, 15]) | pandas.Index |
from sklearn.preprocessing import LabelEncoder
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.model_selection import train_test_split
from tensorflow.keras.models import Sequential
from tensorflow.keras.callbacks import EarlyStopping, ModelCheckpoint
from tensorflow.keras.layers import Dr... | pd.DataFrame(Xtrain) | pandas.DataFrame |
from functools import partialmethod
import pandas as pd
from sqlalchemy.orm import sessionmaker
from sqlalchemy import create_engine
import sqlite3
import click
import json
import pkg_resources
from itertools import combinations
from q2_mlab.db.schema import RegressionScore
from q2_mlab.plotting.components import (
... | pd.crosstab(data[by], data[category]) | pandas.crosstab |
import plotly.graph_objects as go
from plotly.subplots import make_subplots
from parameters_cov import params
import pandas as pd
import numpy as np
from math import ceil
import datetime
from data_constants import POPULATIONS
month_len = 365/12
longname = {'S': 'Susceptible',
'I': 'Infected',
'R': '... | pd.Series(sol['y'][index[name],:]) | pandas.Series |
# -*- coding: utf-8 -*-
"""
Created on Mon Jan 27 13:30:31 2020
@author: User
"""
import sys
import datetime as dt
from collections import Counter
import pprint
import matplotlib
import matplotlib.pyplot as plt
import matplotlib.lines as mlines
from matplotlib import cm
from matplotlib import gridspe... | pd.read_pickle(IndexOVV_ORRpars_fn) | pandas.read_pickle |
import numpy as np
import pandas as pd
from copy import copy, deepcopy
from matplotlib import pyplot as plt
from datetime import datetime, timedelta
from matplotlib.backends.backend_pdf import PdfPages
dfheight= | pd.read_csv('../data/raw/Results from Val_Roseg_Timelapse in µm per sec.csv') | pandas.read_csv |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.