datascrub 1.0.0__tar.gz

datascrub-1.0.0/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Samuel Shine
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

datascrub-1.0.0/PKG-INFO

@@ -0,0 +1,122 @@
+Metadata-Version: 2.1
+Name: datascrub
+Version: 1.0.0
+Summary: A Python package for cleaning and preprocessing data in pandas DataFrames
+Home-page: https://github.com/samuelshine/cleanmydata
+Author: ['Samuel Shine', 'Alex Benjamin']
+Author-email: samuelshine112003@gmail.com
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+
+## DataScrub
+
+The `DataClean` class provides a set of methods to clean and process data in a pandas DataFrame. It includes functions for cleaning text data, handling missing values, performing scaling normalization, exploding data, parsing date columns, and translating text columns.
+
+### Class Initialization
+
+To create an instance of the `DataClean` class, you need to provide the filepath of the data file (CSV or Excel) as an argument to the constructor. The class will automatically read the data into a pandas DataFrame based on the file extension.
+
+Example:
+```python
+cleaner = DataClean('data.csv')
+```
+
+### Method: clean_data
+
+The `clean_data` method cleans text data in the DataFrame. It takes a parameter `columns` that specifies which columns to clean. You can either pass `'all'` to clean all columns or provide a list of specific column names to clean.
+
+Example:
+```python
+cleaned_data = cleaner.clean_data(['text_column1', 'text_column2'])
+```
+
+### Method: handle_missing_values
+
+The `handle_missing_values` method handles missing values in the DataFrame. It takes a parameter `missing_values`, which is a dictionary specifying the actions to be taken for each column with missing values. The keys of the dictionary are the column names, and the values are the operations to be performed.
+
+Example:
+```python
+missing_values = {'column1': 'replace missing value with 0', 'column2': 'drop'}
+processed_data = cleaner.handle_missing_values(missing_values)
+```
+
+### Method: perform_scaling_normalization
+
+The `perform_scaling_normalization` method performs scaling normalization on numerical columns in the DataFrame using the Box-Cox transformation. Currently, this method is marked as 'NOT COMPLETE' in the code and does not contain the complete implementation.
+
+### Method: explode_data
+
+The `explode_data` method splits and expands data in specified columns of the DataFrame. It takes a dictionary `explode` where the keys are column names, and the values are the separators for splitting.
+
+Example:
+```python
+explode_columns = {'column1': ',', 'column2': ';'}
+exploded_data = cleaner.explode_data(explode_columns)
+```
+
+### Method: dupli
+
+The `dupli` method removes duplicate rows from the DataFrame.
+
+Example:
+```python
+unique_data = cleaner.dupli()
+```
+
+### Method: parse_date_column
+
+The `parse_date_column` method converts specified columns in the DataFrame to datetime format and formats them as 'YYYY-MM-DD'. It takes a list `date_columns` containing the names of the columns to be converted.
+
+Example:
+```python
+date_columns = ['date_column1', 'date_column2']
+parsed_data = cleaner.parse_date_column(date_columns)
+```
+
+### Method: translate_columns
+
+The `translate_columns` method translates text in specified columns of the DataFrame to English using Google Translate. It takes a dictionary `translations` where the keys are column names, and the values are overwrite boolean values. If the overwrite value is True, the original column will be overwritten; otherwise, a new column with the translated text will be added.
+
+Example:
+```python
+column_translations = {'text_column1': True, 'text_column2': False}
+translated_data = cleaner.translate_columns(column_translations)
+```
+
+### Method: prep
+
+The `prep` method is the main function to prepare and clean the DataFrame. It provides a convenient way to perform multiple cleaning and processing operations in a specific order. You can specify the operations using the following parameters:
+
+- `clean`: Columns to clean. Pass `'all'` to clean all columns or provide a list of specific column names.
+- `missing_values`: Actions
+
+ to be taken on missing values. Pass a dictionary with column names as keys and operations as values.
+- `perform_scaling_normalization_bool`: Boolean value indicating whether to perform scaling normalization on numerical columns.
+- `explode`: Columns to be exploded. Pass a dictionary with column names as keys and separators for splitting as values.
+- `parse_date`: List of column names to be converted to datetime format.
+- `translate_column_names`: Dictionary mapping column names to overwrite boolean values for translation.
+
+Example:
+```python
+cleaned_data = cleaner.prep(clean='all', missing_values={'column1': 'drop'}, perform_scaling_normalization_bool=True, explode={'column2': ','}, parse_date=['date_column1'], translate_column_names={'text_column1': True})
+```
+
+### Getting the Cleaned DataFrame
+
+To obtain the cleaned and processed DataFrame, you can call the `prep` method and assign the returned DataFrame to a variable.
+
+Example:
+```python
+cleaned_data = cleaner.prep(clean='all', missing_values={'column1': 'drop'})
+```
+
+The variable `cleaned_data` will contain the final cleaned and processed DataFrame.
+
+Please note that some methods in the code are marked as 'NOT COMPLETE' and require further implementation to work properly. You can modify and complete those methods as per your requirements.

