JacobTools 0.0.1__tar.gz

jacobtools-0.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 Abisheak Jacob J
+
+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.

jacobtools-0.0.1/MANIFEST.in

@@ -0,0 +1,2 @@
+graft src
+recursive-exclude __pycache__*.py[cod]

jacobtools-0.0.1/PKG-INFO

@@ -0,0 +1,17 @@
+Metadata-Version: 2.4
+Name: JacobTools
+Version: 0.0.1
+Summary: This package contains functions that help me tackle my day to day data andalytics requirements
+Home-page: https://github.com/AbisheakJacob/JacobTools
+Author: Abisheak Jacob J
+Author-email: "abisheakjacob0032@gmail.com"
+License: MIT
+Classifier: License :: OSI Approved :: MIT License
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=2.1.0
+Requires-Dist: termcolor>=1.1.0
+Dynamic: license-file
+
+README.md

jacobtools-0.0.1/README.md

@@ -0,0 +1,68 @@
+# JacobTools
+
+**JacobTools** is a my personal python library that contains code to automate day to day activities.
+
+## Installation and updating
+
+Installing the package from the github repository
+
+```bash
+pip install git+https://github.com/AbisheakJacob/JacobTools
+```
+
+Installing the local repository so that it updates automatically when a change is made.
+
+```bash
+pip install .
+```
+
+### Creating C extension
+
+```python
+from setuptools import setup 
+from Cython.Build import cythonize
+
+setup(
+        ext_modules=cythonize("src/jacobtools/harmonic_mean.pyx")
+        )
+```
+
+## Structure
+
+### gbq_queries
+
+This module contains codes to connect and work with data in Google BigQuery.
+
+| Function Name     | Description                                        |
+| ----------------- | -------------------------------------------------- |
+| query_gbq         | Read a table from GBQ as a DataFrame               |
+| fillrate_analysis | Perfrom Fill Rate Analysis on GBQ dataset or table |
+
+### preprocessing
+
+This module contains preprocessing steps to be performed on the data before actual analysis.
+
+| Function Name          | Description                                                                 |
+| ---------------------- | --------------------------------------------------------------------------- |
+| drop_columns_by_schema | Drop the columns that are markded in the Schema Document                    |
+| enforce_schema         | Apply the datatypes provided in schema document to the Columns in the Table |
+
+### sql_generation
+
+This module automatically generate SQL codes from DataFrame for ease of use.
+
+#### postgres
+
+| Function Name             | Description                                                        |
+| ------------------------- | ------------------------------------------------------------------ |
+| generate_create_table_sql | Generates SQL code to create the schema to upload data to postgres |
+
+## Next Steps
+
+1. Custom function to perform basic eda on a given dataframe (info, null values, shape, size)
+2. Function to perform match% analysis and perfrom a venn diagram for easier visualization
+
+## License
+
+**_The Reference to this library can be found here:_**
+The base construct of this library is referenced from [this article](https://mikehuls.medium.com/create-your-custom-python-package-that-you-can-pip-install-from-your-git-repository-f90465867893)

jacobtools-0.0.1/pyproject.toml

@@ -0,0 +1,7 @@
+[build-system]
+requires = ["setuptools", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[tool.black]
+line-length = 100
+target-version = ["py313"]

jacobtools-0.0.1/setup.cfg

@@ -0,0 +1,123 @@
+[metadata]
+name = JacobTools
+version = 0.0.1
+url = https://github.com/AbisheakJacob/JacobTools
+author = Abisheak Jacob J
+author_email = "abisheakjacob0032@gmail.com"
+description = This package contains functions that help me tackle my day to day data andalytics requirements
+long_description = README.md
+long_description_content_type = text/markdown
+license = MIT
+license_file = LICENSE
+classifiers = 
+	License :: OSI Approved :: MIT License
+
+[options]
+package_dir = 
+	=src
+packages = find:
+include_package_data = True
+python_requires = >=3.9
+install_requires = 
+	numpy>=2.1.0
+	termcolor>=1.1.0
+
+[options.packages.find]
+where = src
+exclude = 
+	test*
+
+[options.entry_points]
+console_scripts = 
+	harmony = jacobtools_test.harmony:main
+
+[flake8]
+max-line-length = 100
+
+[tool:pytest]
+testpaths = 
+	test
+addopts = 
+	--cov
+	--strict-markers
+	--disable-warnings
+xfail_strict = True
+
+[coverage:run]
+branch = True
+source = jacobtools_test
+
+[coverage:report]
+show_missing = True
+skip_covered = True
+
+[coverage:paths]
+source = 
+	src/jacobtools_test/
+	*/site-packages/jacobtools_test/
+
+[tox:tox]
+isolated_build = True
+envlist = py312
+
+[testimports]
+deps = 
+	pytest
+	requests
+
+[testenv]
+deps = 
+	{[testimports]deps}
+	pytest-cov
+commands = 
+	pytest {posargs}
+
+[testenv:get_my_ip]
+skip_install = True
+deps = 
+	requests
+commands = 
+	python -c "import requests; print(requests.get('https://canhazip.com').text)"
+
+[testenv:check-imports]
+deps = 
+	{[testimports]deps}
+	shipyard
+commands = 
+	python -m shipyard verify
+
+[testenv:typecheck]
+deps = 
+	mypy
+	pytest
+	types-termcolor
+commands = 
+	mypy --ignore-missing-imports {posargs:src test}
+
+[mypy]
+python_version = 3.13
+warn_unused_configs = True
+show_error_context = True
+pretty = True
+namespace_packages = True
+check_untyped_defs = True
+
+[testenv:format]
+skip_install = True
+deps = 
+	black
+commands = 
+	black {posargs:--check --diff src/jacobtools_test test}
+
+[testenv:lint]
+skip_install = True
+deps = 
+	flake8
+	flake8-bugbear
+commands = 
+	flake8 {posargs:src/jacobtools_test test}
+
+[egg_info]
+tag_build = 
+tag_date = 0
+

jacobtools-0.0.1/src/JacobTools.egg-info/PKG-INFO

@@ -0,0 +1,17 @@
+Metadata-Version: 2.4
+Name: JacobTools
+Version: 0.0.1
+Summary: This package contains functions that help me tackle my day to day data andalytics requirements
+Home-page: https://github.com/AbisheakJacob/JacobTools
+Author: Abisheak Jacob J
+Author-email: "abisheakjacob0032@gmail.com"
+License: MIT
+Classifier: License :: OSI Approved :: MIT License
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=2.1.0
+Requires-Dist: termcolor>=1.1.0
+Dynamic: license-file
+
+README.md

jacobtools-0.0.1/src/JacobTools.egg-info/SOURCES.txt

@@ -0,0 +1,47 @@
+LICENSE
+MANIFEST.in
+README.md
+pyproject.toml
+setup.cfg
+src/JacobTools.egg-info/PKG-INFO
+src/JacobTools.egg-info/SOURCES.txt
+src/JacobTools.egg-info/dependency_links.txt
+src/JacobTools.egg-info/entry_points.txt
+src/JacobTools.egg-info/requires.txt
+src/JacobTools.egg-info/top_level.txt
+src/jacobtools/__init__.py
+src/jacobtools/config.py
+src/jacobtools/__pycache__/__init__.cpython-312.pyc
+src/jacobtools/__pycache__/config.cpython-312.pyc
+src/jacobtools/gbq_queries/__init__.py
+src/jacobtools/gbq_queries/fillrate_analysis.py
+src/jacobtools/gbq_queries/query_gbq.py
+src/jacobtools/gbq_queries/__pycache__/__init__.cpython-312.pyc
+src/jacobtools/gbq_queries/__pycache__/fillrate_analysis.cpython-312.pyc
+src/jacobtools/gbq_queries/__pycache__/query_gbq.cpython-312.pyc
+src/jacobtools/preprocessing/__init__.py
+src/jacobtools/preprocessing/drop_columns_by_schema.py
+src/jacobtools/preprocessing/enforce_schema.py
+src/jacobtools/preprocessing/__pycache__/__init__.cpython-312.pyc
+src/jacobtools/preprocessing/__pycache__/drop_columns_by_schema.cpython-312.pyc
+src/jacobtools/sql_generation/__init__.py
+src/jacobtools/sql_generation/__pycache__/__init__.cpython-312.pyc
+src/jacobtools/sql_generation/postgres/__init__.py
+src/jacobtools/sql_generation/postgres/generate_create_table_sql.py
+src/jacobtools/sql_generation/postgres/__pycache__/__init__.cpython-312.pyc
+src/jacobtools/sql_generation/postgres/__pycache__/generate_create_table_sql.cpython-312.pyc
+src/jacobtools/temp/chart.py
+src/jacobtools/temp/database.py
+src/jacobtools/temp/decorators.py
+src/jacobtools/temp/it.py
+src/jacobtools/temp/pa.py
+src/jacobtools/temp/reason_for_absence.csv
+src/jacobtools_test/__init__.py
+src/jacobtools_test/harmonic_mean.py
+src/jacobtools_test/harmony.py
+src/jacobtools_test.egg-info/PKG-INFO
+src/jacobtools_test.egg-info/SOURCES.txt
+src/jacobtools_test.egg-info/dependency_links.txt
+src/jacobtools_test.egg-info/entry_points.txt
+src/jacobtools_test.egg-info/requires.txt
+src/jacobtools_test.egg-info/top_level.txt

jacobtools-0.0.1/src/JacobTools.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

jacobtools-0.0.1/src/JacobTools.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+harmony = jacobtools_test.harmony:main

jacobtools-0.0.1/src/JacobTools.egg-info/requires.txt

@@ -0,0 +1,2 @@
+numpy>=2.1.0
+termcolor>=1.1.0

jacobtools-0.0.1/src/JacobTools.egg-info/top_level.txt

@@ -0,0 +1,2 @@
+jacobtools
+jacobtools_test

jacobtools-0.0.1/src/jacobtools/__init__.py

@@ -0,0 +1,14 @@
+# Expose submodules at top level
+
+from .import config
+from .preprocessing import drop_columns_by_schema
+from .sql_generation import generate_create_table_sql
+from .gbq_queries import fillrate_analysis
+from .gbq_queries import query_gbq
+
+__all__ =[
+    drop_columns_by_schema,
+    generate_create_table_sql,
+    fillrate_analysis,
+    query_gbq
+]

jacobtools-0.0.1/src/jacobtools/config.py

@@ -0,0 +1,10 @@
+# jacobtools global configurations
+
+# Class to map columns in schema table to column numbers
+class SchemaStructure:
+    COLUMN_NAME = 0
+    DATA_TYPE = 1
+    DESCRIPTION = 2
+    DROP_FLAG = 3
+    REASON_FOR_DROPPING = 4
+    FILL_RATE = 5

jacobtools-0.0.1/src/jacobtools/gbq_queries/__init__.py

@@ -0,0 +1,15 @@
+# This is so that you can import ppack or import average from ppack
+# instead of from ppack.functions import average
+
+# from .decorators import singleton
+# from .database import infodb, listtb, uploadtb, downloadtb, deletetb
+# from .it import combo
+# from .pa import fheader
+
+from .fillrate_analysis import fillrate_analysis
+from .query_gbq import query_gbq
+
+__all__ = [
+    fillrate_analysis,
+    query_gbq
+]

jacobtools-0.0.1/src/jacobtools/gbq_queries/fillrate_analysis.py

@@ -0,0 +1,99 @@
+import pandas as pd
+from .query_gbq import query_gbq
+import bigframes.pandas as bpd
+from google.cloud import bigquery
+
+"""
+AUTHOR: Abisheak Jacob J
+LAST MODIFIED: 04-09-2025
+TITLE: Generate sql code to create a table in postgres
+DESCRIPTION: Generate SQL code to automate the process of writing "CREATE TABLE" sql code.
+"""
+
+def fillrate_analysis(
+        str_gcp_project_id: str,
+        str_gbq_project_id: str,
+        str_dataset: str,
+        bool_check_all_tables: bool = True,
+        lst_tables: list = [],
+        bool_save_to_csv: bool = False
+) -> pd.DataFrame:
+    
+    """
+        Calculates the fill rate (non-null value percentage) for columns in specified BigQuery tables.
+
+        Args:
+            str_gcp_project_id (str): The GCP project name used for querying BigQuery.
+            str_gbq_project_id (str): The project ID where the tables are located.
+            str_dataset (str): The dataset name containing the tables.
+            bool_check_all_tables (bool): If True, analyze all tables; otherwise, use lst_tables.
+            lst_tables (list): List of table names to include in the analysis.
+            bool_save_to_csv (bool): If True, save the result DataFrame to a CSV file.
+        Returns:
+            pd.DataFrame: A DataFrame containing table name, column name, non-null count,
+                          null-like count, total count, and fill rate for each column.
+    """
+
+    # Get table and column info
+    query_columns = f"""
+    SELECT table_name, column_name
+    FROM `{str_gbq_project_id}.{str_dataset}.INFORMATION_SCHEMA.COLUMNS`
+    """
+
+    columns_df = query_gbq(query=query_columns, str_gcp_project_id=str_gcp_project_id)
+    tables = columns_df.groupby('table_name')['column_name'].apply(list).to_dict()
+
+    # list of tables to be included in the fill rate calculation
+    if bool_check_all_tables:
+        lst_included_tables = list(tables.heys())
+    else:
+        lst_included_tables = lst_tables
+
+    lst_results = []
+
+    # Step 2: Loop over included tables and calculate fill rate using SQL
+    for table_name, column_list in tables.items():
+        if table_name not in lst_included_tables:
+            continue
+
+        full_table_id = f"{str_gbq_project_id}.{str_dataset}.{table_name}"
+        print(f" Processing table: {full_table_id}")
+
+        for col in column_list:
+            try:
+                query_fillrate = f"""
+                SELECT
+                COUNT(1) AS total_count,
+                SUM(CASE WHEN {col} IS NULL OR LOWER(TRIM(CAST({col} AS STRING))) IN ('null', '') THEN 1
+                        ELSE 0 END) AS null_like_count,
+                ROUND(1 - SUM(CASE WHEN {col} IS NULL OR LOWER(TRIM(CAST({col} AS STRING))) IN ('null', '') THEN 1
+                        ELSE 0 END) / COUNT(1), 4) AS fill_rate
+                FROM `{full_table_id}`
+                """
+
+                df_stats = query_gbq(query=query_fillrate, str_gcp_project_id=str_gcp_project_id)
+                stats = df_stats.iloc[0]    
+
+                lst_results.append({
+                    'table_name': table_name,
+                    'column_name': col,
+                    'non_null_count': stats['total_count'] - stats['null_like_count'],
+                    'null_like_count': stats['null_like_count'],
+                    'total_count': stats['total_count'],
+                    'fill_rate': stats['fill_rate']
+                })
+
+            except Exception as e:
+                print(f" Failed for column '{col}' in table '{table_name}': {e}")
+    
+    # Format Output
+    df_result = pd.DataFrame(lst_results)
+    df_result.sort_values(by='fill_rate', inplace=True)
+    df_result.columns = ['Table Name', 'Column Name', 'Non Null Count', 'Null Like Count', 'Total Count', 'Fill Rate']
+
+    # Save to CSV
+    if bool_save_to_csv:
+        df_result.to_csv("fill_rate_summary_{}_{}.csv".format(str_gbq_project_id,str_dataset), index=False)
+
+    return df_result
+        

jacobtools-0.0.1/src/jacobtools/gbq_queries/query_gbq.py

@@ -0,0 +1,31 @@
+import pandas as pd
+import pandas_gbq
+import bigframes.pandas as bpd
+from google.cloud import bigquery
+
+"""
+AUTHOR: Abisheak Jacob J
+LAST MODIFIED: 04-09-2025
+TITLE: Run SQL Query in GBQ
+DESCRIPTION: Function to connect to GBQ and run SQL Queries
+"""
+def query_gbq(
+        query: str, 
+        str_gcp_project_id: str
+    ) -> pd.DataFrame:
+
+    """
+    Function to connect to GBQ and run SQL Queries
+
+    Args:
+        query (str): the query that needs to be run in gbq
+        str_gcp_project_id (np.str): GCP project id under which you need to run this query. Big queries will be billed under this project
+
+    Returns:
+        pd.DataFrame: the output of the query is returned as a dataframe
+    """
+
+    # excecute query in the respective project
+    df_table = pandas_gbq.read_gbq(query, project_id=str_gcp_project_id, dialect="standard", use_bqstorage_api=True)
+
+    return df_table

jacobtools-0.0.1/src/jacobtools/preprocessing/__init__.py

@@ -0,0 +1,13 @@
+# This is so that you can import ppack or import average from ppack
+# instead of from ppack.functions import average
+
+# from .decorators import singleton
+# from .database import infodb, listtb, uploadtb, downloadtb, deletetb
+# from .it import combo
+# from .pa import fheader
+
+from .drop_columns_by_schema import drop_columns_by_schema
+
+__all__ = [
+    drop_columns_by_schema
+]

jacobtools-0.0.1/src/jacobtools/preprocessing/drop_columns_by_schema.py

@@ -0,0 +1,48 @@
+# import libraries
+from jacobtools.config import SchemaStructure
+import pandas as pd
+
+"""
+AUTHOR: Abisheak Jacob J
+LAST MODIFIED: 01-08-2025
+TITLE: Drop Columns by Schema Document
+DESCRIPTION: Drop columns that are not significant in providing any insight into the data using the DropFlag in the schema document
+"""
+
+def drop_columns_by_schema(
+        df: pd.DataFrame,
+        schema_df: pd.DataFrame,
+        drop_flag_column: int = SchemaStructure.DROP_FLAG
+) -> pd.DataFrame:
+    
+    # DOCSTRING
+    """
+    Drop columns that are not significant in providing any insight into the data using the DropFlag in the schema document.
+
+    PARAMETERS
+    -------------------
+    df: pd.DataFrame
+        This is the input DataFrame where columns need to be dropped
+    schema_df: pd.DataFrame
+        This is the schema DataFrame with the DropFlag
+    drop_flag_column: int
+        This is a global variable that indicates the column in the schema where the DropFlag is present
+
+    RETURNS
+    -------------------
+    pd.DataFrame
+        Residual DataFrame after the flagged columns are dropped
+
+    RAISES
+    --------------------
+    ValueError
+        If the column is not in the DataFrame or any other errors
+    """
+
+    # drop the columns flagged in schema table
+    df.drop(
+        columns = [col for col, flag in zip(df.columns.to_list(), schema_df.iloc[:, drop_flag_column]) if flag],
+        inplace=True
+        )
+
+    return df

jacobtools-0.0.1/src/jacobtools/sql_generation/__init__.py

@@ -0,0 +1,5 @@
+from .postgres import generate_create_table_sql
+
+__all__ = [
+    generate_create_table_sql
+]

jacobtools-0.0.1/src/jacobtools/sql_generation/postgres/__init__.py

@@ -0,0 +1,6 @@
+from .generate_create_table_sql import generate_create_table_sql, infer_pg_type
+
+__all__ = [
+    generate_create_table_sql,
+    infer_pg_type
+]

jacobtools-0.0.1/src/jacobtools/sql_generation/postgres/generate_create_table_sql.py

@@ -0,0 +1,95 @@
+# import libraries
+import pandas as pd
+import numpy as np
+
+"""
+AUTHOR: Abisheak Jacob J
+LAST MODIFIED: 04-09-2025
+TITLE: Generate sql code to create a table in postgres
+DESCRIPTION: Generate SQL code to automate the process of writing "CREATE TABLE" sql code.
+"""
+
+def infer_pg_type(
+        series: pd.Series
+) -> str:
+    
+    # DOCSTRING
+    """
+    Infer efficient Postgres data types from pandas series.
+
+    PARAMETERS
+    -------------------
+    series: pd.Series
+        This is a column of the dataframe for which we are generating SQL code.
+
+    RETURNS
+    -------------------
+    string: str
+        Returns a string that contains the data type of the column
+
+    """
+    # integer datatype
+    if pd.api.types.is_integer_dtype(series):
+        min_val, max_val = series.min(), series.max()
+        if min_val >= -32768 and max_val <= 32767:
+            return "SMALLINT"   # 2 bytes
+        elif min_val >= -2147483648 and max_val <= 2147483647:
+            return "INTEGER"    # 4 bytes
+        else:
+            return "BIGINT"     # 8 bytes
+    elif pd.api.types.is_float_dtype(series):
+        return "DOUBLE PRECISION"  # PostgreSQL's default 8-byte float
+    elif pd.api.types.is_bool_dtype(series):
+        return "BOOLEAN"
+    elif pd.api.types.is_datetime64_any_dtype(series):
+        return "TIMESTAMP"
+    else:
+        max_len = series.astype(str).map(len).max()
+        if max_len <= 255:
+            return f"VARCHAR({max_len + 10})"
+        else:
+            return "TEXT"
+
+def generate_create_table_sql(
+        csv_file: str, 
+        table_name: str = "my_table"
+        ) -> str:
+
+    # DOCSTRING
+    """
+    Generate CREATE TABLE sql for postgres
+
+    PARAMETERS
+    -------------------
+    csv_file: str
+        Path to csv file for which table schema is to be created
+    table_name: str
+        Name of the table in postgres database
+
+    RETURNS
+    -------------------
+    str
+        SQL Code
+
+    RAISES
+    --------------------
+    ValueError
+        If the column is not in the DataFrame or any other errors
+    """
+    # Load only 100000 rows for type inference
+    df = pd.read_csv(csv_file, nrows=10000)
+    
+    # infer efficient data type for each column
+    column_types = {col: infer_pg_type(df[col].dropna()) for col in df.columns}
+    
+    # generate sql code
+    sql_lines = [f'DROP TABLE IF EXISTS "{table_name}";\n\nCREATE TABLE "{table_name}" (']
+
+    for col, dtype in column_types.items():
+        sql_lines.append(f'    "{col}" {dtype},')
+
+    sql_lines[-1] = sql_lines[-1].rstrip(",")  # remove last comma
+    
+    sql_lines.append(");")
+    
+    return print("\n".join(sql_lines))

jacobtools-0.0.1/src/jacobtools/temp/chart.py

@@ -0,0 +1,63 @@
+import matplotlib.pyplot as plt
+import seaborn as sns
+
+def set_global_style():
+    sns.set_theme(style='whitegrid')  # You can choose 'white', 'darkgrid', etc.
+    plt.rcParams.update({
+        'figure.figsize': (10, 6),
+        'axes.titlesize': 16,
+        'axes.labelsize': 14,
+        'axes.edgecolor': '#333333',
+        'axes.linewidth': 1.2,
+        'axes.grid': True,
+        'grid.color': '#dddddd',
+        'grid.linestyle': '--',
+        'grid.linewidth': 0.5,
+        'xtick.labelsize': 12,
+        'ytick.labelsize': 12,
+        'legend.fontsize': 12,
+        'legend.frameon': True,
+        'legend.framealpha': 0.9,
+        'legend.edgecolor': '#444444',
+        'font.family': 'sans-serif',
+        'font.sans-serif': 'DejaVu Sans'
+    })
+
+    sns.set_palette("Set2")  # or use custom_palette = sns.color_palette([...])
+
+
+
+def plot_line(data, x, y, hue=None, title='', xlabel='', ylabel=''):
+    set_global_style()
+    plt.figure()
+    ax = sns.lineplot(data=data, x=x, y=y, hue=hue)
+    ax.set_title(title)
+    ax.set_xlabel(xlabel if xlabel else x)
+    ax.set_ylabel(ylabel if ylabel else y)
+    plt.tight_layout()
+    plt.show()
+
+
+def plot_bar(data, x, y, hue=None, title='', xlabel='', ylabel='', orient='v'):
+    set_global_style()
+    plt.figure()
+    ax = sns.barplot(data=data, x=x, y=y, hue=hue, orient=orient)
+    ax.set_title(title)
+    ax.set_xlabel(xlabel if xlabel else x)
+    ax.set_ylabel(ylabel if ylabel else y)
+    plt.tight_layout()
+    plt.show()
+
+
+def plot_heatmap(data, title='', xlabel='', ylabel='', annot=True, fmt=".2f", cmap='coolwarm'):
+    set_global_style()
+    plt.figure()
+    ax = sns.heatmap(data, annot=annot, fmt=fmt, cmap=cmap, cbar=True)
+    ax.set_title(title)
+    ax.set_xlabel(xlabel)
+    ax.set_ylabel(ylabel)
+    plt.tight_layout()
+    plt.show()
+
+def save_plot(filename, dpi=300):
+    plt.savefig(filename, dpi=dpi, bbox_inches='tight', transparent=False)

jacobtools-0.0.1/src/jacobtools/temp/database.py

@@ -0,0 +1,160 @@
+# %%
+# import the libraries
+from sqlalchemy import create_engine, inspect, MetaData, Table, text
+import pandas as pd
+
+
+# %%
+# defining the parameters for the database connection as global variables
+def infodb(host, user, passw, dbname, show_url=False):
+    # write a docstring for this function
+    """
+    This function is used to define the parameters for the database connection as global variables.
+    This function also defines the MySQL database url for the connection.
+
+    :param host: object
+    :param user: object
+    :param passw: object
+    :param dbname: object
+    :return:
+    """
+
+    # define the global variables
+    global hostname
+    global username
+    global password
+    global databasename
+    global databaseurl
+
+    # assign the values of the database credentials to the global variables
+    hostname = str(host)
+    username = str(user)
+    password = str(passw)
+    databasename = str(dbname)
+    databaseurl = "mysql://" + user + ":" + password + "@" + host + "/" + databasename
+
+    # if show_url is True then print the database url
+    if show_url:
+        print(f"The database url is: {databaseurl}")
+
+
+# %%
+# defining the list all tables in the database function
+def listtb():
+    """
+    This function is used to list all the tables in the database.
+    :return:
+    """
+    try:
+        # Create a SQLAlchemy engine to connect to the database
+        engine = create_engine(databaseurl)
+
+        # Create an Inspector for the engine
+        inspector = inspect(engine)
+
+        # Get the table names from the database
+        table_names = inspector.get_table_names()
+
+        # return the table names
+        return pd.DataFrame(table_names)
+
+    except Exception as e:
+
+        # if error return the error
+        return str(e)
+
+
+# %%
+# upload a dataframe to the database
+def uploadtb(df, tbname):
+    """
+    This function is used to upload a dataframe to the database.
+    :param df: dataframe
+    :param tbname: object
+    :return:
+    """
+
+    # convert the table name to string
+    tbname = str(tbname)
+
+    try:
+        # Create a SQLAlchemy engine to connect to the database
+        engine = create_engine(databaseurl)
+
+        # engine.execute(text('DELETE FROM NseTicker'))
+        with engine.connect() as conn:
+            conn.execute(text(f"DELETE FROM {tbname}"))
+            conn.commit()
+
+        # upload the dataframe to the database
+        df.to_sql(tbname, engine, if_exists="append", index=False)
+
+        # return a success message
+        return "Dataframe uploaded successfully"
+
+    except Exception as e:
+
+        # if error return the error
+        return str(e)
+
+
+# %%
+# download a table from the database
+def downloadtb(tbname):
+    """
+    This function is used to download a table from the database.
+    :param tbname: object
+    :return:
+    """
+
+    # convert the table name to string
+    tbname = str(tbname)
+
+    try:
+        # Create a SQLAlchemy engine to connect to the database
+        engine = create_engine(databaseurl)
+
+        # download the table from the database
+        df = pd.read_sql(tbname, engine)
+
+        # return the dataframe
+        return df
+
+    except Exception as e:
+
+        # if error return the error
+        print(str(e))
+
+
+# %%
+# delete a table from the database
+def deletetb(tbname):
+    """
+    This function is used to delete a table from the database.
+    :param tbname: object
+    :return:
+    """
+
+    # convert the table name to string
+    tbname = str(tbname)
+
+    try:
+        # Create a SQLAlchemy engine to connect to the database
+        engine = create_engine(databaseurl)
+
+        # Create a MetaData object
+        metadata = MetaData()
+
+        # Reflect the existing table
+        existing_table = Table(tbname, metadata, autoload_with=engine)
+
+        # Drop the table
+        existing_table.drop(engine, checkfirst=True)
+
+        # return a success message
+        return "Table deleted successfully"
+
+    except Exception as e:
+
+        # if error return the error
+        return str(e)

jacobtools-0.0.1/src/jacobtools/temp/decorators.py

@@ -0,0 +1,7 @@
+def singleton(class_):
+    instances = {}
+    def getinstance(*args, **kwargs):
+        if class_ not in instances:
+            instances[class_] = class_(*args, **kwargs)
+        return instances[class_]
+    return getinstance

jacobtools-0.0.1/src/jacobtools/temp/it.py

@@ -0,0 +1,36 @@
+# importing the packages
+
+from itertools import combinations
+from collections import Counter
+import pandas as pd
+# creating a function to calculate the count of all the possible combinations
+
+def combo(df_data, column_name, groupby_column, combo_no):
+    
+    
+    # create the groupby column and the column name
+    # groupby column - the column which you choose to use as the pivot for the entire combination operation
+    # column_name - the column that you wish to create the combinations along a pivot
+    # creating a dataframe along the groupby column where the combination column will form a list
+    
+    new_data = df_data.groupby(groupby_column)[column_name].agg(list).reset_index()
+    
+    
+    # creating a new column all-combinations that contains all the combinations of the items as per the combo_no
+    
+    new_data['all_combinations'] = new_data[column_name].apply(lambda x: list(combinations(x,combo_no)))
+    
+    
+    # count the number of occurances of each particular combinations
+    
+    combinations_counter = Counter([tuple(sorted(i)) for sublist in new_data['all_combinations'] for i in sublist])
+    
+    
+    # sort all the combinations in the descending order
+    
+    all_combinations_sorted = combinations_counter.most_common()
+    
+    
+    # returns the sorted series 
+    
+    return all_combinations_sorted

jacobtools-0.0.1/src/jacobtools/temp/pa.py

@@ -0,0 +1,34 @@
+# importing the packages
+import pandas as pd
+
+
+# defining a fuction to convert the function to lowercase
+def fheader(df_name):
+
+
+    # creating a list of the column titles in the dataframe
+    
+    column_titles = list(df_name.columns)
+
+    
+    # converting all the elements in the list to lowercase
+    
+    column_titles = [x.lower() for x in column_titles]
+
+    
+    # removing empty space in the beginging and the end of all the headers
+    
+    column_titles = [x.strip() for x in column_titles]
+
+    
+    # converting all the spaces left in the header to underscore
+    
+    column_titles = [x.replace(" ", "_") for x in column_titles]
+    
+    
+    # replacing the old header names with the new ones
+    
+    df_name.columns = column_titles
+
+
+    return df_name

jacobtools-0.0.1/src/jacobtools/temp/reason_for_absence.csv

@@ -0,0 +1,29 @@
+reason_no,reason_details
+1,Certain infectious and parasitic diseases
+2,Neoplasms
+3,Diseases of the blood and blood-forming organs and certain disorders involving the immune mechanism
+4,"Endocrine, nutritional and metablolic diseases"
+5,Mental and behavioural disorders
+6,Diseases of the nervous system
+7,Diseases of the eye and adnexa
+8,Diseases of the ear and mastoid process
+9,Diseases of the circulatory system
+10,Diseases of the respiratory system
+11,Diseases of the digestive system
+12,Diseases of the skin and subcutaneous tissue
+13,Diseases of he musculoskeletal system and connective tissue
+14,Disease of the genitourinary system
+15,"Pregnancy, childbirth and the puerperium"
+16,Certain conditions originating in the perinatal period
+17,"Congenital malformations, deformations and chromosal abnormalities"
+18,"Symptoms, signs and abnormal clinical and laboratory findings, not elsewhere classified"
+19,"Injury, poisoning and certain other consequences of external causes"
+20,External causes of morbidity and mortality
+21,Factors influencing health status and contack with health services
+22,Patient follow-up
+23,Medical consultation
+24,Blood donation
+25,Laboratory examination
+26,Unjustified absence
+27,Physiotherapy
+28,Dental Consultation

jacobtools-0.0.1/src/jacobtools_test/__init__.py

@@ -0,0 +1,5 @@
+# Expose submodules at top level
+
+from . import harmonic_mean
+
+__all__ = [harmonic_mean]

jacobtools-0.0.1/src/jacobtools_test/harmonic_mean.py

@@ -0,0 +1,2 @@
+def harmonic_mean(nums):
+    return len(nums) / sum(1 / num for num in nums)

jacobtools-0.0.1/src/jacobtools_test/harmony.py

@@ -0,0 +1,19 @@
+import sys
+from jacobtools_test.harmonic_mean import harmonic_mean
+from termcolor import cprint
+
+
+def main():
+    result = 0.0
+
+    try:
+        nums = [float(num) for num in sys.argv[1:]]
+    except ValueError:
+        nums = []
+
+    try:
+        result = harmonic_mean(nums)
+    except ZeroDivisionError:
+        pass
+
+    cprint(result, "red", "on_cyan", attrs=["bold"])

jacobtools-0.0.1/src/jacobtools_test.egg-info/PKG-INFO

@@ -0,0 +1,17 @@
+Metadata-Version: 2.4
+Name: jacobtools_test
+Version: 0.0.1
+Summary: This package contains functions that help me tackle my day to day data andalytics requirements
+Home-page: 'https://github.com/AbisheakJacob/jacobtools'
+Author: Abisheak Jacob J
+Author-email: "AbisheakJacob0032" abisheakjacob0032@gmail.com
+License: MIT
+Classifier: License :: OSI Approved :: MIT License
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=2.1.0
+Requires-Dist: termcolor>=1.1.0
+Dynamic: license-file
+
+README.md

jacobtools-0.0.1/src/jacobtools_test.egg-info/SOURCES.txt

@@ -0,0 +1,41 @@
+LICENSE
+MANIFEST.in
+README.md
+pyproject.toml
+setup.cfg
+src/jacobtools/__init__.py
+src/jacobtools/config.py
+src/jacobtools/__pycache__/__init__.cpython-312.pyc
+src/jacobtools/__pycache__/config.cpython-312.pyc
+src/jacobtools/gbq_queries/__init__.py
+src/jacobtools/gbq_queries/fillrate_analysis.py
+src/jacobtools/gbq_queries/query_gbq.py
+src/jacobtools/gbq_queries/__pycache__/__init__.cpython-312.pyc
+src/jacobtools/gbq_queries/__pycache__/fillrate_analysis.cpython-312.pyc
+src/jacobtools/gbq_queries/__pycache__/query_gbq.cpython-312.pyc
+src/jacobtools/preprocessing/__init__.py
+src/jacobtools/preprocessing/drop_columns_by_schema.py
+src/jacobtools/preprocessing/enforce_schema.py
+src/jacobtools/preprocessing/__pycache__/__init__.cpython-312.pyc
+src/jacobtools/preprocessing/__pycache__/drop_columns_by_schema.cpython-312.pyc
+src/jacobtools/sql_generation/__init__.py
+src/jacobtools/sql_generation/__pycache__/__init__.cpython-312.pyc
+src/jacobtools/sql_generation/postgres/__init__.py
+src/jacobtools/sql_generation/postgres/generate_create_table_sql.py
+src/jacobtools/sql_generation/postgres/__pycache__/__init__.cpython-312.pyc
+src/jacobtools/sql_generation/postgres/__pycache__/generate_create_table_sql.cpython-312.pyc
+src/jacobtools/temp/chart.py
+src/jacobtools/temp/database.py
+src/jacobtools/temp/decorators.py
+src/jacobtools/temp/it.py
+src/jacobtools/temp/pa.py
+src/jacobtools/temp/reason_for_absence.csv
+src/jacobtools_test/__init__.py
+src/jacobtools_test/harmonic_mean.py
+src/jacobtools_test/harmony.py
+src/jacobtools_test.egg-info/PKG-INFO
+src/jacobtools_test.egg-info/SOURCES.txt
+src/jacobtools_test.egg-info/dependency_links.txt
+src/jacobtools_test.egg-info/entry_points.txt
+src/jacobtools_test.egg-info/requires.txt
+src/jacobtools_test.egg-info/top_level.txt

jacobtools-0.0.1/src/jacobtools_test.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

jacobtools-0.0.1/src/jacobtools_test.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+harmony = jacobtools_test.harmony:main

jacobtools-0.0.1/src/jacobtools_test.egg-info/requires.txt

@@ -0,0 +1,2 @@
+numpy>=2.1.0
+termcolor>=1.1.0

jacobtools-0.0.1/src/jacobtools_test.egg-info/top_level.txt

@@ -0,0 +1,2 @@
+jacobtools
+jacobtools_test