def insallRpackages(options): """Install R packages that cannot be installed using pip install ...""" #from rpy2.robjects.packages import importr src = join(sys.prefix, "lib", "R-3.2.3", "lib64", "R", "lib") spe = "$" cmd = 'export LD_LIBRARY_PATH=%sLD_LIBRARY_PATH:%s' %(spe,src) sh(cmd) # import rpy2.robjects as robjects import rpy2.robjects.packages as rpackages #from rpy2.robjects.vectors import StrVector packageNames = ('ggplot2') if all(rpackages.isinstalled(x) for x in packageNames): have_packages = True else: have_packages = False if not have_packages: #utils = rpackages.importr('utils') #utils.chooseCRANmirror(ind=1, useHTTPS=False) packnames_to_install = [x for x in packageNames if not rpackages.isinstalled(x)] # if len(packnames_to_install) > 0: # utils.install_packages(StrVector(packnames_to_install)) if len(packnames_to_install) > 0: # install biocondcutor package base = rpackages.importr('base') base.source("http://www.bioconductor.org/biocLite.R") biocinstaller = rpackages.importr("BiocInstaller") biocinstaller.biocLite("ggplot2", suppressUpdates=True)
def insallRpackages(options): """Install R packages that cannot be installed using pip install ...""" #from rpy2.robjects.packages import importr src = join(sys.prefix, "lib", "R-3.2.3", "lib64", "R", "lib") spe = "$" cmd = 'export LD_LIBRARY_PATH=%sLD_LIBRARY_PATH:%s' % (spe, src) sh(cmd) # import rpy2.robjects as robjects import rpy2.robjects.packages as rpackages #from rpy2.robjects.vectors import StrVector packageNames = ('ggplot2') if all(rpackages.isinstalled(x) for x in packageNames): have_packages = True else: have_packages = False if not have_packages: #utils = rpackages.importr('utils') #utils.chooseCRANmirror(ind=1, useHTTPS=False) packnames_to_install = [ x for x in packageNames if not rpackages.isinstalled(x) ] # if len(packnames_to_install) > 0: # utils.install_packages(StrVector(packnames_to_install)) if len(packnames_to_install) > 0: # install biocondcutor package base = rpackages.importr('base') base.source("http://www.bioconductor.org/biocLite.R") biocinstaller = rpackages.importr("BiocInstaller") biocinstaller.biocLite("ggplot2", suppressUpdates=True)
def cran(): print("install R packages") from rpy2.robjects.packages import importr, isinstalled if not os.path.exists(R_REQUIREMENTS): print(" {} not found".format(R_REQUIREMENTS)) return False rlib = os.path.abspath(os.path.join(os.path.dirname(sys.executable), RLIB)) if not os.path.isdir(rlib): os.makedirs(rlib) print(" {} created".format(rlib)) with open(R_REQUIREMENTS, 'r') as file: data = file.read() packages_required = data.split(sep='\n') utils = importr('utils') utils.chooseCRANmirror(ind=0) for package in packages_required: if package: if not isinstalled(package, lib_loc=rlib): print(" install", package) utils.install_packages(package, lib=rlib, verbose=False, quiet=True) else: print(" requirement", package, "already satisfied")
def install_bart(self): import rpy2.robjects.packages as rpackages from rpy2.robjects.packages import importr from rpy2.robjects.vectors import StrVector import rpy2.robjects as robjects robjects.r.options(download_file_method='curl') # install.packages("rJava") rj = importr("rJava", robject_translations={'.env': 'rj_env'}) rj._jinit(parameters="-Xmx16g", force_init=True) print( "rJava heap size is", np.array(rj._jcall(rj._jnew("java/lang/Runtime"), "J", "maxMemory"))[0] / 1e9, "GB.", file=sys.stderr) package_names = ["bartMachine"] utils = rpackages.importr('utils') utils.chooseCRANmirror(ind=0) utils.chooseCRANmirror(ind=0) names_to_install = [ x for x in package_names if not rpackages.isinstalled(x) ] if len(names_to_install) > 0: utils.install_packages(StrVector(names_to_install)) return importr("bartMachine")
def importFromDashUtils(funcName): # Check to ensure that the direct parent of study_management/ is dashboard/ path = Path(os.getcwd()) parent = path.parent.parts[-1] if parent != "dashboard": # raise exception if the direct parent is not dashboard/ raise Exception( "Error: the direct parent of 'study_management/' should be 'dashboard/'." ) # import R's utility package utils = rpackages.importr('utils') # select a mirror for R packages utils.chooseCRANmirror(ind=1) # select the first mirror in the list # R package names, copied from dashboard/dashboard_utils.R packnames = ("RSQLite", "plyr", "dplyr", "ggplot2", "zoo", "sqldf", "rjson", "reticulate") # Selectively install what needs to be install. names_to_install = [x for x in packnames if not rpackages.isinstalled(x)] if len(names_to_install) > 0: utils.install_packages(StrVector(names_to_install)) # Defining the R script and loading the instance in Python r = robjects.r r['source']('../dashboard_utils.R') # Loading the function we have defined in R r_func = robjects.globalenv[funcName] # return the selected function return r_func
def create_clustering_file(outdir, outfile): base = rpackages.importr('base') packageNames = ('tidyverse') utils = rpackages.importr('utils') utils.chooseCRANmirror(ind=1) packnames_to_install = [ x for x in packageNames if not rpackages.isinstalled(x) ] if len(packnames_to_install) > 0: utils.install_packages(StrVector(packnames_to_install)) tidyverse = rpackages.importr('tidyverse') robjects.r['options'](warn=-1) create_file = robjects.r(''' function(results_file,outdir) { all_domains_blast_df <- read_tsv(results_file, col_names = F) names(all_domains_blast_df) <- c("sseqid", "slen","sstart", "send", "qseqid", "qlen", "qstart", "qend", "qcovs", "pident"," evalue", "Sample", "cohort") all_domains_blast_df_count <- all_domains_blast_df %>% group_by(Sample, qseqid) %>% count() %>% ungroup() all_domains_blast_df_count_table <- all_domains_blast_df_count %>% spread(., Sample, n, fill =0 ) abundFile = file.path(outdir, "unique-biosynthetic-reads-abundance-table.txt") abundWideFile = file.path(outdir, "unique-biosynthetic-reads-abundance-table-wide.txt") write_tsv(all_domains_blast_df_count_table, abundFile, col_names = T) write_tsv(all_domains_blast_df_count, abundWideFile, col_names = T) } ''') create_file(outfile, outdir)
def create_reformat_data(input_df, outdir): rpackages.importr('base') utils = rpackages.importr('utils') packageNames = ('tidyverse') packnames_to_install = [ x for x in packageNames if not rpackages.isinstalled(x) ] if len(packnames_to_install) > 0: utils.install_packages(StrVector(packnames_to_install)) rpackages.importr('tidyverse') robjects.r['options'](warn=-1) reformat_df = robjects.r(''' function(hmmdf,outDir) { hmmdfRecoded <- separate(hmmdf, readID, into = c("read","F_R_read_frame"), sep = "_", extra = "merge") %>% select(-c(F_R_read_frame)) hmmdfRecodedDFUnique<-aggregate(HMMScore ~ read + Sample + sampleType + protType , hmmdfRecoded, max) colnames(hmmdfRecodedDFUnique)<-c("readID","Sample", "sampleType", "protType","HMMScore") write_tsv(hmmdfRecodedDFUnique, file.path(outDir, "spHMM-filtered-results.txt"), col_names = T) return(hmmdfRecodedDFUnique) } ''') # convert pandas df to R datafame with localconverter(ro.default_converter + pandas2ri.converter): input_r_df = ro.conversion.py2rpy(input_df) data_filter = reformat_df(input_r_df, outdir) return (data_filter)
def get_results_from_r( processed_data: pd.DataFrame, experiment_config: ExperimentConfig) -> ExperimentOutput: """ Get results from the CausalImpact implementation using R :type experiment_config.training_period: List[int] :type experiment_config.evaluation_period: List[int] """ processed_data.set_index(experiment_config.time_var, inplace=True) pre_period = robjects.FloatVector(experiment_config.training_period) post_period = robjects.FloatVector(experiment_config.evaluation_period) # Load R libraries utils = rpackages.importr("utils") utils.chooseCRANmirror(ind=1) lib_names = ("CausalImpact", "bsts") libs_to_install = [x for x in lib_names if not rpackages.isinstalled(x)] if len(libs_to_install) > 0: utils.install_packages(StrVector(libs_to_install)) robjects.numpy2ri.activate() pandas2ri.activate() rdf = robjects.conversion.py2rpy(processed_data) causalimpact = importr("CausalImpact") ci = causalimpact.CausalImpact(rdf, pre_period, post_period) summary = robjects.r("function(x) x$summary") results = summary(ci).T results.rename( index={ "Actual": "actual", "Pred": "predicted", "Pred.lower": "predicted_lower", "Pred.upper": "predicted_upper", "Pred.sd": "predicted_sd", "AbsEffect": "abs_effect", "AbsEffect.lower": "abs_effect_lower", "AbsEffect.upper": "abs_effect_upper", "AbsEffect.sd": "abs_effect_sd", "RelEffect": "rel_effect", "RelEffect.lower": "rel_effect_lower", "RelEffect.upper": "rel_effect_upper", "RelEffect.sd": "rel_effect_sd", }, inplace=True, ) results.columns = ["average", "cumulative"] experiment_output = ExperimentOutput( **{ "results_summary": results, "trained_model": ci, "experiment_name": experiment_config.experiment_name, }) return experiment_output
def import_R_library(rpacknames): from rpy2.robjects.vectors import StrVector utils = rpackages.importr('utils') utils.chooseCRANmirror(ind=1) names_to_install = [x for x in rpacknames if not rpackages.isinstalled(x)] if len(names_to_install) > 0: utils.install_packages(StrVector(names_to_install))
def uninstall_grf(): """ Ensures the grf packages is not installed before the test runs""" if rpackages.isinstalled("grf"): robjects.r.options(download_file_method="curl") utils = rpackages.importr("utils") utils.chooseCRANmirror(ind=0) utils.remove_packages(StrVector(["grf"]))
def fart_ass(gene_counts, metadata, output_dir, output_name): # imports utils = importr('utils') utils.chooseBioCmirror(ind=1) # select the first mirror in the list if (not rpackages.isinstalled('kBET')): print('kBET not installed, installing kBET') utils.install_packages('../source_packages/kBET-master.zip', type="source") else: print('kBET alraedy installed') if (not rpackages.isinstalled('devtools')): print('devtools not installed, installing devtools') utils.install_packages('devtools') else: print('devtools alraedy installed') #devtools = importr('devtools') #devtools.install_github('theislab/kBET') kBET = importr('kBET') batch = metadata['batch'] # ### # # #r_gene_counts = ro.conversion.py2rpy(gene_counts) results = kBET(gene_counts, batch, plot=False) #utils.install_packages('gutenbergr', repos='https://cloud.r-project.org') print('we made it this far') #packages = ['devtools', 'kBET', 'bapred', 'ggplot2'] #packages_to_install = [p for p in packages if not rpackages.isinstalled(p)] #for package in packages_to_install: # utils.install_packages(package, repos='https://cloud.r-project.org' # load imports #devtools = importr('devtools') #kBet = importr('kBET')) rstring = """
def install_r_package(name): from rpy2.robjects.vectors import StrVector from rpy2.robjects.packages import importr, isinstalled if not isinstalled(name): utils = importr("utils") utils.chooseCRANmirror(ind=1) utils.install_packages(StrVector([name]))
def RimportLibrary(lib_name): """ Helper function to import R libraries using the rpy2 binder """ if not rpackages.isinstalled(lib_name): base.source("http://www.bioconductor.org/biocLite.R") biocinstaller = rpackages.importr("BiocInstaller") biocinstaller.biocLite(lib_name) return rpackages.importr(lib_name)
def import_packages(self): for im in self.imports: if not rpackages.isinstalled(im): utils = rpackages.importr('utils') utils.chooseCRANmirror(ind=1) ## FIXME: this returns rpy2.rinterface.NULL if package is not found utils.install_packages(im) rpackages.importr(im) self.ready = True
def activate_r_packages(packnames): if all(rpackages.isinstalled(x) for x in packnames): have_tutorial_packages = True else: have_tutorial_packages = False if not have_tutorial_packages: # import R's utility package utils = rpackages.importr('utils') # select a mirror for R packages utils.chooseCRANmirror(ind=1) # select the first mirror in the list #We are now ready to install packages using R's own function install.package: if not have_tutorial_packages: # R vector of strings from rpy2.robjects.vectors import StrVector # file packnames_to_install = [x for x in packnames if not rpackages.isinstalled(x)] if len(packnames_to_install) > 0: utils.install_packages(StrVector(packnames_to_install))
def r_importer(modules, install_only=[], log=False): """ Import and install R packages. If the desired packages are not installed it will automatically install them. Note that this function will act as a one time delay in running time, if modules need to be installed. Import R packages manually as e.g. <stargazer = rpy2.robjects.packages.importr('stargazer')>. So, the same name used for installing, should be used to import the functions. Important to note, this function imports the following modules from rpy2: "rpy2.robjects.packages" and "rpy2.robjects.vectors". Args: modules: list of the desired packages. The packages to be included should be as a string. E.g. modules = ['stargazer', 'tidyverse']. install_only: default=None. list or string of packages to be installed only. Note, combinations are possible. log: default=False. Prints a log message if true, of the packages that are (succesfully) installed. Returns: None """ if not isinstance(modules, list): modules = [modules] if not isinstance(install_only, list): install_only = [install_only] # import R's utility package: utils = rpackages.importr('utils') # R package names: packnames = tuple(modules) # Selectively install what needs to be install. Use CRAN cloud server: names_to_install = [x for x in packnames if not rpackages.isinstalled(x)] if len(names_to_install) > 0: print('Installing:', names_to_install) with walpy.suppress(): utils.install_packages(StrVector(names_to_install), repos='https://cloud.r-project.org/') print('Successfully installed:', names_to_install) # Make modules non-overlapping with install_only: modules = set(modules) - set(install_only) # Import modules to be automatically imported for module in modules: rpackages.importr(module) # Print log message if true: if log == True: print('Successfully imported:', [i for i in modules]) return
def fit_glm(data, family='binomial', glmnet_kwargs=None): """ :param data: the data dictionary :param family: response type :param glmnet_kwargs: dictionary of keyword arguments to pass the glmnet function in R. :return: pandas dataframe containing the fit model parameters. Each row corresponds to a unique value for lambda. """ if not packages.isinstalled(name='glmnet'): utils = packages.importr('utils') utils.chooseCRANmirror(ind=1) utils.install_packages('glmnet') if not glmnet_kwargs: glmnet_kwargs = {} # intercept should be added as a constant 1 feature, not via glmnet. Thus, always set to 'False'. if 'intercept' in glmnet_kwargs.keys(): assert glmnet_kwargs['intercept'] is False, \ "Do not add intercept in glmnet. Please add an intercept feature to the dataset instead." glmnet_kwargs['intercept'] = False # set default parameters if 'alpha' not in glmnet_kwargs.keys(): glmnet_kwargs['alpha'] = DEFAULT_ALPHA if 'nlambda' not in glmnet_kwargs.keys(): glmnet_kwargs['nlambda'] = DEFAULT_NLAMBDA # R set-up numpy2ri.activate() glmnet = importr('glmnet') n_row, n_col = data['X'].shape # transfer to R objects x_ = r.matrix(data['X'], nrow=n_row) y_ = r.matrix(data['Y'], nrow=n_row) weights = FloatVector(data['sample_weights']) output = glmnet.glmnet(x=x_, y=y_, family=family, weights=weights, **glmnet_kwargs) coefs = r.t(sparse_to_full_matrix(output.rx2('beta'))) coefs = np.array(coefs) # drop added intercept column which is fixed at 0 lambda_ = output.rx('lambda') lambda_ = np.array(r.matrix(lambda_))[0] coef_names = data['variable_names'] df = pd.DataFrame(coefs, columns=coef_names) df['lambda_'] = lambda_ df['alpha'] = glmnet_kwargs['alpha'] return df
def grf(): """ Ensures grf is installed before running tests with it This is required as usually the user is requested to install the package manually """ if not rpackages.isinstalled("grf"): install_r_packages(["grf"]) return 0 return 1
def install_r_dependencies(r_package_names, r_bioconducter_package_names): from rpy2.robjects.packages import importr import rpy2.robjects.packages as rpackages r_packages_uninstalled = [ x for x in r_package_names if not rpackages.isinstalled(x) ] r_bioconducter_packages_uninstalled = [ x for x in r_bioconducter_package_names if not rpackages.isinstalled(x) ] if r_packages_uninstalled: utils = importr('utils') utils.chooseCRANmirror(ind=1) for p in r_packages_uninstalled: utils.install_packages(p) if r_bioconducter_packages_uninstalled: biocm = importr("BiocManager") for p in r_bioconducter_packages_uninstalled: biocm.install(p)
def install_package(): #you must run this as root packnames = ('readxl', 'BiocManager', 'ggplot2', 'gridExtra') if all(rpackages.isinstalled(x) for x in packnames): have_packages = True else: have_packages = False if not have_packages: utils = rpackages.importr('utils') utils.chooseCRANmirror(ind=1) packnames_to_install = [ x for x in packnames if not rpackages.isinstalled(x) ] if len(packnames_to_install) > 0: utils.install_packages(StrVector(packnames_to_install)) r('BiocManager::install("ropls")')
def setupCluster(): # import R's utility package utils = rpackages.importr('utils') # select a mirror for R packages utils.chooseCRANmirror(ind=1) # select the first mirror in the list for x in packnames: if not rpackages.isinstalled(x): utils.install_packages(x) print ( "installing ", x ) print( "In case lgfortran is missing make sure these have same used version of gcc, g++ and gfortran" )
def install_r_packages(rlib): from rpy2.robjects.packages import importr, isinstalled r_requirements = "r.txt" if os.path.exists(r_requirements): with open(r_requirements, 'r') as file: data = file.read() else: data = "" packages_required = data.split(sep='\n') for default in R_DEFAULT: if default not in packages_required: packages_required.append(default) utils = importr('utils') utils.chooseCRANmirror(ind=1) for package in packages_required: if package: output('Checking package: {}', package) output('Installed?: {}', isinstalled(package, lib_loc=rlib)) if not (isinstalled(package, lib_loc=rlib)): utils.install_packages(package, lib=rlib, verbose=False, quiet=True)
def install_r_packages(): import rpy2.robjects.packages as rpackages from rpy2.robjects.vectors import StrVector utils = rpackages.importr('utils') utils.chooseCRANmirror(ind=1) packnames = ['zoo', 'caTools', 'gets'] names_to_install = [ pkg for pkg in packnames if not rpackages.isinstalled(pkg) ] if len(names_to_install) > 0: utils.install_packages(StrVector(names_to_install)) print('Installed ' + str(names_to_install))
def install_packages(): packnames = ('base', 'ggplot2', 'smoof', 'mlr', 'mlrMBO', 'DiceKriging', 'randomForest', 'ParamHelpers', 'stats', 'rgenoud', 'lhs', 'methods', 'emoa') if all(isinstalled(x) for x in packnames): have_tutorial_packages = True else: have_tutorial_packages = False if not have_tutorial_packages: # import R's utility package utils = importr('utils') # select a mirror for R packages utils.chooseCRANmirror(ind=1) # select the first mirror in the list # R vector of strings from rpy2.robjects.vectors import StrVector # file packnames_to_install = [x for x in packnames if not isinstalled(x)] if len(packnames_to_install) > 0: utils.install_packages(StrVector(packnames_to_install))
def gen_match(Tr, X, estimand='ATT'): # Install the Matching and rgenoud R packages, if not already installed to_install = [ x for x in [MATCHING, RGENOUD] if not rpackages.isinstalled(x) ] if len(to_install) > 0: utils = importr('utils') utils.chooseCRANmirror(ind=1) # select the first mirror in the list utils.install_packages(StrVector(to_install)) matching = importr(MATCHING) # import Matching R package importr(RGENOUD) return matching.GenMatch(Tr=Tr, X=X, estimand=estimand)
def check_r_packages(packnames): """ Check R packages in list `packnames` are installed Return empty string if all packages are installed, otherwise, informative error message. """ missing_packnames = [] for packname in packnames: if not rpackages.isinstalled(packname): missing_packnames.append(packname) if len(missing_packnames) == 0: return '' raise RuntimeError("Please install R package(s) " + ', '.join(missing_packnames))
def rpy2_init() -> None: import rpy2.robjects.packages as rpackages from rpy2.robjects.vectors import StrVector global bnlearn, gRain, utils # Initialize RPY2 utils = rpackages.importr('utils') utils.chooseCRANmirror(ind=1) # Install packages packages = ('bnlearn', 'gRain') packages_to_install = [x for x in packages if not rpackages.isinstalled(x)] if len(packages_to_install) > 0: utils.install_packages(StrVector(packages_to_install)) # Import packages bnlearn = rpackages.importr('bnlearn') gRain = rpackages.importr('gRain')
def get_package(package): """ Exposes all R objects in package as Python objects after checking that it is installed. Parameters: package (str): the name of an R package Returns: Exposed R package """ if isinstalled(package): return importr(package) else: raise ProcessError(f"R package, {package}, is not installed")
def __init__(self, packnames): """Initialise the object through checking the required packages and install them if needed. Input -> packnames : tuple of required r packages """ # import rpy2's package module import rpy2.robjects.packages as rpackages if all(rpackages.isinstalled(x) for x in packnames): have_tutorial_packages = True else: have_tutorial_packages = False if not have_tutorial_packages: # import R's utility package utils = rpackages.importr('utils') # select a mirror for R packages utils.chooseCRANmirror(ind=1) # select the first mirror in the list if not have_tutorial_packages: # R vector of strings from rpy2.robjects.vectors import StrVector # file packnames_to_install = [x for x in packnames if not rpackages.isinstalled(x)] if len(packnames_to_install) > 0: utils.install_packages(StrVector(packnames_to_install))
def install_package(self, pname): print('Check package {}...'.format(pname)) # import R's utility package utils = rpackages.importr('utils') # select a mirror for R packages utils.chooseCRANmirror(ind=1) # select the first mirror in the list # Selectively install what needs to be install. # We are fancy, just because we can. if not rpackages.isinstalled(pname): print('Package {} not installed, install it...'.format(pname)) utils.install_packages(pname) print('Package {} installed.'.format(pname)) else: print('Package {} already installed.'.format(pname))
def check_r_packages(): """Ensures required R packages are installed.""" # import R's utility package utils = rpackages.importr('utils') # select a mirror for R packages utils.chooseCRANmirror(ind=113) # Indiana # R package names packnames = ('classInt', 'minerva', 'randomForest', 'MASS', 'ggplot2', 'gplots') # R vector of strings packnames_to_install = [ x for x in packnames if not rpackages.isinstalled(x) ] if len(packnames_to_install) > 0: utils.install_packages(StrVector(packnames_to_install))
def install(): # Install BART robjects.r.options(download_file_method="curl") numpy2ri.activate() rj = importr("rJava", robject_translations={".env": "rj_env"}) rj._jinit(parameters="-Xmx16g", force_init=True) package_names = ["dbarts"] utils = rpackages.importr("utils") utils.chooseCRANmirror(ind=0) utils.chooseCRANmirror(ind=0) names_to_install = [ x for x in package_names if not rpackages.isinstalled(x) ] if len(names_to_install) > 0: utils.install_packages(StrVector(names_to_install), repos="http://cran.us.r-project.org")
def __init__(self, parent): super(QWidget, self).__init__(parent) utils = rpackages.importr('utils') utils.chooseCRANmirror(ind=1) packnames=('plotrix', 'psd', 'fractal', 'squash', 'doParallel') for x in packnames: if (not rpackages.isinstalled(x)): utils.install_packages(x) #self.layout es una ventana contenedora self.layout = QVBoxLayout(self) # Initialize tab screen #self.tabs es un elemento que soporta la contención de pestañas self.tabs = QTabWidget() #Pestañas self.tabVis = QWidget() self.tabEst = QWidget() self.tabEsp = QWidget() # Content Tabs self.tabVisLayout = Visualizacion() self.tabEstLayout = Estacionariedad() self.tabEspLayout = Espectro() # Add tabs self.tabs.addTab(self.tabVis,"Visualization") self.tabs.addTab(self.tabEst,"Estacionariedad") self.tabs.addTab(self.tabEsp,"Espectro") # Set asing layout self.tabVis.layout = self.tabVisLayout self.tabEst.layout = self.tabEstLayout self.tabEsp.layout = self.tabEspLayout # SetLayout Tabs self.tabVis.setLayout(self.tabVis.layout) self.tabEst.setLayout(self.tabEst.layout) self.tabEsp.setLayout(self.tabEsp.layout) # Add tabs to Main self.layout.addWidget(self.tabs) self.setLayout(self.layout)
def install_matchit(self): from rpy2.robjects.packages import importr import rpy2.robjects.packages as rpackages from rpy2.robjects.vectors import StrVector import rpy2.robjects as robjects package_names = ["MatchIt"] names_to_install = [x for x in package_names if not rpackages.isinstalled(x)] if len(names_to_install) > 0: robjects.r.options(download_file_method='curl') utils = rpackages.importr('utils') utils.chooseCRANmirror(ind=0) utils.chooseCRANmirror(ind=0) utils.install_packages(StrVector(names_to_install)) return importr("MatchIt")
def RCheckPackage(Packages): RPacksUsed = Packages RPacksToInstall = [Pack for Pack in RPacksUsed if not RPackages.isinstalled(Pack)] if len(RPacksToInstall) > 0: print(str(RPacksToInstall), 'not installed. Install now?') Ans = input('[y/N]: ') if Ans in ['y', 'yes', 'Yes', 'YES']: from rpy2.robjects.vectors import StrVector as RStrVector RUtils = RPackages.importr('utils') RUtils.chooseCRANmirror(ind=1) RUtils.install_packages(RStrVector(RPacksToInstall)) else: print('Aborted.') else: print('Packages', str(Packages), 'installed.') return(None)
def set_R_plotting_device(self, device): """ Set which device R should use to produce plots. If device == 'svg' then the package 'Cairo' must be installed. Because Cairo forces "onefile=TRUE", it is not posible to include multiple plots per cell. Parameters ---------- device : ['png', 'X11', 'svg'] Device to be used for plotting. Currently only "png" and "X11" are supported, with 'png' and 'svg' being most useful in the notebook, and 'X11' allowing interactive plots in the terminal. """ device = device.strip() if device not in ['png', 'X11', 'svg']: raise ValueError("device must be one of ['png', 'X11' 'svg'], got '%s'", device) if device == 'svg': try: self.cairo = rpacks.importr('Cairo') except ri.RRuntimeError as rre: if rpacks.isinstalled('Cairo'): msg = "An error occurred when trying to load the R package Cairo'\n%s" % str(rre) else: msg = """ The R package 'Cairo' is required but it does not appear to be installed/available. Try: import rpy2.robjects.packages as rpacks if not rpacks.isinstalled('Cairo'): utils = rpacks.importr('utils') utils.chooseCRANmirror(ind=1) from rpy2.robjects.vectors import StrVector utils.install_packages(StrVector(['Cairo'])) """ raise RInterpreterError(msg) self.device = device
import os # import rpy2's package module import rpy2.robjects.packages as rpackages # R vector of strings from rpy2.robjects.vectors import StrVector # import R's utility package utils = rpackages.importr('utils') base = rpackages.importr('base') # select a mirror for R packages utils.chooseCRANmirror(ind=1) # select the first mirror in the listls') # R package names packnames = ('WeightedCluster', 'TraMineR', 'seqdist2') # Selectively install what needs to be install. names_to_install = [x for x in packnames if not rpackages.isinstalled(x)] if len(names_to_install) > 0: utils.install_packages(StrVector(names_to_install)) directory = os.path.dirname(__file__) r_cluster_function_path = os.path.join(directory, 'clustering_sequences.R') cluster_function = base.dget(r_cluster_function_path) df_list = '/home/oscar/Documents/tropical_earm/earm_dataframes_consumption/data_frame37.csv' sm_df = '/home/oscar/Documents/tropical_earm/subs_matrix_consumption/sm_37.csv' cluster_function(df_list, sm_df, clusterMethod='PAM', clustered_pars_path=directory)
def RunWDModel(recent): pandas2ri.activate() # R package names packnames = ('forecast') if all(rpackages.isinstalled(x) for x in packnames): have_tutorial_packages = True else: have_tutorial_packages = False if not have_tutorial_packages: # import R's utility package utils = rpackages.importr('utils') # select a mirror for R packages utils.chooseCRANmirror(ind=1) # select the first mirror in the list if not have_tutorial_packages: # R vector of strings from rpy2.robjects.vectors import StrVector # file packnames_to_install = [x for x in packnames if not rpackages.isinstalled(x)] if len(packnames_to_install) > 0: utils.install_packages(StrVector(packnames_to_install)) # Import R packages forecast = importr('forecast') base = importr('base') # Model subset of data for particular station jump = 3 # skip weekend output = pd.DataFrame(columns=['count_diff', 'DateTime', 'Type', 'ID']) absent = [] errors = [] for x in station_range: SepModel = Model(recent, x) if SepModel.valid is False: absent.append(x) continue SepModel.PreProcess(separate=True) SepModel.WD = SepModel.WD[:480] if(len(SepModel.WD) > 0): if(x == 1): # Only needs to be run once, same for all stations WD_dates = SepModel.WD.index y = np.asarray(WD_dates[-1].year, dtype='datetime64[Y]') - 1970 doy = np.asarray((WD_dates[-1].dayofyear + jump), dtype='timedelta64[D]') - 1 new = pd.to_datetime(y + doy) new_dates = pd.DatetimeIndex(start=new, freq='30Min', periods=48 * 4) SepModel.WD.reset_index(inplace=True, drop=True) gc.collect() robjects.r('o = c(2,0,3)') robjects.r('sorder = c(1,1,2)') robjects.r('s = list(order=sorder, period=48)') DF = pandas2ri.py2ri(SepModel.WD) robjects.r.assign('df', DF) try: robjects.r('fit = Arima(df,order=o, seasonal=s, method="CSS")') except: errors.append(x) continue f_cast = robjects.r('f_cast = forecast(fit, h=4*48)') arima_mean = np.array(f_cast.rx('mean')) robjects.r('rm(list = ls(all = TRUE))') robjects.r('gc()') results = pd.DataFrame({'count_diff': arima_mean.flatten()}).round() results.count_diff = results.count_diff.astype(int) results['DateTime'] = new_dates results['Type'] = 'Forecast' results['ID'] = x SepModel.WD['DateTime'] = WD_dates SepModel.WD['Type'] = 'Historic' SepModel.WD['ID'] = x out = SepModel.WD.append(results) output = output.append(out) del f_cast del DF del SepModel gc.collect() output.ID = output.ID.astype(int) output.count_diff = output.count_diff.astype(int) output.reset_index(inplace=True, drop=True) path = wd + '\Model' if not os.path.exists(path): os.mkdir(path) output.to_csv(path + '\\' 'ModelOutput.csv') return output, absent, errors
def Run(self): self.transit_message("Starting ZINB analysis") start_time = time.time() packnames = ("MASS", "pscl") r_packages_needed = [x for x in packnames if not rpackages.isinstalled(x)] if (len(r_packages_needed) > 0): self.transit_error( "Error: Following R packages are required: %(0)s. From R console, You can install them using install.packages(c(%(0)s))" % ({'0': '"{0}"'.format('", "'.join(r_packages_needed))})) sys.exit(1) self.transit_message("Getting Data") (sites, data, filenamesInCombWig) = tnseq_tools.read_combined_wig(self.combined_wig) self.transit_message("Normalizing using: %s" % self.normalization) (data, factors) = norm_tools.normalize_data(data, self.normalization) condition_name = self.condition conditionsByFile, covariatesByFileList, interactionsByFileList, orderingMetadata = tnseq_tools.read_samples_metadata(self.metadata, self.covars, self.interactions, condition_name=condition_name) ## [Condition] in the order of files in combined wig conditions = self.wigs_to_conditions( conditionsByFile, filenamesInCombWig) ## [Covariate] in the order of files in combined wig covariates = self.wigs_to_covariates( covariatesByFileList, filenamesInCombWig) ## [Interaction] in the order of files in combined wig interactions = self.wigs_to_interactions( interactionsByFileList, filenamesInCombWig) data, conditions, covariates, interactions = self.filter_wigs_by_conditions( data, conditions, covariates = covariates, interactions = interactions, ignored_conditions = self.ignored_conditions, included_conditions = self.included_conditions) genes = tnseq_tools.read_genes(self.annotation_path) TASiteindexMap = {TA: i for i, TA in enumerate(sites)} RvSiteindexesMap = tnseq_tools.rv_siteindexes_map(genes, TASiteindexMap, nterm=self.NTerminus, cterm=self.CTerminus) statsByRv, statGroupNames = self.stats_by_rv(data, RvSiteindexesMap, genes, conditions, interactions) LogZPercByRep, NZMeanByRep = self.global_stats_for_rep(data) self.transit_message("Running ZINB") pvals, qvals, run_status = self.run_zinb(data, genes, NZMeanByRep, LogZPercByRep, RvSiteindexesMap, conditions, covariates, interactions) def orderStats(x, y): ic1 = x.split("_") ic2 = y.split("_") c1, i1 = (ic1[0], ic1[1]) if len(ic1) > 1 else (ic1[0], None) c2, i2 = (ic2[0], ic2[1]) if len(ic2) > 1 else (ic2[0], None) if len(self.included_conditions) > 0: condDiff = (self.included_conditions.index(c1) - self.included_conditions.index(c2)) ## Order by interaction, if stat belongs to same condition if condDiff == 0 and i1 is not None and i2 is not None: return (orderingMetadata['interaction'].index(i1) - orderingMetadata['interaction'].index(i2)) return condDiff ## Order by samples metadata, if include flag not provided. condDiff = (orderingMetadata['condition'].index(c1) - orderingMetadata['condition'].index(c2)) if condDiff == 0 and i1 is not None and i2 is not None: return (orderingMetadata['interaction'].index(i1) - orderingMetadata['interaction'].index(i2)) return condDiff orderedStatGroupNames = sorted(statGroupNames, orderStats) self.transit_message("Adding File: %s" % (self.output)) file = open(self.output,"w") head = ("Rv Gene TAs".split() + map(lambda v: "Mean_" + v, orderedStatGroupNames) + map(lambda v: "NZmean_" + v, orderedStatGroupNames) + map(lambda v: "NZperc_" + v, orderedStatGroupNames) + "pval padj".split() + ["status"]) file.write("#Console: python %s\n" % " ".join(sys.argv)) file.write('\t'.join(head)+EOL) for gene in genes: Rv = gene["rv"] vals = ([Rv, gene["gene"], str(len(RvSiteindexesMap[Rv]))] + ["%0.2f" % statsByRv[Rv]['mean'][group] for group in orderedStatGroupNames] + ["%0.2f" % statsByRv[Rv]['nz_mean'][group] for group in orderedStatGroupNames] + ["%0.2f" % statsByRv[Rv]['nz_perc'][group] for group in orderedStatGroupNames] + ["%f" % x for x in [pvals[Rv], qvals[Rv]]]) + [run_status[Rv]] file.write('\t'.join(vals)+EOL) file.close() self.transit_message("Finished Zinb analysis") self.transit_message("Time: %0.1fs\n" % (time.time() - start_time))
def check_r_packages(packagenames: list): results = dict() for package in packagenames: results[package] = rpackages.isinstalled(package) return results