datascrub-1.0.0/README.md

@@ -0,0 +1,105 @@
+## DataScrub
+
+The `DataClean` class provides a set of methods to clean and process data in a pandas DataFrame. It includes functions for cleaning text data, handling missing values, performing scaling normalization, exploding data, parsing date columns, and translating text columns.
+
+### Class Initialization
+
+To create an instance of the `DataClean` class, you need to provide the filepath of the data file (CSV or Excel) as an argument to the constructor. The class will automatically read the data into a pandas DataFrame based on the file extension.
+
+Example:
+```python
+cleaner = DataClean('data.csv')
+```
+
+### Method: clean_data
+
+The `clean_data` method cleans text data in the DataFrame. It takes a parameter `columns` that specifies which columns to clean. You can either pass `'all'` to clean all columns or provide a list of specific column names to clean.
+
+Example:
+```python
+cleaned_data = cleaner.clean_data(['text_column1', 'text_column2'])
+```
+
+### Method: handle_missing_values
+
+The `handle_missing_values` method handles missing values in the DataFrame. It takes a parameter `missing_values`, which is a dictionary specifying the actions to be taken for each column with missing values. The keys of the dictionary are the column names, and the values are the operations to be performed.
+
+Example:
+```python
+missing_values = {'column1': 'replace missing value with 0', 'column2': 'drop'}
+processed_data = cleaner.handle_missing_values(missing_values)
+```
+
+### Method: perform_scaling_normalization
+
+The `perform_scaling_normalization` method performs scaling normalization on numerical columns in the DataFrame using the Box-Cox transformation. Currently, this method is marked as 'NOT COMPLETE' in the code and does not contain the complete implementation.
+
+### Method: explode_data
+
+The `explode_data` method splits and expands data in specified columns of the DataFrame. It takes a dictionary `explode` where the keys are column names, and the values are the separators for splitting.
+
+Example:
+```python
+explode_columns = {'column1': ',', 'column2': ';'}
+exploded_data = cleaner.explode_data(explode_columns)
+```
+
+### Method: dupli
+
+The `dupli` method removes duplicate rows from the DataFrame.
+
+Example:
+```python
+unique_data = cleaner.dupli()
+```
+
+### Method: parse_date_column
+
+The `parse_date_column` method converts specified columns in the DataFrame to datetime format and formats them as 'YYYY-MM-DD'. It takes a list `date_columns` containing the names of the columns to be converted.
+
+Example:
+```python
+date_columns = ['date_column1', 'date_column2']
+parsed_data = cleaner.parse_date_column(date_columns)
+```
+
+### Method: translate_columns
+
+The `translate_columns` method translates text in specified columns of the DataFrame to English using Google Translate. It takes a dictionary `translations` where the keys are column names, and the values are overwrite boolean values. If the overwrite value is True, the original column will be overwritten; otherwise, a new column with the translated text will be added.
+
+Example:
+```python
+column_translations = {'text_column1': True, 'text_column2': False}
+translated_data = cleaner.translate_columns(column_translations)
+```
+
+### Method: prep
+
+The `prep` method is the main function to prepare and clean the DataFrame. It provides a convenient way to perform multiple cleaning and processing operations in a specific order. You can specify the operations using the following parameters:
+
+- `clean`: Columns to clean. Pass `'all'` to clean all columns or provide a list of specific column names.
+- `missing_values`: Actions
+
+ to be taken on missing values. Pass a dictionary with column names as keys and operations as values.
+- `perform_scaling_normalization_bool`: Boolean value indicating whether to perform scaling normalization on numerical columns.
+- `explode`: Columns to be exploded. Pass a dictionary with column names as keys and separators for splitting as values.
+- `parse_date`: List of column names to be converted to datetime format.
+- `translate_column_names`: Dictionary mapping column names to overwrite boolean values for translation.
+
+Example:
+```python
+cleaned_data = cleaner.prep(clean='all', missing_values={'column1': 'drop'}, perform_scaling_normalization_bool=True, explode={'column2': ','}, parse_date=['date_column1'], translate_column_names={'text_column1': True})
+```
+
+### Getting the Cleaned DataFrame
+
+To obtain the cleaned and processed DataFrame, you can call the `prep` method and assign the returned DataFrame to a variable.
+
+Example:
+```python
+cleaned_data = cleaner.prep(clean='all', missing_values={'column1': 'drop'})
+```
+
+The variable `cleaned_data` will contain the final cleaned and processed DataFrame.
+
+Please note that some methods in the code are marked as 'NOT COMPLETE' and require further implementation to work properly. You can modify and complete those methods as per your requirements.

