HomeArtificial IntelligenceConstructing a Good Python-to-R Code Converter with Gemini AI-Powered Validation and Suggestions

Constructing a Good Python-to-R Code Converter with Gemini AI-Powered Validation and Suggestions


class EnhancedPythonToRConverter:
    """
    Enhanced Python to R converter with Gemini AI validation
    """


    def __init__(self, gemini_api_key: str = None):
        self.validator = GeminiValidator(gemini_api_key)


        self.import_mappings = {
            'pandas': 'library(dplyr)nlibrary(tidyr)nlibrary(readr)',
            'numpy': 'library(base)',
            'matplotlib.pyplot': 'library(ggplot2)',
            'seaborn': 'library(ggplot2)nlibrary(RColorBrewer)',
            'scipy.stats': 'library(stats)',
            'sklearn': 'library(caret)nlibrary(randomForest)nlibrary(e1071)',
            'statsmodels': 'library(stats)nlibrary(lmtest)',
            'plotly': 'library(plotly)',
        }


        self.function_mappings = {
            'pd.DataFrame': 'knowledge.body',
            'pd.read_csv': 'learn.csv',
            'pd.read_excel': 'read_excel',
            'df.head': 'head',
            'df.tail': 'tail',
            'df.form': 'dim',
            'df.information': 'str',
            'df.describe': 'abstract',
            'df.imply': 'imply',
            'df.median': 'median',
            'df.std': 'sd',
            'df.var': 'var',
            'df.sum': 'sum',
            'df.depend': 'size',
            'df.groupby': 'group_by',
            'df.merge': 'merge',
            'df.drop': 'choose',
            'df.dropna': 'na.omit',
            'df.fillna': 'replace_na',
            'df.sort_values': 'prepare',
            'df.value_counts': 'desk',


            'np.array': 'c',
            'np.imply': 'imply',
            'np.median': 'median',
            'np.std': 'sd',
            'np.var': 'var',
            'np.sum': 'sum',
            'np.min': 'min',
            'np.max': 'max',
            'np.sqrt': 'sqrt',
            'np.log': 'log',
            'np.exp': 'exp',
            'np.random.regular': 'rnorm',
            'np.random.uniform': 'runif',
            'np.linspace': 'seq',
            'np.arange': 'seq',


            'plt.determine': 'ggplot',
            'plt.plot': 'geom_line',
            'plt.scatter': 'geom_point',
            'plt.hist': 'geom_histogram',
            'plt.bar': 'geom_bar',
            'plt.boxplot': 'geom_boxplot',
            'plt.present': 'print',
            'sns.scatterplot': 'geom_point',
            'sns.histplot': 'geom_histogram',
            'sns.boxplot': 'geom_boxplot',
            'sns.heatmap': 'geom_tile',


            'scipy.stats.ttest_ind': 't.take a look at',
            'scipy.stats.chi2_contingency': 'chisq.take a look at',
            'scipy.stats.pearsonr': 'cor.take a look at',
            'scipy.stats.spearmanr': 'cor.take a look at',
            'scipy.stats.normaltest': 'shapiro.take a look at',
            'stats.ttest_ind': 't.take a look at',


            'sklearn.linear_model.LinearRegression': 'lm',
            'sklearn.ensemble.RandomForestRegressor': 'randomForest',
            'sklearn.model_selection.train_test_split': 'pattern',
        }


        self.syntax_patterns = [
            (r'bTrueb', 'TRUE'),
            (r'bFalseb', 'FALSE'),
            (r'bNoneb', 'NULL'),
            (r'blen(', 'length('),
            (r'range((d+))', r'1:1'),
            (r'range((d+),s*(d+))', r'1:2'),
            (r'.split(', '.strsplit('),
            (r'.strip()', '.str_trim()'),
            (r'.lower()', '.str_to_lower()'),
            (r'.upper()', '.str_to_upper()'),
            (r'[0]', '[1]'),
            (r'f"([^"]*)"', r'paste0("1")'),
            (r"f'([^']*)'", r"paste0('1')"),
        ]


    def convert_imports(self, code: str) -> str:
        """Convert Python import statements to R library statements."""
        strains = code.cut up('n')
        converted_lines = []


        for line in strains:
            line = line.strip()
            if line.startswith('import ') or line.startswith('from '):
                if ' as ' in line:
                    if 'import' in line and 'as' in line:
                        components = line.cut up(' as ')
                        module = components[0].substitute('import ', '').strip()
                        if module in self.import_mappings:
                            converted_lines.append(f"# {line}")
                            converted_lines.append(self.import_mappings[module])
                        else:
                            converted_lines.append(f"# {line} # No direct R equal")
                    elif 'from' in line and 'import' in line and 'as' in line:
                        converted_lines.append(f"# {line} # Deal with particular imports manually")
                elif line.startswith('from '):
                    components = line.cut up(' import ')
                    module = components[0].substitute('from ', '').strip()
                    if module in self.import_mappings:
                        converted_lines.append(f"# {line}")
                        converted_lines.append(self.import_mappings[module])
                    else:
                        converted_lines.append(f"# {line} # No direct R equal")
                else:
                    module = line.substitute('import ', '').strip()
                    if module in self.import_mappings:
                        converted_lines.append(f"# {line}")
                        converted_lines.append(self.import_mappings[module])
                    else:
                        converted_lines.append(f"# {line} # No direct R equal")
            else:
                converted_lines.append(line)


        return 'n'.be part of(converted_lines)


    def convert_functions(self, code: str) -> str:
        """Convert Python operate calls to R equivalents."""
        for py_func, r_func in self.function_mappings.gadgets():
            code = code.substitute(py_func, r_func)
        return code


    def apply_syntax_patterns(self, code: str) -> str:
        """Apply regex patterns to transform Python syntax to R syntax."""
        for sample, substitute in self.syntax_patterns:
            code = re.sub(sample, substitute, code)
        return code


    def convert_pandas_operations(self, code: str) -> str:
        """Convert frequent pandas operations to dplyr/tidyr equivalents."""
        code = re.sub(r'df[['"](.*?)['"]]', r'df$1', code)
        code = re.sub(r'df.(w+)', r'df$1', code)


        code = re.sub(r'df[df[['"](.*?)['"]]s*([> str:
        """Convert matplotlib/seaborn plotting to ggplot2."""
        conversions = [
            (r'plt.figure(figsize=((d+),s*(d+)))', r'# Set figure size in ggplot theme'),
            (r'plt.title(['"](.*?)['"])', r'+ ggtitle("1")'),
            (r'plt.xlabel(['"](.*?)['"])', r'+ xlab("1")'),
            (r'plt.ylabel(['"](.*?)['"])', r'+ ylab("1")'),
            (r'plt.legend()', r'+ theme(legend.place="proper")'),
            (r'plt.grid(True)', r'+ theme(panel.grid.main = element_line())'),
        ]


        for sample, substitute in conversions:
            code = re.sub(sample, substitute, code)


        return code


    def add_r_context(self, code: str) -> str:
        """Add R-specific context and feedback."""
        r_header=""'# R Statistical Evaluation Code
