Transaction is not getting rolled back about pyodbc HOT 7 CLOSED

def __enter__(self):
    try:
        # Initialize the connection
        self.conn = pyodbc.connect()
        # Begin transaction
        self.conn.autocommit = False
        self.error_occurred = False
        return self
    except Exception as e:
        print(f"Error occurred while establishing connection: {e}")
        raise

def __exit__(self, exc_type, exc_value, traceback):
    try:
        if self.conn:
            if exc_type is not None or self.error_occurred:
                # Rollback transaction if exception occurred
                print(f"exception received here--->{exc_type}")
                self.conn.rollback()
                self.error_occurred = False
            else:
                print("Coming for commit--->")
                # Commit transaction if no exception occurred
                self.conn.commit()
            # Reset autocommit to default value
            self.conn.close()
    except Exception as e:
        print(f"Error occurred while closing connection: {e}")

def select_data(self, query):
    try:
        with self.conn.cursor() as cursor:
            cursor.execute(query)
            rows = cursor.fetchall()
            if rows:
                columns = [str(column[0]) for column in cursor.description]
                df = pd.DataFrame.from_records(rows, columns=columns)
                return df
            else:
                return pd.DataFrame()
    except Exception as e:
        print(f"Error occurred while executing select query: {e}")
        raise

def bulk_update(self, table, updates):
    try:
        with self.conn.cursor() as cursor:
            for update in updates:
                update_query = f"UPDATE {table} SET {', '.join([f'{col} = ?' for col in update['columns']])} WHERE {update['condition']}"
                cursor.execute(update_query, update['values'])
    except Exception as e:
        print(f"Error occurred while bulk updating data: {e}")
        self.error_occurred = True
        raise

def single_insert(self, table, data):
    """
    Perform a single insert operation for a row of data into the specified table.

    Args:
        table (str): The name of the table where the data will be inserted.
        data (dict): A dictionary representing the data to be inserted.
                     The keys should correspond to column names and values
                     should correspond to the values to be inserted.

    Raises:
        Exception: If an error occurs during the insert operation.
    """
    try:
        with self.conn.cursor() as cursor:
            columns = ', '.join(data.keys())
            placeholders = ', '.join(['?' for _ in data.values()])
            insert_query = f"INSERT INTO {table} ({columns}) VALUES ({placeholders})"
            cursor.execute(insert_query, list(data.values()))
    except Exception as e:
        print(f"Error occurred while performing single insert: {e}")
        self.error_occurred = True
        raise

def bulk_insert(self, table, df):
    try:
        with self.conn.cursor() as cursor:
            # Extract column names and values from the DataFrame
            columns = list(df.columns)
            values = df.values.tolist()
            # Generate the INSERT INTO query
            insert_query = f"INSERT INTO {table} ({', '.join(columns)}) VALUES ({', '.join(['?'] * len(columns))})"
            # Execute the query
            cursor.executemany(insert_query, values)
    except Exception as e:
        print(f"Error occurred while bulk inserting data: {e}")
        self.error_occurred = True
        raise