datascrub-1.0.0/datascrub/__init__.py

@@ -0,0 +1,3 @@
+# CleanMyData/__init__.py
+
+from datascrub import DataClean

datascrub-1.0.0/datascrub/datascrub.py

@@ -0,0 +1,208 @@
+import pandas as pd
+import numpy as np
+import datetime
+import charset_normalizer
+import fuzzywuzzy
+from fuzzywuzzy import process
+import re
+from scipy import stats
+from pandas.api.types import is_numeric_dtype
+import emoji
+import string
+from googletrans import Translator
+
+class DataClean:
+    def __init__(self, filepath):
+        if filepath.endswith('.csv'):
+            self.raw_data = pd.read_csv(filepath)
+        elif filepath.endswith('.xlsx'):
+            self.raw_data = pd.read_excel(filepath)
+
+    def clean_data(self, columns):
+        """
+        Cleans text data in a pandas DataFrame.
+
+        Parameters:
+        columns (str, list): Either 'all' to clean all columns or a list of column names to clean.
+
+        Returns:
+        pd.DataFrame: DataFrame with cleaned text data.
+        """
+        updated_data = self.raw_data.copy()
+
+        if columns == 'all':
+            text_columns = updated_data.select_dtypes(include='object').columns
+            print(text_columns)
+        elif isinstance(columns, list):
+            text_columns = [col for col in columns if col in updated_data.columns]
+        else:
+            raise ValueError("Invalid value for 'clean' parameter. It should be 'all' or a list of column names.")
+
+        # Clean text columns
+        for column in text_columns:
+            updated_data[column] = updated_data[column].str.strip()
+            updated_data[column] = updated_data[column].str.lower()
+            updated_data[column] = updated_data[column].apply(lambda x: emoji.demojize(str(x)))
+
+        return updated_data
+
+    def handle_missing_values(self, missing_values):
+        """
+        Handles missing values in a pandas DataFrame. Actions depend on the `missing_values` dictionary provided.
+
+        Parameters:
+        missing_values (dict): Dictionary with actions to be taken on missing values.
+                               Keys: Column names.
+                               Values: Operations to be performed on corresponding column.
+                                       "replace missing value with <value>" to replace missing values with <value>.
+                                       "drop" to drop rows with missing values.
+                                       "fill with backward fill along rows" to fill missing values using backward fill along rows.
+                                       "fill with backward fill along columns" to fill missing values using backward fill along columns.
+
+        Returns:
+        pd.DataFrame: DataFrame with handled missing values.
+        """
+        for column, operation in missing_values.items():
+            if operation.startswith("replace missing value with "):
+                value = operation.split("replace missing value with ")[1]
+                try:
+                    value = float(value)
+                except ValueError:
+                    value = str(value)
+                self.raw_data[column] = self.raw_data[column].fillna(value)
+            elif operation == "drop":
+                self.raw_data.dropna(subset=[column], inplace=True)
+            elif operation == "fill with backward fill along rows":
+                self.raw_data[column] = self.raw_data[column].fillna(method='bfill', axis='rows').fillna(0)
+            elif operation == "fill with backward fill along columns":
+                self.raw_data[column] = self.raw_data[column].fillna(method='bfill', axis='columns').fillna(0)
+            else:
+                raise ValueError(f"Invalid operation '{operation}' in 'missing_values' parameter.")
+        return self.raw_data
+
+    def perform_scaling_normalization(self):
+        """
+        NOT COMPLETE!!!
+
+        Performs scaling normalization on numerical columns in a pandas DataFrame using Box-Cox transformation.
+
+        Returns:
+        pd.DataFrame: DataFrame with scaled and normalized numerical data.
+        """
+        updated_data = self.raw_data.copy()
+        for column in updated_data.columns:
+            if is_numeric_dtype(updated_data[column]):
+                updated_data[column] = updated_data[column].apply(lambda x: abs(x) if x != 0 else 1)
+                updated_data[column] = stats.boxcox(updated_data[column])
+        return updated_data
+
+    def explode_data(self, explode):
+        """
+        Splits and expands data in specified columns of a pandas DataFrame.
+
+        Parameters:
+        explode (dict): Dictionary with column names as keys and separator as values for splitting.
+
+        Returns:
+        pd.DataFrame: DataFrame with exploded data.
+        """
+        updated_data = self.raw_data.copy()
+        for column, separator in explode.items():
+            updated_data[column] = updated_data[column].str.split(separator)
+            updated_data = updated_data.explode(column)
+        return updated_data
+
+    def dupli(self):
+        """
+        Removes duplicate rows from a pandas DataFrame.
+
+        Returns:
+        pd.DataFrame: DataFrame without duplicate rows.
+        """
+        return self.raw_data.drop_duplicates()
+
+    def parse_date_column(self, date_columns):
+        """
+        Converts specified columns in a pandas DataFrame to datetime format and formats them as 'YYYY-MM-DD'.
+
+        Parameters:
+        date_columns (dict): List of column names to be converted to datetime format.
+
+        Returns:
+        pd.DataFrame: DataFrame with parsed date columns.
+        """
+        updated_data = self.raw_data.copy()
+
+        for column in date_columns:
+            if column not in updated_data.columns:
+                raise ValueError(f"Column '{column}' not found in the DataFrame.")
+
+            if updated_data[column].dtype != 'datetime64[ns]':
+                updated_data[column] = updated_data[column].astype(str)
+                updated_data[column] = pd.to_datetime(updated_data[column], errors='coerce').dt.strftime('%Y-%m-%d')
+                # updated_data[column] = pd.to_datetime(updated_data[column], format=date_format)
+
+        return updated_data
+
+    def translate_columns(self, translations):
+        """
+        Translates text in specified columns of a DataFrame to English using Google Translate.
+
+        Parameters:
+        translations (dict): Dictionary mapping column names to overwrite boolean values.
+                             The key is the column name, and the value is the overwrite boolean value.
+
+        Returns:
+        pd.DataFrame: DataFrame with translated columns.
+        """
+        translator = Translator()
+        updated_data = self.raw_data.copy()
+
+        for column, overwrite_value in translations.items():
+            if column not in updated_data.columns:
+                raise ValueError(f"Column '{column}' not found in the DataFrame.")
+
+            translated_texts = []
+
+            for text in updated_data[column]:
+                translation = translator.translate(text)
+                translated_texts.append(translation.text)
+
+            if overwrite_value:
+                updated_data[column] = translated_texts
+            else:
+                new_column_name = column + '_translated'
+                updated_data[new_column_name] = translated_texts
+
+        return updated_data
+
+    def prep(self, clean='all', missing_values={}, perform_scaling_normalization_bool=False, explode={}, parse_date=[], translate_column_names={}):
+        """
+        Main function to prepare and clean a pandas DataFrame. Can perform cleaning, handle missing values, fix inconsistencies,
+        perform scaling normalization, explode data, and parse date columns based on parameters passed.
+
+        Parameters:
+        clean (str, list): Columns to clean. Either 'all' for all columns or a list of specific column names.
+        missing_values (dict): Actions to be taken on missing values. Refer `handle_missing_values` for more details.
+        perform_scaling_normalization (bool): If True, will perform scaling normalization on numerical columns.
+        explode (dict): Columns to be exploded. Keys are column names and values are separators for splitting.
+        parse_date (list): List of column names to be converted to datetime format.
+        translate_column_names (dict): Dictionary mapping column names to overwrite boolean values for translation.
+
+        Returns:
+        pd.DataFrame: Updated DataFrame with cleaned, transformed, and translated columns.
+        """
+        updated_data = self.clean_data(clean)
+        updated_data = self.handle_missing_values(missing_values)
+
+        if perform_scaling_normalization_bool:
+            updated_data = self.perform_scaling_normalization()
+
+        updated_data = self.explode_data(explode)
+
+        if parse_date:
+            updated_data = self.parse_date_column(parse_date)
+
+        updated_data = self.translate_columns(translate_column_names)
+
+        return updated_data