# Transformed from Python utilizing Enhanced Converter with Gemini AI Validation
# Set up required packages: set up.packages(c("dplyr", "ggplot2", "tidyr", "readr"))


'''
        return r_header + code


    def convert_code(self, python_code: str) -> str:
        """Foremost conversion methodology that applies all transformations."""
        code = python_code.strip()


        code = self.convert_imports(code)
        code = self.convert_functions(code)
        code = self.convert_pandas_operations(code)
        code = self.convert_plotting(code)
        code = self.apply_syntax_patterns(code)
        code = self.add_r_context(code)


        return code


    def convert_and_validate(self, python_code: str, use_gemini: bool = True) -> Dict:
        """
        Convert Python code to R and validate with Gemini AI
        """
        r_code = self.convert_code(python_code)


        end result = {
            "original_python": python_code,
            "converted_r": r_code,
            "validation": None
        }


        if use_gemini and self.validator.api_key:
            print("🔍 Validating conversion with Gemini AI...")
            validation = self.validator.validate_conversion(python_code, r_code)
            end result["validation"] = validation


            if validation.get("improved_code") and validation.get("improved_code") != r_code:
                end result["final_r_code"] = validation["improved_code"]
            else:
                end result["final_r_code"] = r_code
        else:
            end result["final_r_code"] = r_code
            if not self.validator.api_key:
                end result["validation"] = {"observe": "Set GEMINI_API_KEY for AI validation"}


        return end result


    def print_results(self, outcomes: Dict):
        """Fairly print the conversion outcomes"""
        print("=" * 80)
        print("🐍 ORIGINAL PYTHON CODE")
        print("=" * 80)
        print(outcomes["original_python"])


        print("n" + "=" * 80)
        print("📊 CONVERTED R CODE")
        print("=" * 80)
        print(outcomes["final_r_code"])


        if outcomes.get("validation"):
            validation = outcomes["validation"]
            print("n" + "=" * 80)
            print("🤖 GEMINI AI VALIDATION")
            print("=" * 80)


            if validation.get("validation_score"):
                print(f"📈 Rating: {validation['validation_score']}/100")


            if validation.get("abstract"):
                print(f"📝 Abstract: {validation['summary']}")


            if validation.get("issues_found"):
                print("n⚠️  Points Discovered:")
                for difficulty in validation["issues_found"]:
                    print(f"   • {difficulty}")


            if validation.get("strategies"):
                print("n💡 Ideas:")
                for suggestion in validation["suggestions"]:
                    print(f"   • {suggestion}")

RELATED ARTICLES

LEAVE A REPLY

Please enter your comment!
Please enter your name here

- Advertisment -
Google search engine

Most Popular

Recent Comments