def biocLite(package=None, suppressUpdates=True, verbose=True):
"""Install a bioconductor package
This function does not work like the R function. Only a few options are
implemented so far. However, you can use rcode function directly if needed.
:param str package: name of the bioconductor package to install. If None, no
package is installed but installed packages are updated. If not provided,
biocLite itself may be updated if needed.
:param bool suppressUpdates: updates the dependencies if needed (default is
False)
:return: True if update is required or the required package is installed and
could be imported. False otherwise.
::
>>> from biokit.viz.rtools import biocLite
>>> biocLite("CellNOptR")
"""
code = """source("http://bioconductor.org/biocLite.R")\n"""
# without a package, biocLite performs an update of the installed packages
if package is None:
code += """biocLite(suppressUpdates=%s) """ % (
bool2R(suppressUpdates))
else:
# if not found, no error is returned...
code += """biocLite("%s", suppressUpdates=%s) """ % (
package,
bool2R(suppressUpdates))
r = RSession(verbose=verbose)
r.run(code)
def __init__(self, name, version_required=None, install=False, verbose=False):
self.name = name
self.version_required = version_required # the required version
if self.version_required and isinstance(self.version_required, str) is False:
raise TypeError("version_required argument must be a string e.g., 2.0, 2.0.1")
if version_required and "." not in self.version_required:
# trying to infer correct version
self.version_required += '.0'
self.session = RSession()
code = """rvar_version = as.character(packageVersion("%s"))"""
self.session.run(code % (self.name))
try:
self._version = self.session.rvar_version
except:
self._version = None
if self.version is None and install is True:
self.install(name)
if self.version and self.version_required:
if self._get_val_version(self.version) >= self._get_val_version(self.version_required):
pass
else:
print("Found %s (version %s) but version %s required." % (
self.name, self.version, self.version_required))
def install_package(query,
dependencies=False,
verbose=True,
repos="http://cran.univ-paris1.fr/"):
"""Install a R package
:param str query: It can be a valid URL to a R package (tar ball), a CRAN
package, a path to a R package (tar ball), or simply the directory
containing a R package source.
:param bool dependencies:
:param repos: if provided, install_packages automatically select the
provided repositories otherwise a popup window will ask you to select a repo
::
>>> rtools.install_package("path_to_a_valid_Rpackage.tar.gz")
>>> rtools.install_package("http://URL_to_a_valid_Rpackage.tar.gz")
>>> rtools.install_package("hash") # a CRAN package
>>> rtools.install_package("path to a valid R package directory")
.. seealso:: :class:`biokit.rtools.RPackageManager`
"""
session = RSession(verbose=verbose)
# Is it a local file?
if os.path.exists(query):
repos = 'NULL'
else:
repos = '"{0}"'.format(
repos) # we want the " to be part of the string later on
try:
# PART for fetching a file on the web, download and install locally
if verbose:
print("Trying from the web ?")
data = urlopen(query)
fh = TempFile(suffix=".tar.gz")
with open(fh.name, 'w') as fh:
for x in data.readlines():
fh.write(x)
code = """install.packages("%s", dependencies=%s """ % \
(fh.name, bool2R(dependencies))
code += """ , repos=NULL) """
session.run(code)
except Exception as err:
if verbose:
print(err)
print("trying local or from repos")
print(
"RTOOLS warning: URL provided does not seem to exist %s. Trying from CRAN"
% query)
code = """install.packages("%s", dependencies=%s """ % \
(query, bool2R(dependencies))
code += """ , repos=%s) """ % repos
session.run(code)
return
def __init__(self, filename=None):
if filename is None:
filename = easydev.get_share_file('gdsctools', 'data',
'PANCAN_simple_MOBEM.rdata')
super(PANCAN, self).__init__(filename)
# Remove R dependencies
from biokit.rtools import RSession
self.session = RSession()
self.session.run('load("%s")' % self._filename)
self.df = self._read_matrix_from_r('MoBEM')
def __init__(self, filename="djvIC50v17v002-nowWithRMSE.rdata"):
super(Extra, self).__init__(filename)
# Remove R dependencies
from biokit.rtools import RSession
self.session = RSession()
self.session.run('load("%s")' % self._filename)
# 3 identical matrices containing AUC, IC50 and
self.dfAUCv17 = self._read_matrix_from_r('dfAUCv17')
self.dfIC50v17 = self._read_matrix_from_r('dfIC50v17')
# Residual
self.dfResv17 = self._read_matrix_from_r('dfResv17')
# This df holds the xmid/scale parameters for each cell line
# Can be visualised using the tools.Logistic class.
self.dfCL = self._read_matrix_from_r('dfCL')
def get_R_version():
"""Return R version"""
r = RSession()
r.run("version")
return r.version
def __init__(self, verbose=True):
self.session = RSession()
self.logging = Logging(verbose)
self.logging.info('Fetching package information')
self.update()
def __init__(self, verboseR):
assert verboseR in [True, False]
self._verboseR = verboseR
self.session = RSession(verbose=self.verboseR)