datascrub-1.0.0/datascrub.egg-info/PKG-INFO

@@ -0,0 +1,122 @@
+Metadata-Version: 2.1
+Name: datascrub
+Version: 1.0.0
+Summary: A Python package for cleaning and preprocessing data in pandas DataFrames
+Home-page: https://github.com/samuelshine/cleanmydata
+Author: ['Samuel Shine', 'Alex Benjamin']
+Author-email: samuelshine112003@gmail.com
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+
+## DataScrub
+
+The `DataClean` class provides a set of methods to clean and process data in a pandas DataFrame. It includes functions for cleaning text data, handling missing values, performing scaling normalization, exploding data, parsing date columns, and translating text columns.
+
+### Class Initialization
+
+To create an instance of the `DataClean` class, you need to provide the filepath of the data file (CSV or Excel) as an argument to the constructor. The class will automatically read the data into a pandas DataFrame based on the file extension.
+
+Example:
+```python
+cleaner = DataClean('data.csv')
+```
+
+### Method: clean_data
+
+The `clean_data` method cleans text data in the DataFrame. It takes a parameter `columns` that specifies which columns to clean. You can either pass `'all'` to clean all columns or provide a list of specific column names to clean.
+
+Example:
+```python
+cleaned_data = cleaner.clean_data(['text_column1', 'text_column2'])
+```
+
+### Method: handle_missing_values
+
+The `handle_missing_values` method handles missing values in the DataFrame. It takes a parameter `missing_values`, which is a dictionary specifying the actions to be taken for each column with missing values. The keys of the dictionary are the column names, and the values are the operations to be performed.
+
+Example:
+```python
+missing_values = {'column1': 'replace missing value with 0', 'column2': 'drop'}
+processed_data = cleaner.handle_missing_values(missing_values)
+```
+
+### Method: perform_scaling_normalization
+
+The `perform_scaling_normalization` method performs scaling normalization on numerical columns in the DataFrame using the Box-Cox transformation. Currently, this method is marked as 'NOT COMPLETE' in the code and does not contain the complete implementation.
+
+### Method: explode_data
+
+The `explode_data` method splits and expands data in specified columns of the DataFrame. It takes a dictionary `explode` where the keys are column names, and the values are the separators for splitting.
+
+Example:
+```python
+explode_columns = {'column1': ',', 'column2': ';'}
+exploded_data = cleaner.explode_data(explode_columns)
+```
+
+### Method: dupli
+
+The `dupli` method removes duplicate rows from the DataFrame.
+
+Example:
+```python
+unique_data = cleaner.dupli()
+```
+
+### Method: parse_date_column
+
+The `parse_date_column` method converts specified columns in the DataFrame to datetime format and formats them as 'YYYY-MM-DD'. It takes a list `date_columns` containing the names of the columns to be converted.
+
+Example:
+```python
+date_columns = ['date_column1', 'date_column2']
+parsed_data = cleaner.parse_date_column(date_columns)
+```
+
+### Method: translate_columns
+
+The `translate_columns` method translates text in specified columns of the DataFrame to English using Google Translate. It takes a dictionary `translations` where the keys are column names, and the values are overwrite boolean values. If the overwrite value is True, the original column will be overwritten; otherwise, a new column with the translated text will be added.
+
+Example:
+```python
+column_translations = {'text_column1': True, 'text_column2': False}
+translated_data = cleaner.translate_columns(column_translations)
+```
+
+### Method: prep
+
+The `prep` method is the main function to prepare and clean the DataFrame. It provides a convenient way to perform multiple cleaning and processing operations in a specific order. You can specify the operations using the following parameters:
+
+- `clean`: Columns to clean. Pass `'all'` to clean all columns or provide a list of specific column names.
+- `missing_values`: Actions
+
+ to be taken on missing values. Pass a dictionary with column names as keys and operations as values.
+- `perform_scaling_normalization_bool`: Boolean value indicating whether to perform scaling normalization on numerical columns.
+- `explode`: Columns to be exploded. Pass a dictionary with column names as keys and separators for splitting as values.
+- `parse_date`: List of column names to be converted to datetime format.
+- `translate_column_names`: Dictionary mapping column names to overwrite boolean values for translation.
+
+Example:
+```python
+cleaned_data = cleaner.prep(clean='all', missing_values={'column1': 'drop'}, perform_scaling_normalization_bool=True, explode={'column2': ','}, parse_date=['date_column1'], translate_column_names={'text_column1': True})
+```
+
+### Getting the Cleaned DataFrame
+
+To obtain the cleaned and processed DataFrame, you can call the `prep` method and assign the returned DataFrame to a variable.
+
+Example:
+```python
+cleaned_data = cleaner.prep(clean='all', missing_values={'column1': 'drop'})
+```
+
+The variable `cleaned_data` will contain the final cleaned and processed DataFrame.
+
+Please note that some methods in the code are marked as 'NOT COMPLETE' and require further implementation to work properly. You can modify and complete those methods as per your requirements.

