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)