def activate():
warnings.warn(
'The global conversion available with activate() '
'is deprecated and will be removed in the next '
'major release. Use a local converter.',
category=DeprecationWarning)
global original_converter
# If module is already activated, there is nothing to do.
if original_converter is not None:
return
original_converter = conversion.Converter(
'snapshot before pandas conversion', template=conversion.converter)
numpy2ri.activate()
new_converter = conversion.Converter('snapshot before pandas conversion',
template=conversion.converter)
numpy2ri.deactivate()
for k, v in py2rpy.registry.items():
if k is object:
continue
new_converter.py2rpy.register(k, v)
for k, v in rpy2py.registry.items():
if k is object:
continue
new_converter.rpy2py.register(k, v)
conversion.set_conversion(new_converter)
def activate():
global original_converter
# If module is already activated, there is nothing to do
if original_converter is not None:
return
original_converter = conversion.Converter(
'snapshot before pandas conversion', template=conversion.converter)
numpy2ri.activate()
new_converter = conversion.Converter('snapshot before pandas conversion',
template=conversion.converter)
numpy2ri.deactivate()
for k, v in py2ri.registry.items():
if k is object:
continue
new_converter.py2ri.register(k, v)
for k, v in ri2ro.registry.items():
if k is object:
continue
new_converter.ri2ro.register(k, v)
for k, v in py2ro.registry.items():
if k is object:
continue
new_converter.py2ro.register(k, v)
for k, v in ri2py.registry.items():
if k is object:
continue
new_converter.ri2py.register(k, v)
conversion.set_conversion(new_converter)
def full_converter() -> conversion.Converter:
pandas2ri.activate()
new_converter = conversion.Converter("anndata conversion", template=conversion.converter)
pandas2ri.deactivate()
overlay_converter(converter, new_converter)
return new_converter
def full_converter() -> conversion.Converter:
pandas2ri.activate()
new_converter = conversion.Converter("anndata conversion", template=conversion.converter)
pandas2ri.deactivate()
overlay_converter(scipy2ri.converter, new_converter)
# overwrite the scipy2ri Sexp4 converter and add our others
overlay_converter(converter, new_converter)
return new_converter
def activate():
"""
Activate conversion between sparse matrices from Scipy and R’s Matrix package.
Does nothing if this is the active conversion.
"""
global original_converter
if original_converter is not None:
return
original_converter = conversion.converter
numpy2ri.activate()
new_converter = conversion.Converter("scipy conversion",
template=conversion.converter)
numpy2ri.deactivate()
overlay_converter(converter, new_converter)
conversion.set_conversion(new_converter)
def activate():
global original_converter
# If module is already activated, there is nothing to do
if original_converter is not None:
return
original_converter = conversion.converter
new_converter = conversion.Converter('numpy conversion',
template=original_converter)
for k, v in py2rpy.registry.items():
if k is object:
continue
new_converter.py2rpy.register(k, v)
for k, v in rpy2py.registry.items():
if k is object:
continue
new_converter.rpy2py.register(k, v)
conversion.set_conversion(new_converter)
import warnings
from collections import OrderedDict
from rpy2.robjects.vectors import (DataFrame, Vector, FactorVector, ListVector,
StrVector, IntVector, POSIXct)
from rpy2.rinterface import (IntSexpVector, ListSexpVector)
original_converter = None
# pandas is requiring numpy. We add the numpy conversion will be
# activate in the function activate() below
import rpy2.robjects.numpy2ri as numpy2ri
ISOdatetime = rinterface.baseenv['ISOdatetime']
as_vector = rinterface.baseenv['as.vector']
converter = conversion.Converter('original pandas conversion')
py2ri = converter.py2ri
py2ro = converter.py2ro
ri2py = converter.ri2py
ri2ro = converter.ri2ro
# numpy types for Pandas columns that require (even more) special handling
dt_datetime64ns_type = numpy.dtype('datetime64[ns]')
dt_O_type = numpy.dtype('O')
@py2ri.register(PandasDataFrame)
def py2ri_pandasdataframe(obj):
od = OrderedDict()
for name, values in obj.iteritems():
try:
from rpy2.robjects import conversion, pandas2ri, default_converter
from rpy2.robjects.conversion import localconverter
from rpy2.robjects.vectors import ListVector
from rpy2.robjects.methods import RS4
from . import conv_name
from .conv import converter, mat_converter, full_converter
from .rpy2_ext import importr
class NotConvertedWarning(Warning):
pass
dict_converter = conversion.Converter("Converter handling dicts")
dict_converter.py2rpy.register(np.bool_, lambda x: conversion.py2rpy(bool(x)))
dict_converter.py2rpy.register(np.int_, lambda x: conversion.py2rpy(int(x)))
dict_converter.py2rpy.register(np.float_, lambda x: conversion.py2rpy(float(x)))
dict_converter.py2rpy.register(np.bytes_, lambda x: conversion.py2rpy(bytes(x)))
dict_converter.py2rpy.register(np.str_, lambda x: conversion.py2rpy(str(x)))
@dict_converter.py2rpy.register(Mapping)
def py2rpy_dict(obj: Mapping) -> ListVector:
"""Try converting everything. For nested dicts, this needs itself to be registered"""
converted = {}
for k, v in obj.items():
try:
converted[str(k)] = conversion.py2rpy(v)
except NotImplementedError as e:
# "O" -> special-cased below
'S': ro.vectors.ByteVector,
'U': ro.vectors.StrVector,
# "V" -> special-cased below
# TODO: datetime64 ?
# "datetime64":
}
_vectortypes = (RTYPES.LGLSXP,
RTYPES.INTSXP,
RTYPES.REALSXP,
RTYPES.CPLXSXP,
RTYPES.STRSXP)
converter = conversion.Converter('original numpy conversion')
py2rpy = converter.py2rpy
rpy2py = converter.rpy2py
def numpy_O_py2rpy(o):
if all(isinstance(x, str) for x in o):
res = StrSexpVector(o)
elif all(isinstance(x, bytes) for x in o):
res = ByteSexpVector(o)
else:
res = conversion.py2rpy(list(o))
return res
def _numpyarray_to_r(a, func):
def sim_movement(n_ids=1, n_states=2, step_distr="gamma", angle_distr="vm",
step_pars=None, angle_pars=None, beta=None,
covariates=None, n_covariates=None,
is_zero_inflated=False, n_per_id=None, model=None,
return_states=False):
"""Simulate movement as Hidden Markov Model
Parameters
----------
n_ids : int, optional
Number of individuals (IDs) to simulate.
n_states : int, optional
Number of states to simulate.
step_distr : str, optional
Name of the distribution for the step lengths. Supported
distributions are: "gamma", "weibull", "lnorm", and "exp".
angle_distr : str, optional
Name of the distribution for the turning angles. Supported
distributions are: "vm", "wrpcauchy", "lnorm", and "exp". Set to
None if the angle distribution should not be estimated.
step_pars : array_like, optional
Parameters for the step length distribution.
angle_pars : array_like, optional
Parameters for the turning angle distribution.
beta : array_like, optional
Matrix of regression parameters for the transition probabilities
covariates : DataFrame, optional
Covariate values to include in the model. Covariates can also be
simulated as a standard normal distribution, by setting
`covariates=None`, and `n_covariates > 0`.
n_covariates : int, optional
Number of covariates to simulate; does not need to be specified if
`covariates` is not None.
is_zero_inflated : bool, optional
Whether step length distribution is inflated at zero.
If `TRUE`, values for the zero-mass parameters should be
included in `stepPar`.
n_per_id : int or array_like, optional
Either the number of the number of observations per animal (integer
scalar), or the bounds of the number of observations per animal
(length 2 array or list). In the latter case, the numbers of
obervations generated for each animal are uniformly picked from
this interval.
model : moveHMM, optional
Simulation based on a fitted model. If this argument is specified,
most other arguments will be ignored, except for n_ids, n_per_id,
covariates (if covariates are different from those in the data), and
states.
return_states : bool, optional
Whether the simulated states should be returned.
Returns
-------
DataFrame
"""
none_converter = cv.Converter("None converter")
none_converter.py2rpy.register(type(None), _none2null)
with cv.localconverter(robjs.default_converter +
pandas2ri.converter +
none_converter):
sim_df = moveHMM.simData(nbAnimals=n_ids, nbStates=n_states,
stepDist=step_distr, angleDist=angle_distr,
stepPar=step_pars, anglePar=angle_pars,
beta=beta, covs=covariates,
nbCovs=n_covariates,
zeroInflation=is_zero_inflated,
obsPerAnimal=n_per_id, model=model,
states=return_states)
return sim_df
NULL = robjects.NULL
grid = importr('grid')
grid = WeakPackage(grid._env,
grid.__rname__,
translation=grid._translation,
exported_names=grid._exported_names,
on_conflict="warn",
version=grid.__version__,
symbol_r2python=grid._symbol_r2python,
symbol_resolve=grid._symbol_resolve)
original_converter = None
converter = conversion.Converter('original grid conversion')
py2rpy = converter.py2rpy
rpy2py = converter.rpy2py
grid_env = robjects.baseenv['as.environment']('package:grid')
layout = grid.grid_layout
newpage = grid.grid_newpage
grill = grid.grid_grill
edit = grid.grid_edit
get = grid.grid_get
remove = grid.grid_remove
add = grid.grid_add
xaxis = grid.grid_xaxis
yaxis = grid.grid_yaxis
"""This module handles the conversion of data structures.
In the future it fill ensure the conversion between R objects from the R
package Matrix and scipy sparse matrices."""
import rpy2.robjects.conversion as conversion
from rpy2.rinterface import SexpS4
try:
import scipy.sparse
has_scipy = True
except ImportError:
has_scipy = False
from . import Matrix
rs4_map = conversion.converter.rpy2py_nc_name[SexpS4]
rs4map_context = conversion.NameClassMapContext(rs4_map, Matrix._classmap)
cast = conversion.Converter('Cast R objects into scipy objects')
if has_scipy:
def py2rpy_csc_matrix(obj) -> Matrix.Matrix:
# TODO: implement how to populate an R compressed sparse column matrix
# from the scipy object.
# res = Matrix.sparseMatrix(giveCsparse=True)
raise NotImplementedError()
cast.py2rpy.register(scipy.sparse.csc_matrix, py2rpy_csc_matrix)
from rpy2.robjects import DataFrame
import rpy2.robjects.conversion as cv
from rpy2.rinterface import NULL
import app.utils.r_importer
from app.utils.singleton import Singleton
from app.schemas.fba_calc import FuelTypeEnum
logger = logging.getLogger(__name__)
def _none2null(_):
""" Turn None values into null """
return robjs.r("NULL")
none_converter = cv.Converter("None converter")
none_converter.py2rpy.register(type(None), _none2null)
@Singleton
class CFFDRS():
""" Singleton that loads CFFDRS R lib once in memory for reuse."""
def __init__(self):
# pylint: disable=too-many-function-args
self.cffdrs = app.utils.r_importer.import_cffsdrs()
class CFFDRSException(Exception):
""" CFFDRS contextual exception """
from typing import Optional
from rpy2.robjects import conversion, numpy2ri, pandas2ri
from rpy2.robjects.conversion import overlay_converter
from . import scipy2ri
original_converter: Optional[conversion.Converter] = None
converter = conversion.Converter("original anndata conversion")
mat_converter = numpy2ri.converter + scipy2ri.converter
def full_converter() -> conversion.Converter:
pandas2ri.activate()
new_converter = conversion.Converter("anndata conversion", template=conversion.converter)
pandas2ri.deactivate()
overlay_converter(scipy2ri.converter, new_converter)
# overwrite the scipy2ri Sexp4 converter and add our others
overlay_converter(converter, new_converter)
return new_converter
def activate():
r"""
Activate conversion for :class:`~anndata.AnnData` objects
as well as :ref:`numpy:arrays` and :class:`pandas.DataFrame`\ s
via ``rpy2.robjects.numpy2ri`` and ``rpy2.robjects.pandas2ri``.
from typing import Optional
from rpy2.robjects import conversion, numpy2ri
from rpy2.robjects.conversion import overlay_converter
original_converter: Optional[conversion.Converter] = None
converter = conversion.Converter("original scipy conversion")
def activate():
"""
Activate conversion between sparse matrices from Scipy and R’s Matrix package.
Does nothing if this is the active conversion.
"""
global original_converter
if original_converter is not None:
return
original_converter = conversion.converter
numpy2ri.activate()
new_converter = conversion.Converter("scipy conversion",
template=conversion.converter)
numpy2ri.deactivate()
overlay_converter(converter, new_converter)
conversion.set_conversion(new_converter)