datascrub-1.0.0/datascrub.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+LICENSE.txt
+README.md
+setup.py
+datascrub/__init__.py
+datascrub/datascrub.py
+datascrub.egg-info/PKG-INFO
+datascrub.egg-info/SOURCES.txt
+datascrub.egg-info/dependency_links.txt
+datascrub.egg-info/requires.txt
+datascrub.egg-info/top_level.txt

datascrub-1.0.0/datascrub.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

datascrub-1.0.0/datascrub.egg-info/requires.txt

@@ -0,0 +1,8 @@
+pandas
+numpy
+charset_normalizer
+fuzzywuzzy
+scipy
+dateutil
+emoji
+googletrans

datascrub-1.0.0/datascrub.egg-info/top_level.txt

@@ -0,0 +1 @@
+datascrub

datascrub-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

datascrub-1.0.0/setup.py

@@ -0,0 +1,32 @@
+from setuptools import setup, find_packages
+
+setup(
+    name='datascrub',
+    version='1.0.0',
+    author=['Samuel Shine', 'Alex Benjamin'],
+    author_email='samuelshine112003@gmail.com',
+    description='A Python package for cleaning and preprocessing data in pandas DataFrames',
+    long_description=open('README.md').read(),
+    long_description_content_type='text/markdown',
+    url='https://github.com/samuelshine/cleanmydata',
+    packages=find_packages(),
+    classifiers=[
+        'Development Status :: 5 - Production/Stable',
+        'License :: OSI Approved :: MIT License',
+        'Programming Language :: Python :: 3',
+        'Programming Language :: Python :: 3.6',
+        'Programming Language :: Python :: 3.7',
+        'Programming Language :: Python :: 3.8',
+        'Programming Language :: Python :: 3.9',
+    ],
+    install_requires=[
+        'pandas',
+        'numpy',
+        'charset_normalizer',
+        'fuzzywuzzy',
+        'scipy',
+        'dateutil',
+        'emoji',
+        'googletrans',
+    ],
+)