Upload 3701 files

.env

@@ -0,0 +1 @@
+GOOGLE_API_KEY= "AIzaSyDV12vrr57IM98VmbEMdWm2fqDTMFFsNE4"

.gitattributes

@@ -40,3 +40,10 @@ Project/myenv/Lib/site-packages/faiss_cpu.libs/openblas-a71b19fb42460f7cb972d9cc
 Project/myenv/Lib/site-packages/faiss/_swigfaiss.cp311-win_amd64.pyd filter=lfs diff=lfs merge=lfs -text
 Project/myenv/Lib/site-packages/grpc/_cython/cygrpc.cp311-win_amd64.pyd filter=lfs diff=lfs merge=lfs -text
 Project/myenv/share/jupyter/nbextensions/pydeck/index.js.map filter=lfs diff=lfs merge=lfs -text
+myenv/Lib/site-packages/altair/vegalite/v5/schema/__pycache__/channels.cpython-311.pyc filter=lfs diff=lfs merge=lfs -text
+myenv/Lib/site-packages/altair/vegalite/v5/schema/__pycache__/core.cpython-311.pyc filter=lfs diff=lfs merge=lfs -text
+myenv/Lib/site-packages/faiss_cpu.libs/flang-d38962844214aa9b06fc3989f9adae5b.dll filter=lfs diff=lfs merge=lfs -text
+myenv/Lib/site-packages/faiss_cpu.libs/openblas-a71b19fb42460f7cb972d9cc8bfba6b4.dll filter=lfs diff=lfs merge=lfs -text
+myenv/Lib/site-packages/faiss/_swigfaiss.cp311-win_amd64.pyd filter=lfs diff=lfs merge=lfs -text
+myenv/Lib/site-packages/grpc/_cython/cygrpc.cp311-win_amd64.pyd filter=lfs diff=lfs merge=lfs -text
+myenv/share/jupyter/nbextensions/pydeck/index.js.map filter=lfs diff=lfs merge=lfs -text

Scraper/course_scraper.py

@@ -0,0 +1,162 @@
+import requests
+from bs4 import BeautifulSoup
+import pandas as pd
+from sklearn.feature_extraction.text import TfidfVectorizer
+from sklearn.metrics.pairwise import cosine_similarity
+import time
+from urllib.parse import urljoin
+
+# Constants
+BASE_URL = 'https://courses.analyticsvidhya.com/collections/'
+COURSE_LISTING_URL = f'{BASE_URL}courses'
+CSV_FILE = 'detailed_courses.csv'
+
+# Function to fetch and parse HTML content
+def fetch_html(url):
+    try:
+        response = requests.get(url)
+        response.raise_for_status()
+        return BeautifulSoup(response.content, 'html.parser')
+    except requests.exceptions.HTTPError as errh:
+        print(f"HTTP Error: {errh}")
+    except requests.exceptions.ConnectionError as errc:
+        print(f"Error Connecting: {errc}")
+    except requests.exceptions.Timeout as errt:
+        print(f"Timeout Error: {errt}")
+    except requests.exceptions.RequestException as err:
+        print(f"Error: {err}")
+
+# Function to scrape course listing pages
+def scrape_course_listings():
+    courses = []  # Initialize empty list to store all courses
+    page_num = 1
+    max_pages = 9
+
+    while page_num <= max_pages:
+        print(f"\nProcessing page {page_num}")
+        page_url = f"{COURSE_LISTING_URL}?page={page_num}"
+        soup = fetch_html(page_url)
+
+        if not soup:
+            print(f"Failed to fetch or parse page {page_num}")
+            break
+
+        course_container = soup.find('div', class_='collections__product-cards collections__product-cards___0b9ab')
+        if not course_container:
+            print(f"No course container found on page {page_num}")
+            break
+
+        course_cards = course_container.find_all('li', class_='products__list-item')
+
+        courses_on_this_page = 0  # Counter for courses added from current page
+
+        for card in course_cards:
+            price = card.find('span', class_='course-card__price')
+            if price and price.text.strip() == 'Free':
+                link = card.find('a')
+                title = card.find('h3')
+
+                if link and title:
+                    full_link = urljoin(BASE_URL, link['href'])
+                    courses.append({
+                        'Title': title.text.strip(),
+                        'Link': full_link,
+                        'Page': page_num  # Adding page number for verification
+                    })
+                    courses_on_this_page += 1
+
+
+        page_num += 1
+        time.sleep(1)
+
+    return courses
+
+#Function to scrape detailed course information
+def scrape_course_details(courses):
+    for course in courses:
+        soup = fetch_html(course['Link'])
+        if not soup:
+            continue
+
+        try:
+            # Brief
+            h2_elements = soup.find_all('h2')
+            course['Brief'] = h2_elements[0].text if h2_elements else 'No brief available'
+
+            # Duration, Rating, Level
+            h4_elements = soup.find_all('h4', class_=None)
+            if len(h4_elements) >= 3:
+                course['Duration'] = h4_elements[0].text
+                course['Rating'] = h4_elements[1].text
+                course['Level'] = h4_elements[2].text
+            else:
+                course['Duration'] = 'No duration available'
+                course['Rating'] = 'No rating available'
+                course['Level'] = 'No level available'
+
+            # Trainer information
+            trainer = []
+            inst = soup.find_all('h4', class_=lambda x: x and x.startswith("section__subheading"))
+            trainer.extend(i.text for i in inst)
+
+            tf = soup.find_all('div', class_='section__body')
+            if tf and tf[0].get_text(strip=True).startswith("Unlock a lifetime-valid"):
+                tf = tf[1:]
+
+            trainer_dict = {}
+            for i in range(len(trainer)):
+                if i < len(tf):
+                    trainer_dict[trainer[i]] = tf[i].get_text(strip=True)
+            course['Trainer'] = trainer_dict if trainer_dict else 'No trainer available'
+
+            # Description
+            description_elements = soup.find_all('div', class_='custom-theme')
+            course['Description'] = description_elements[0].text if description_elements else 'No description available'
+
+            # Curriculum
+            spans = soup.find_all('span', class_='course-curriculum__chapter-lesson')
+            curriculum = [span.get_text(strip=True) for span in spans]
+            course['Curriculum'] = curriculum if curriculum else 'No curriculum available'
+
+            # What should enroll & takeaway
+            wse_ta = soup.find_all('li', class_='checklist__list-item')
+            wa = [i.get_text(strip=True) for i in wse_ta]
+            course['What should enroll & takeaway'] = wa if wa else 'No what should enroll & takeaway available'
+
+            # FAQ
+            faq_list_items = soup.find_all('li', class_='faq__list-item')
+            faq_data = []
+            for item in faq_list_items:
+                question = item.find('strong')
+                answer = item.find('p')
+                if question and answer:
+                    faq_data.append({
+                        'Question': question.text,
+                        'Answer': answer.text
+                    })
+            course['FAQ'] = faq_data if faq_data else 'No FAQ available'
+
+        except Exception as e:
+            print(f"Error processing {course['Title']}: {str(e)}")
+            continue
+
+        time.sleep(1)  # Respectful delay between requests
+
+    return courses
+
+# Example usage:
+courses = scrape_course_listings()  # Get the initial courses
+detailed_courses = scrape_course_details(courses)  # Add details to each course
+
+
+# Function to save data to CSV
+def save_to_csv(courses):
+    df = pd.DataFrame(courses)
+    df.to_csv(CSV_FILE, index=False)
+    print(f"Data saved to {CSV_FILE}")
+
+
+course_list = scrape_course_listings()
+cr = scrape_course_details(course_list)
+save_to_csv(cr)
+

app.py

@@ -0,0 +1,185 @@
+import streamlit as st
+import pandas as pd
+import os
+from dotenv import load_dotenv
+import google.generativeai as genai
+from langchain_google_genai import GoogleGenerativeAIEmbeddings
+from langchain_community.vectorstores import FAISS
+import tempfile
+
+# Load environment variables
+load_dotenv()
+
+class CourseSearchSystem:
+    def __init__(self):
+        """
+        Initialize the course search system with Google's Generative AI
+        """
+        genai.configure(api_key=os.getenv('GOOGLE_API_KEY'))
+        self.generation_model = genai.GenerativeModel('gemini-pro')
+        self.embeddings = GoogleGenerativeAIEmbeddings(model="models/embedding-001")
+        self.vector_store = None
+        self.course_data = []
+
+    def process_course(self, row):
+        """
+        Process a single course row into a formatted string
+        """
+        return f"""
+        TITLE: {row['Title']}
+        BRIEF: {row['Brief']}
+        LEVEL: {row['Level']}
+        DURATION: {row['Duration']}
+        DESCRIPTION: {row['Description']}
+        URL: {row['Link']}
+        CURRICULUM: {row['Curriculum']}
+        TARGET AUDIENCE AND BENEFITS: {row['What should enroll & takeaway']}
+        """
+
+    def create_vector_store(self, df):
+        """
+        Create vector store from course data
+        """
+        texts = []
+        for _, row in df.iterrows():
+            doc = self.process_course(row)
+            texts.append(doc)
+            self.course_data.append({
+                'title': row['Title'],
+                'brief': row['Brief'],
+                'level': row['Level'],
+                'duration': row['Duration'],
+                'url': row['Link'],
+                'curriculum': row['Curriculum'],
+                'target_audience': row['What should enroll & takeaway']
+            })
+        
+        # Create vector store and store it directly in memory
+        self.vector_store = FAISS.from_texts(texts, self.embeddings)
+
+    def search_courses(self, query, k=3):
+        """
+        Search for relevant courses based on query
+        """
+        try:
+            if not self.vector_store:
+                return "Error: Search index not initialized.", []
+
+            # Perform similarity search using in-memory vector store
+            similar_docs = self.vector_store.similarity_search(query, k=k)
+            
+            relevant_courses = []
+            relevant_chunks = []
+            
+            for doc in similar_docs:
+                doc_content = doc.page_content
+                try:
+                    idx = next(i for i, course in enumerate(self.course_data) 
+                             if course['title'] in doc_content)
+                    relevant_courses.append(self.course_data[idx])
+                    relevant_chunks.append(doc_content)
+                except StopIteration:
+                    continue
+
+            if not relevant_courses:
+                return "No matching courses found for your query.", []
+            
+            # Enhanced prompt for better analysis
+            context = f"""
+            Act as an experienced course advisor analyzing courses for a student interested in: "{query}"
+
+            Based on their interest, analyze these relevant courses:
+            {relevant_chunks}
+
+            Provide a detailed analysis that includes:
+            1. Query Analysis: What specific learning needs or interests are indicated by this query
+            2. Course Recommendations: For each relevant course:
+               - Explain why it matches the student's needs
+               - Highlight key features and benefits
+               - Specify who would benefit most from this course
+            3. Best Match: Identify the most suitable course and explain why
+            4. Learning Path: Suggest how the student might progress through these courses if relevant
+
+            Be specific in your analysis, mentioning course titles and concrete features.
+            Focus on how each course addresses the student's learning objectives.
+            """
+            
+            try:
+                response = self.generation_model.generate_content(context)
+                return response.text, relevant_courses
+            except Exception as e:
+                return f"Error generating course analysis: {str(e)}", relevant_courses
+                
+        except Exception as e:
+            return f"Error during course search: {str(e)}", []
+
+def main():
+    """
+    Main function to run the Streamlit application
+    """
+    st.title("🎓 Intelligent Course Search Assistant")
+    st.write("Find the perfect course for your learning journey with AI-powered recommendations.")
+    
+    @st.cache_resource
+    def initialize_search_system():
+        return CourseSearchSystem()
+    
+    @st.cache_data
+    def load_and_process_data():
+        csv_path = r"data\detailed_courses.csv"
+        try:
+            df = pd.read_csv(csv_path)
+            return df
+        except FileNotFoundError:
+            st.error(f"Could not find the file: {csv_path}")
+            st.info("Please ensure the CSV file path is correct.")
+            return None
+
+    search_system = initialize_search_system()
+    df = load_and_process_data()
+    
+    if df is not None:
+        if 'index_built' not in st.session_state:
+            with st.spinner("Building search index... This may take a moment."):
+                search_system.create_vector_store(df)
+                st.session_state.index_built = True
+
+        query = st.text_input("🔍 What would you like to learn?", 
+                            placeholder="Example: machine learning for beginners")
+        
+        col1, col2 = st.columns([2, 1])
+        with col1:
+            search_button = st.button("Search Courses", use_container_width=True)
+            
+        if query and search_button:
+            with st.spinner("Analyzing courses for you..."):
+                response, courses = search_system.search_courses(query)
+                
+                if courses:  # Only show analysis if courses were found
+                    st.write("### 📊 Course Analysis")
+                    st.write(response)
+                    
+                    st.write("### 📚 Recommended Courses")
+                    for course in courses:
+                        with st.expander(f"📘 {course['title']}", expanded=True):
+                            cols = st.columns([1, 1])
+                            with cols[0]:
+                                st.write(f"**Level:** {course['level']}")
+                                st.write(f"**Duration:** {course['duration']}")
+                            
+                            with cols[1]:
+                                st.markdown(f"[**Enroll Now** 🚀]({course['url']})")
+                            
+                            st.write("**Overview:**")
+                            st.write(course['brief'])
+                            
+                            with st.expander("📋 View Curriculum"):
+                                st.write(course['curriculum'])
+                            
+                            with st.expander("👥 Who Should Take This Course"):
+                                st.write(course['target_audience'])
+                else:
+                    st.warning("No courses found matching your query. Please try different search terms.")
+
+if __name__ == "__main__":
+    main()

myenv/Include/site/python3.11/greenlet/greenlet.h

@@ -0,0 +1,164 @@
+/* -*- indent-tabs-mode: nil; tab-width: 4; -*- */
+
+/* Greenlet object interface */
+
+#ifndef Py_GREENLETOBJECT_H
+#define Py_GREENLETOBJECT_H
+
+
+#include <Python.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* This is deprecated and undocumented. It does not change. */
+#define GREENLET_VERSION "1.0.0"
+
+#ifndef GREENLET_MODULE
+#define implementation_ptr_t void*
+#endif
+
+typedef struct _greenlet {
+    PyObject_HEAD
+    PyObject* weakreflist;
+    PyObject* dict;
+    implementation_ptr_t pimpl;
+} PyGreenlet;
+
+#define PyGreenlet_Check(op) (op && PyObject_TypeCheck(op, &PyGreenlet_Type))
+
+
+/* C API functions */
+
+/* Total number of symbols that are exported */
+#define PyGreenlet_API_pointers 12
+
+#define PyGreenlet_Type_NUM 0
+#define PyExc_GreenletError_NUM 1
+#define PyExc_GreenletExit_NUM 2
+
+#define PyGreenlet_New_NUM 3
+#define PyGreenlet_GetCurrent_NUM 4
+#define PyGreenlet_Throw_NUM 5
+#define PyGreenlet_Switch_NUM 6
+#define PyGreenlet_SetParent_NUM 7
+
+#define PyGreenlet_MAIN_NUM 8
+#define PyGreenlet_STARTED_NUM 9
+#define PyGreenlet_ACTIVE_NUM 10
+#define PyGreenlet_GET_PARENT_NUM 11
+
+#ifndef GREENLET_MODULE
+/* This section is used by modules that uses the greenlet C API */
+static void** _PyGreenlet_API = NULL;
+
+#    define PyGreenlet_Type \
+        (*(PyTypeObject*)_PyGreenlet_API[PyGreenlet_Type_NUM])
+
+#    define PyExc_GreenletError \
+        ((PyObject*)_PyGreenlet_API[PyExc_GreenletError_NUM])
+
+#    define PyExc_GreenletExit \
+        ((PyObject*)_PyGreenlet_API[PyExc_GreenletExit_NUM])
+
+/*
+ * PyGreenlet_New(PyObject *args)
+ *
+ * greenlet.greenlet(run, parent=None)
+ */
+#    define PyGreenlet_New                                        \
+        (*(PyGreenlet * (*)(PyObject * run, PyGreenlet * parent)) \
+             _PyGreenlet_API[PyGreenlet_New_NUM])
+
+/*
+ * PyGreenlet_GetCurrent(void)
+ *
+ * greenlet.getcurrent()
+ */
+#    define PyGreenlet_GetCurrent \
+        (*(PyGreenlet * (*)(void)) _PyGreenlet_API[PyGreenlet_GetCurrent_NUM])
+
+/*
+ * PyGreenlet_Throw(
+ *         PyGreenlet *greenlet,
+ *         PyObject *typ,
+ *         PyObject *val,
+ *         PyObject *tb)
+ *
+ * g.throw(...)
+ */
+#    define PyGreenlet_Throw                 \
+        (*(PyObject * (*)(PyGreenlet * self, \
+                          PyObject * typ,    \
+                          PyObject * val,    \
+                          PyObject * tb))    \
+             _PyGreenlet_API[PyGreenlet_Throw_NUM])
+
+/*
+ * PyGreenlet_Switch(PyGreenlet *greenlet, PyObject *args)
+ *
+ * g.switch(*args, **kwargs)
+ */
+#    define PyGreenlet_Switch                                              \
+        (*(PyObject *                                                      \
+           (*)(PyGreenlet * greenlet, PyObject * args, PyObject * kwargs)) \
+             _PyGreenlet_API[PyGreenlet_Switch_NUM])
+
+/*
+ * PyGreenlet_SetParent(PyObject *greenlet, PyObject *new_parent)
+ *
+ * g.parent = new_parent
+ */
+#    define PyGreenlet_SetParent                                 \
+        (*(int (*)(PyGreenlet * greenlet, PyGreenlet * nparent)) \
+             _PyGreenlet_API[PyGreenlet_SetParent_NUM])
+
+/*
+ * PyGreenlet_GetParent(PyObject* greenlet)
+ *
+ * return greenlet.parent;
+ *
+ * This could return NULL even if there is no exception active.
+ * If it does not return NULL, you are responsible for decrementing the
+ * reference count.
+ */
+#     define PyGreenlet_GetParent                                    \
+    (*(PyGreenlet* (*)(PyGreenlet*))                                 \
+     _PyGreenlet_API[PyGreenlet_GET_PARENT_NUM])
+
+/*
+ * deprecated, undocumented alias.
+ */
+#     define PyGreenlet_GET_PARENT PyGreenlet_GetParent
+
+#     define PyGreenlet_MAIN                                         \
+    (*(int (*)(PyGreenlet*))                                         \
+     _PyGreenlet_API[PyGreenlet_MAIN_NUM])
+
+#     define PyGreenlet_STARTED                                      \
+    (*(int (*)(PyGreenlet*))                                         \
+     _PyGreenlet_API[PyGreenlet_STARTED_NUM])
+
+#     define PyGreenlet_ACTIVE                                       \
+    (*(int (*)(PyGreenlet*))                                         \
+     _PyGreenlet_API[PyGreenlet_ACTIVE_NUM])
+
+
+
+
+/* Macro that imports greenlet and initializes C API */
+/* NOTE: This has actually moved to ``greenlet._greenlet._C_API``, but we
+   keep the older definition to be sure older code that might have a copy of
+   the header still works. */
+#    define PyGreenlet_Import()                                               \
+        {                                                                     \
+            _PyGreenlet_API = (void**)PyCapsule_Import("greenlet._C_API", 0); \
+        }
+
+#endif /* GREENLET_MODULE */
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_GREENLETOBJECT_H */

myenv/Lib/site-packages/GitPython-3.1.44.dist-info/AUTHORS

@@ -0,0 +1,59 @@
+GitPython was originally written by Michael Trier.
+GitPython 0.2 was partially (re)written by Sebastian Thiel, based on 0.1.6 and git-dulwich.
+
+Contributors are:
+
+-Michael Trier <mtrier _at_ gmail.com>
+-Alan Briolat
+-Florian Apolloner <florian _at_ apolloner.eu>
+-David Aguilar <davvid _at_ gmail.com>
+-Jelmer Vernooij <jelmer _at_ samba.org>
+-Steve Frécinaux <code _at_ istique.net>
+-Kai Lautaportti <kai _at_ lautaportti.fi>
+-Paul Sowden <paul _at_ idontsmoke.co.uk>
+-Sebastian Thiel <byronimo _at_ gmail.com>
+-Jonathan Chu <jonathan.chu _at_ me.com>
+-Vincent Driessen <me _at_ nvie.com>
+-Phil Elson <pelson _dot_ pub _at_ gmail.com>
+-Bernard `Guyzmo` Pratz <guyzmo+gitpython+pub@m0g.net>
+-Timothy B. Hartman <tbhartman _at_ gmail.com>
+-Konstantin Popov <konstantin.popov.89 _at_ yandex.ru>
+-Peter Jones <pjones _at_ redhat.com>
+-Anson Mansfield <anson.mansfield _at_ gmail.com>
+-Ken Odegard <ken.odegard _at_ gmail.com>
+-Alexis Horgix Chotard
+-Piotr Babij <piotr.babij _at_ gmail.com>
+-Mikuláš Poul <mikulaspoul _at_ gmail.com>
+-Charles Bouchard-Légaré <cblegare.atl _at_ ntis.ca>
+-Yaroslav Halchenko <debian _at_ onerussian.com>
+-Tim Swast <swast _at_ google.com>
+-William Luc Ritchie
+-David Host <hostdm _at_ outlook.com>
+-A. Jesse Jiryu Davis <jesse _at_ emptysquare.net>
+-Steven Whitman <ninloot _at_ gmail.com>
+-Stefan Stancu <stefan.stancu _at_ gmail.com>
+-César Izurieta <cesar _at_ caih.org>
+-Arthur Milchior <arthur _at_ milchior.fr>
+-Anil Khatri <anil.soccer.khatri _at_ gmail.com>
+-JJ Graham <thetwoj _at_ gmail.com>
+-Ben Thayer <ben _at_ benthayer.com>
+-Dries Kennes <admin _at_ dries007.net>
+-Pratik Anurag <panurag247365 _at_ gmail.com>
+-Harmon <harmon.public _at_ gmail.com>
+-Liam Beguin <liambeguin _at_ gmail.com>
+-Ram Rachum <ram _at_ rachum.com>
+-Alba Mendez <me _at_ alba.sh>
+-Robert Westman <robert _at_ byteflux.io>
+-Hugo van Kemenade
+-Hiroki Tokunaga <tokusan441 _at_ gmail.com>
+-Julien Mauroy <pro.julien.mauroy _at_ gmail.com>
+-Patrick Gerard
+-Luke Twist <itsluketwist@gmail.com>
+-Joseph Hale <me _at_ jhale.dev>
+-Santos Gallegos <stsewd _at_ proton.me>
+-Wenhan Zhu <wzhu.cosmos _at_ gmail.com>
+-Eliah Kagan <eliah.kagan _at_ gmail.com>
+-Ethan Lin <et.repositories _at_ gmail.com>
+-Jonas Scharpf <jonas.scharpf _at_ checkmk.com>
+
+Portions derived from other open source works and are clearly marked.

myenv/Lib/site-packages/GitPython-3.1.44.dist-info/INSTALLER

@@ -0,0 +1 @@
+pip

myenv/Lib/site-packages/GitPython-3.1.44.dist-info/LICENSE

@@ -0,0 +1,29 @@
+Copyright (C) 2008, 2009 Michael Trier and contributors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+
+* Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright
+notice, this list of conditions and the following disclaimer in the
+documentation and/or other materials provided with the distribution.
+
+* Neither the name of the GitPython project nor the names of
+its contributors may be used to endorse or promote products derived
+from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
+TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

myenv/Lib/site-packages/GitPython-3.1.44.dist-info/METADATA

@@ -0,0 +1,295 @@
+Metadata-Version: 2.1
+Name: GitPython
+Version: 3.1.44
+Summary: GitPython is a Python library used to interact with Git repositories
+Home-page: https://github.com/gitpython-developers/GitPython
+Author: Sebastian Thiel, Michael Trier
+Author-email: byronimo@gmail.com, mtrier@gmail.com
+License: BSD-3-Clause
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Operating System :: OS Independent
+Classifier: Operating System :: POSIX
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Typing :: Typed
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+License-File: AUTHORS
+Requires-Dist: gitdb<5,>=4.0.1
+Requires-Dist: typing-extensions>=3.7.4.3; python_version < "3.8"
+Provides-Extra: test
+Requires-Dist: coverage[toml]; extra == "test"
+Requires-Dist: ddt!=1.4.3,>=1.1.1; extra == "test"
+Requires-Dist: mock; python_version < "3.8" and extra == "test"
+Requires-Dist: mypy; extra == "test"
+Requires-Dist: pre-commit; extra == "test"
+Requires-Dist: pytest>=7.3.1; extra == "test"
+Requires-Dist: pytest-cov; extra == "test"
+Requires-Dist: pytest-instafail; extra == "test"
+Requires-Dist: pytest-mock; extra == "test"
+Requires-Dist: pytest-sugar; extra == "test"
+Requires-Dist: typing-extensions; python_version < "3.11" and extra == "test"
+Provides-Extra: doc
+Requires-Dist: sphinx<7.2,>=7.1.2; extra == "doc"
+Requires-Dist: sphinx_rtd_theme; extra == "doc"
+Requires-Dist: sphinx-autodoc-typehints; extra == "doc"
+
+![Python package](https://github.com/gitpython-developers/GitPython/workflows/Python%20package/badge.svg)
+[![Documentation Status](https://readthedocs.org/projects/gitpython/badge/?version=stable)](https://readthedocs.org/projects/gitpython/?badge=stable)
+[![Packaging status](https://repology.org/badge/tiny-repos/python:gitpython.svg)](https://repology.org/metapackage/python:gitpython/versions)
+
+## [Gitoxide](https://github.com/Byron/gitoxide): A peek into the future…
+
+I started working on GitPython in 2009, back in the days when Python was 'my thing' and I had great plans with it.
+Of course, back in the days, I didn't really know what I was doing and this shows in many places. Somewhat similar to
+Python this happens to be 'good enough', but at the same time is deeply flawed and broken beyond repair.
+
+By now, GitPython is widely used and I am sure there is a good reason for that, it's something to be proud of and happy about.
+The community is maintaining the software and is keeping it relevant for which I am absolutely grateful. For the time to come I am happy to continue maintaining GitPython, remaining hopeful that one day it won't be needed anymore.
+
+More than 15 years after my first meeting with 'git' I am still in excited about it, and am happy to finally have the tools and
+probably the skills to scratch that itch of mine: implement `git` in a way that makes tool creation a piece of cake for most.
+
+If you like the idea and want to learn more, please head over to [gitoxide](https://github.com/Byron/gitoxide), an
+implementation of 'git' in [Rust](https://www.rust-lang.org).
+
+*(Please note that `gitoxide` is not currently available for use in Python, and that Rust is required.)*
+
+## GitPython
+
+GitPython is a python library used to interact with git repositories, high-level like git-porcelain,
+or low-level like git-plumbing.
+
+It provides abstractions of git objects for easy access of repository data often backed by calling the `git`
+command-line program.
+
+### DEVELOPMENT STATUS
+
+This project is in **maintenance mode**, which means that
+
+- …there will be no feature development, unless these are contributed
+- …there will be no bug fixes, unless they are relevant to the safety of users, or contributed
+- …issues will be responded to with waiting times of up to a month
+
+The project is open to contributions of all kinds, as well as new maintainers.
+
+### REQUIREMENTS
+
+GitPython needs the `git` executable to be installed on the system and available in your
+`PATH` for most operations. If it is not in your `PATH`, you can help GitPython find it
+by setting the `GIT_PYTHON_GIT_EXECUTABLE=<path/to/git>` environment variable.
+
+- Git (1.7.x or newer)
+- Python >= 3.7
+
+The list of dependencies are listed in `./requirements.txt` and `./test-requirements.txt`.
+The installer takes care of installing them for you.
+
+### INSTALL
+
+GitPython and its required package dependencies can be installed in any of the following ways, all of which should typically be done in a [virtual environment](https://docs.python.org/3/tutorial/venv.html).
+
+#### From PyPI
+
+To obtain and install a copy [from PyPI](https://pypi.org/project/GitPython/), run:
+
+```sh
+pip install GitPython
+```
+
+(A distribution package can also be downloaded for manual installation at [the PyPI page](https://pypi.org/project/GitPython/).)
+
+#### From downloaded source code
+
+If you have downloaded the source code, run this from inside the unpacked `GitPython` directory:
+
+```sh
+pip install .
+```
+
+#### By cloning the source code repository
+
+To clone the [the GitHub repository](https://github.com/gitpython-developers/GitPython) from source to work on the code, you can do it like so:
+
+```sh
+git clone https://github.com/gitpython-developers/GitPython
+cd GitPython
+./init-tests-after-clone.sh
+```
+
+On Windows, `./init-tests-after-clone.sh` can be run in a Git Bash shell.
+
+If you are cloning [your own fork](https://docs.github.com/en/pull-requests/collaborating-with-pull-requests/working-with-forks/about-forks), then replace the above `git clone` command with one that gives the URL of your fork. Or use this [`gh`](https://cli.github.com/) command (assuming you have `gh` and your fork is called `GitPython`):
+
+```sh
+gh repo clone GitPython
+```
+
+Having cloned the repo, create and activate your [virtual environment](https://docs.python.org/3/tutorial/venv.html).
+
+Then make an [editable install](https://pip.pypa.io/en/stable/topics/local-project-installs/#editable-installs):
+
+```sh
+pip install -e ".[test]"
+```
+
+In the less common case that you do not want to install test dependencies, `pip install -e .` can be used instead.
+
+#### With editable *dependencies* (not preferred, and rarely needed)
+
+In rare cases, you may want to work on GitPython and one or both of its [gitdb](https://github.com/gitpython-developers/gitdb) and [smmap](https://github.com/gitpython-developers/smmap) dependencies at the same time, with changes in your local working copy of gitdb or smmap immediately reflected in the behavior of your local working copy of GitPython. This can be done by making editable installations of those dependencies in the same virtual environment where you install GitPython.
+
+If you want to do that *and* you want the versions in GitPython's git submodules to be used, then pass `-e git/ext/gitdb` and/or `-e git/ext/gitdb/gitdb/ext/smmap` to `pip install`. This can be done in any order, and in separate `pip install` commands or the same one, so long as `-e` appears before *each* path. For example, you can install GitPython, gitdb, and smmap editably in the currently active virtual environment this way:
+
+```sh
+pip install -e ".[test]" -e git/ext/gitdb -e git/ext/gitdb/gitdb/ext/smmap
+```
+
+The submodules must have been cloned for that to work, but that will already be the case if you have run `./init-tests-after-clone.sh`. You can use `pip list` to check which packages are installed editably and which are installed normally.
+
+To reiterate, this approach should only rarely be used. For most development it is preferable to allow the gitdb and smmap dependencices to be retrieved automatically from PyPI in their latest stable packaged versions.
+
+### Limitations
+
+#### Leakage of System Resources
+
+GitPython is not suited for long-running processes (like daemons) as it tends to
+leak system resources. It was written in a time where destructors (as implemented
+in the `__del__` method) still ran deterministically.
+
+In case you still want to use it in such a context, you will want to search the
+codebase for `__del__` implementations and call these yourself when you see fit.
+
+Another way assure proper cleanup of resources is to factor out GitPython into a
+separate process which can be dropped periodically.
+
+#### Windows support
+
+See [Issue #525](https://github.com/gitpython-developers/GitPython/issues/525).
+
+### RUNNING TESTS
+
+_Important_: Right after cloning this repository, please be sure to have executed
+the `./init-tests-after-clone.sh` script in the repository root. Otherwise
+you will encounter test failures.
+
+#### Install test dependencies
+
+Ensure testing libraries are installed. This is taken care of already if you installed with:
+
+```sh
+pip install -e ".[test]"
+```
+
+If you had installed with a command like `pip install -e .` instead, you can still run
+the above command to add the testing dependencies.
+
+#### Test commands
+
+To test, run:
+
+```sh
+pytest
+```
+
+To lint, and apply some linting fixes as well as automatic code formatting, run:
+
+```sh
+pre-commit run --all-files
+```
+
+This includes the linting and autoformatting done by Ruff, as well as some other checks.
+
+To typecheck, run:
+
+```sh
+mypy
+```
+
+#### CI (and tox)
+
+Style and formatting checks, and running tests on all the different supported Python versions, will be performed:
+
+- Upon submitting a pull request.
+- On each push, *if* you have a fork with GitHub Actions enabled.
+- Locally, if you run [`tox`](https://tox.wiki/) (this skips any Python versions you don't have installed).
+
+#### Configuration files
+
+Specific tools are all configured in the `./pyproject.toml` file:
+
+- `pytest` (test runner)
+- `coverage.py` (code coverage)
+- `ruff` (linter and formatter)
+- `mypy` (type checker)
+
+Orchestration tools:
+
+- Configuration for `pre-commit` is in the `./.pre-commit-config.yaml` file.
+- Configuration for `tox` is in `./tox.ini`.
+- Configuration for GitHub Actions (CI) is in files inside `./.github/workflows/`.
+
+### Contributions
+
+Please have a look at the [contributions file][contributing].
+
+### INFRASTRUCTURE
+
+- [User Documentation](http://gitpython.readthedocs.org)
+- [Questions and Answers](http://stackexchange.com/filters/167317/gitpython)
+- Please post on Stack Overflow and use the `gitpython` tag
+- [Issue Tracker](https://github.com/gitpython-developers/GitPython/issues)
+  - Post reproducible bugs and feature requests as a new issue.
+    Please be sure to provide the following information if posting bugs:
+    - GitPython version (e.g. `import git; git.__version__`)
+    - Python version (e.g. `python --version`)
+    - The encountered stack-trace, if applicable
+    - Enough information to allow reproducing the issue
+
+### How to make a new release
+
+1. Update/verify the **version** in the `VERSION` file.
+2. Update/verify that the `doc/source/changes.rst` changelog file was updated. It should include a link to the forthcoming release page: `https://github.com/gitpython-developers/GitPython/releases/tag/<version>`
+3. Commit everything.
+4. Run `git tag -s <version>` to tag the version in Git.
+5. _Optionally_ create and activate a [virtual environment](https://packaging.python.org/en/latest/guides/installing-using-pip-and-virtual-environments/#creating-a-virtual-environment). (Then the next step can install `build` and `twine`.)
+6. Run `make release`.
+7. Go to [GitHub Releases](https://github.com/gitpython-developers/GitPython/releases) and publish a new one with the recently pushed tag. Generate the changelog.
+
+### Projects using GitPython
+
+- [PyDriller](https://github.com/ishepard/pydriller)
+- [Kivy Designer](https://github.com/kivy/kivy-designer)
+- [Prowl](https://github.com/nettitude/Prowl)
+- [Python Taint](https://github.com/python-security/pyt)
+- [Buster](https://github.com/axitkhurana/buster)
+- [git-ftp](https://github.com/ezyang/git-ftp)
+- [Git-Pandas](https://github.com/wdm0006/git-pandas)
+- [PyGitUp](https://github.com/msiemens/PyGitUp)
+- [PyJFuzz](https://github.com/mseclab/PyJFuzz)
+- [Loki](https://github.com/Neo23x0/Loki)
+- [Omniwallet](https://github.com/OmniLayer/omniwallet)
+- [GitViper](https://github.com/BeayemX/GitViper)
+- [Git Gud](https://github.com/bthayer2365/git-gud)
+
+### LICENSE
+
+[3-Clause BSD License](https://opensource.org/license/bsd-3-clause/), also known as the New BSD License. See the [LICENSE file][license].
+
+One file exclusively used for fuzz testing is subject to [a separate license, detailed here](./fuzzing/README.md#license).
+This file is not included in the wheel or sdist packages published by the maintainers of GitPython.
+
+[contributing]: https://github.com/gitpython-developers/GitPython/blob/main/CONTRIBUTING.md
+[license]: https://github.com/gitpython-developers/GitPython/blob/main/LICENSE

myenv/Lib/site-packages/GitPython-3.1.44.dist-info/RECORD

@@ -0,0 +1,82 @@
+GitPython-3.1.44.dist-info/AUTHORS,sha256=tZ9LuyBks2V2HKTPK7kCmtd9Guu_LyU1oZHvU0NiAok,2334
+GitPython-3.1.44.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+GitPython-3.1.44.dist-info/LICENSE,sha256=hvyUwyGpr7wRUUcTURuv3tIl8lEA3MD3NQ6CvCMbi-s,1503
+GitPython-3.1.44.dist-info/METADATA,sha256=0O_Fr2Y7A-DlPYhlbSxGjblBC2mWkw3USNUhyL80Ip8,13245
+GitPython-3.1.44.dist-info/RECORD,,
+GitPython-3.1.44.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+GitPython-3.1.44.dist-info/top_level.txt,sha256=0hzDuIp8obv624V3GmbqsagBWkk8ohtGU-Bc1PmTT0o,4
+git/__init__.py,sha256=nkQImgv-bWdiZOFDjzN-gbt93FoRHD0nY6_t9LQxy4Y,8899
+git/__pycache__/__init__.cpython-311.pyc,,
+git/__pycache__/cmd.cpython-311.pyc,,
+git/__pycache__/compat.cpython-311.pyc,,
+git/__pycache__/config.cpython-311.pyc,,
+git/__pycache__/db.cpython-311.pyc,,
+git/__pycache__/diff.cpython-311.pyc,,
+git/__pycache__/exc.cpython-311.pyc,,
+git/__pycache__/remote.cpython-311.pyc,,
+git/__pycache__/types.cpython-311.pyc,,
+git/__pycache__/util.cpython-311.pyc,,
+git/cmd.py,sha256=QwiaBy0mFbi9xjRKhRgUVK-_-K6xVdFqh9l0cxPqPSc,67724
+git/compat.py,sha256=y1E6y6O2q5r8clSlr8ZNmuIWG9nmHuehQEsVsmBffs8,4526
+git/config.py,sha256=vTUlK6d8ORqFqjOv4Vbq_Hm-5mp-jOAt1dkq0IdzJ3U,34933
+git/db.py,sha256=vIW9uWSbqu99zbuU2ZDmOhVOv1UPTmxrnqiCtRHCfjE,2368
+git/diff.py,sha256=wmpMCIdMiVOqreGVPOGYyO4gFboGOAicyrvvI7PPjEg,27095
+git/exc.py,sha256=Gc7g1pHpn8OmTse30NHmJVsBJ2CYH8LxaR8y8UA3lIM,7119
+git/index/__init__.py,sha256=i-Nqb8Lufp9aFbmxpQBORmmQnjEVVM1Pn58fsQkyGgQ,406
+git/index/__pycache__/__init__.cpython-311.pyc,,
+git/index/__pycache__/base.cpython-311.pyc,,
+git/index/__pycache__/fun.cpython-311.pyc,,
+git/index/__pycache__/typ.cpython-311.pyc,,
+git/index/__pycache__/util.cpython-311.pyc,,
+git/index/base.py,sha256=nDD7XVLNbgBKpJMrrTVyHBy6NVLWgDkk7oUw6ZOegPc,60808
+git/index/fun.py,sha256=37cA3DBC9vpAnSVu5TGA072SnoF5XZOkOukExwlejHs,16736
+git/index/typ.py,sha256=uuKNwitUw83FhVaLSwo4pY7PHDQudtZTLJrLGym4jcI,6570
+git/index/util.py,sha256=fULi7GPG-MvprKrRCD5c15GNdzku_1E38We0d97WB3A,3659
+git/objects/__init__.py,sha256=O6ZL_olX7e5-8iIbKviRPkVSJxN37WA-EC0q9d48U5Y,637
+git/objects/__pycache__/__init__.cpython-311.pyc,,
+git/objects/__pycache__/base.cpython-311.pyc,,
+git/objects/__pycache__/blob.cpython-311.pyc,,
+git/objects/__pycache__/commit.cpython-311.pyc,,
+git/objects/__pycache__/fun.cpython-311.pyc,,
+git/objects/__pycache__/tag.cpython-311.pyc,,
+git/objects/__pycache__/tree.cpython-311.pyc,,
+git/objects/__pycache__/util.cpython-311.pyc,,
+git/objects/base.py,sha256=0dqNkSRVH0mk0-7ZKIkGBK7iNYrzLTVxwQFUd6CagsE,10277
+git/objects/blob.py,sha256=zwwq0KfOMYeP5J2tW5CQatoLyeqFRlfkxP1Vwx1h07s,1215
+git/objects/commit.py,sha256=GH1_83C9t7RGTukwozTHDgvxYQPRjTHhPDkXJyBbJyo,30553
+git/objects/fun.py,sha256=B4jCqhAjm6Hl79GK58FPzW1H9K6Wc7Tx0rssyWmAcEE,8935
+git/objects/submodule/__init__.py,sha256=6xySp767LVz3UylWgUalntS_nGXRuVzXxDuFAv_Wc2c,303
+git/objects/submodule/__pycache__/__init__.cpython-311.pyc,,
+git/objects/submodule/__pycache__/base.cpython-311.pyc,,
+git/objects/submodule/__pycache__/root.cpython-311.pyc,,
+git/objects/submodule/__pycache__/util.cpython-311.pyc,,
+git/objects/submodule/base.py,sha256=MQ-2xV8JznGwy2hLQv1aeQNgAkhBhgc5tdtClFL3DmE,63901
+git/objects/submodule/root.py,sha256=5eTtYNHasqdPq6q0oDCPr7IaO6uAHL3b4DxMoiO2LhE,20246
+git/objects/submodule/util.py,sha256=sQqAYaiSJdFkZa9NlAuK_wTsMNiS-kkQnQjvIoJtc_o,3509
+git/objects/tag.py,sha256=jAGESnpmTEv-dLakPzheT5ILZFFArcItnXYqfxfDrgc,4441
+git/objects/tree.py,sha256=jJH888SHiP4dGzE-ra1yenQOyya_0C_MkHr06c1gHpM,13849
+git/objects/util.py,sha256=Nlza4zLgdPmr_Yasyvvs6c1rKtW_wMxI6wDmQpQ3ufw,23846
+git/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+git/refs/__init__.py,sha256=DWlJNnsx-4jM_E-VycbP-FZUdn6iWhjnH_uZ_pZXBro,509
+git/refs/__pycache__/__init__.cpython-311.pyc,,
+git/refs/__pycache__/head.cpython-311.pyc,,
+git/refs/__pycache__/log.cpython-311.pyc,,
+git/refs/__pycache__/reference.cpython-311.pyc,,
+git/refs/__pycache__/remote.cpython-311.pyc,,
+git/refs/__pycache__/symbolic.cpython-311.pyc,,
+git/refs/__pycache__/tag.cpython-311.pyc,,
+git/refs/head.py,sha256=SGa3N301HfAi79X6UR5Mcg7mO9TnCH3Bk549kHlJVaQ,10513
+git/refs/log.py,sha256=kXiuAgTo1DIuM_BfbDUk9gQ0YO-mutIMVdHv1_ES90o,12493
+git/refs/reference.py,sha256=l6mhF4YLSEwtjz6b9PpOQH-fkng7EYWMaJhkjn-2jXA,5630
+git/refs/remote.py,sha256=WwqV9T7BbYf3F_WZNUQivu9xktIIKGklCjDpwQrhD-A,2806
+git/refs/symbolic.py,sha256=c8zOwaqzcg-J-rGrpuWdvh8zwMvSUqAHghd4vJoYG_s,34552
+git/refs/tag.py,sha256=kgzV2vhpL4FD2TqHb0BJuMRAHgAvJF-TcoyWlaB-djQ,5010
+git/remote.py,sha256=pYn9dAlz-QwvNMWXD1M57pMPQitthOM86qTRK_cpTqU,46786
+git/repo/__init__.py,sha256=CILSVH36fX_WxVFSjD9o1WF5LgsNedPiJvSngKZqfVU,210
+git/repo/__pycache__/__init__.cpython-311.pyc,,
+git/repo/__pycache__/base.cpython-311.pyc,,
+git/repo/__pycache__/fun.cpython-311.pyc,,
+git/repo/base.py,sha256=0GU6nKNdT8SYjDI5Y5DeZ1zCEX3tHeq1VW2MSpne05g,59891
+git/repo/fun.py,sha256=HSGC0-rqeKKx9fDg7JyQyMZgIwUWn-FnSZR_gRGpG-E,13573
+git/types.py,sha256=MQzIDEOnoueXGsAJF_0MgUc_osH7Eu0Sw3DQofYzCVE,10272
+git/util.py,sha256=2uAv34zZ_827-zJ3-D5ACrVH-4Q4EO_KLUTH23zi2AI,43770

myenv/Lib/site-packages/GitPython-3.1.44.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (75.6.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

myenv/Lib/site-packages/GitPython-3.1.44.dist-info/top_level.txt

@@ -0,0 +1 @@
+git

myenv/Lib/site-packages/adodbapi/__init__.py

@@ -0,0 +1,81 @@
+"""adodbapi - A python DB API 2.0 (PEP 249) interface to Microsoft ADO
+
+Copyright (C) 2002 Henrik Ekelund, version 2.1 by Vernon Cole
+* http://sourceforge.net/projects/adodbapi
+"""
+
+import time
+
+# Re-exports to keep backward compatibility with existing code
+from .adodbapi import (
+    Connection as Connection,
+    Cursor as Cursor,
+    __version__,
+    connect as connect,
+    dateconverter,
+)
+from .apibase import (
+    BINARY as BINARY,
+    DATETIME as DATETIME,
+    NUMBER as NUMBER,
+    ROWID as ROWID,
+    STRING as STRING,
+    DatabaseError as DatabaseError,
+    DataError as DataError,
+    Error as Error,
+    FetchFailedError as FetchFailedError,
+    IntegrityError as IntegrityError,
+    InterfaceError as InterfaceError,
+    InternalError as InternalError,
+    NotSupportedError as NotSupportedError,
+    OperationalError as OperationalError,
+    ProgrammingError as ProgrammingError,
+    Warning as Warning,
+    apilevel as apilevel,
+    paramstyle as paramstyle,
+    threadsafety as threadsafety,
+)
+
+
+def Binary(aString):
+    """This function constructs an object capable of holding a binary (long) string value."""
+    return bytes(aString)
+
+
+def Date(year, month, day):
+    "This function constructs an object holding a date value."
+    return dateconverter.Date(year, month, day)
+
+
+def Time(hour, minute, second):
+    "This function constructs an object holding a time value."
+    return dateconverter.Time(hour, minute, second)
+
+
+def Timestamp(year, month, day, hour, minute, second):
+    "This function constructs an object holding a time stamp value."
+    return dateconverter.Timestamp(year, month, day, hour, minute, second)
+
+
+def DateFromTicks(ticks):
+    """This function constructs an object holding a date value from the given ticks value
+    (number of seconds since the epoch; see the documentation of the standard Python time module for details).
+    """
+    return Date(*time.gmtime(ticks)[:3])
+
+
+def TimeFromTicks(ticks):
+    """This function constructs an object holding a time value from the given ticks value
+    (number of seconds since the epoch; see the documentation of the standard Python time module for details).
+    """
+    return Time(*time.gmtime(ticks)[3:6])
+
+
+def TimestampFromTicks(ticks):
+    """This function constructs an object holding a time stamp value from the given
+    ticks value (number of seconds since the epoch;
+    see the documentation of the standard Python time module for details)."""
+    return Timestamp(*time.gmtime(ticks)[:6])
+
+
+version = "adodbapi v" + __version__

myenv/Lib/site-packages/adodbapi/ado_consts.py

@@ -0,0 +1,281 @@
+# ADO enumerated constants documented on MSDN:
+# http://msdn.microsoft.com/en-us/library/ms678353(VS.85).aspx
+
+# IsolationLevelEnum
+adXactUnspecified = -1
+adXactBrowse = 0x100
+adXactChaos = 0x10
+adXactCursorStability = 0x1000
+adXactIsolated = 0x100000
+adXactReadCommitted = 0x1000
+adXactReadUncommitted = 0x100
+adXactRepeatableRead = 0x10000
+adXactSerializable = 0x100000
+
+# CursorLocationEnum
+adUseClient = 3
+adUseServer = 2
+
+# CursorTypeEnum
+adOpenDynamic = 2
+adOpenForwardOnly = 0
+adOpenKeyset = 1
+adOpenStatic = 3
+adOpenUnspecified = -1
+
+# CommandTypeEnum
+adCmdText = 1
+adCmdStoredProc = 4
+adSchemaTables = 20
+
+# ParameterDirectionEnum
+adParamInput = 1
+adParamInputOutput = 3
+adParamOutput = 2
+adParamReturnValue = 4
+adParamUnknown = 0
+directions = {
+    0: "Unknown",
+    1: "Input",
+    2: "Output",
+    3: "InputOutput",
+    4: "Return",
+}
+
+
+def ado_direction_name(ado_dir):
+    try:
+        return "adParam" + directions[ado_dir]
+    except:
+        return f"unknown direction ({ado_dir})"
+
+
+# ObjectStateEnum
+adStateClosed = 0
+adStateOpen = 1
+adStateConnecting = 2
+adStateExecuting = 4
+adStateFetching = 8
+
+# FieldAttributeEnum
+adFldMayBeNull = 0x40
+
+# ConnectModeEnum
+adModeUnknown = 0
+adModeRead = 1
+adModeWrite = 2
+adModeReadWrite = 3
+adModeShareDenyRead = 4
+adModeShareDenyWrite = 8
+adModeShareExclusive = 12
+adModeShareDenyNone = 16
+adModeRecursive = 0x400000
+
+# XactAttributeEnum
+adXactCommitRetaining = 131072
+adXactAbortRetaining = 262144
+
+ado_error_TIMEOUT = -2147217871
+
+# DataTypeEnum - ADO Data types documented at:
+# http://msdn2.microsoft.com/en-us/library/ms675318.aspx
+adArray = 0x2000
+adEmpty = 0x0
+adBSTR = 0x8
+adBigInt = 0x14
+adBinary = 0x80
+adBoolean = 0xB
+adChapter = 0x88
+adChar = 0x81
+adCurrency = 0x6
+adDBDate = 0x85
+adDBTime = 0x86
+adDBTimeStamp = 0x87
+adDate = 0x7
+adDecimal = 0xE
+adDouble = 0x5
+adError = 0xA
+adFileTime = 0x40
+adGUID = 0x48
+adIDispatch = 0x9
+adIUnknown = 0xD
+adInteger = 0x3
+adLongVarBinary = 0xCD
+adLongVarChar = 0xC9
+adLongVarWChar = 0xCB
+adNumeric = 0x83
+adPropVariant = 0x8A
+adSingle = 0x4
+adSmallInt = 0x2
+adTinyInt = 0x10
+adUnsignedBigInt = 0x15
+adUnsignedInt = 0x13
+adUnsignedSmallInt = 0x12
+adUnsignedTinyInt = 0x11
+adUserDefined = 0x84
+adVarBinary = 0xCC
+adVarChar = 0xC8
+adVarNumeric = 0x8B
+adVarWChar = 0xCA
+adVariant = 0xC
+adWChar = 0x82
+# Additional constants used by introspection but not ADO itself
+AUTO_FIELD_MARKER = -1000
+
+adTypeNames = {
+    adBSTR: "adBSTR",
+    adBigInt: "adBigInt",
+    adBinary: "adBinary",
+    adBoolean: "adBoolean",
+    adChapter: "adChapter",
+    adChar: "adChar",
+    adCurrency: "adCurrency",
+    adDBDate: "adDBDate",
+    adDBTime: "adDBTime",
+    adDBTimeStamp: "adDBTimeStamp",
+    adDate: "adDate",
+    adDecimal: "adDecimal",
+    adDouble: "adDouble",
+    adEmpty: "adEmpty",
+    adError: "adError",
+    adFileTime: "adFileTime",
+    adGUID: "adGUID",
+    adIDispatch: "adIDispatch",
+    adIUnknown: "adIUnknown",
+    adInteger: "adInteger",
+    adLongVarBinary: "adLongVarBinary",
+    adLongVarChar: "adLongVarChar",
+    adLongVarWChar: "adLongVarWChar",
+    adNumeric: "adNumeric",
+    adPropVariant: "adPropVariant",
+    adSingle: "adSingle",
+    adSmallInt: "adSmallInt",
+    adTinyInt: "adTinyInt",
+    adUnsignedBigInt: "adUnsignedBigInt",
+    adUnsignedInt: "adUnsignedInt",
+    adUnsignedSmallInt: "adUnsignedSmallInt",
+    adUnsignedTinyInt: "adUnsignedTinyInt",
+    adUserDefined: "adUserDefined",
+    adVarBinary: "adVarBinary",
+    adVarChar: "adVarChar",
+    adVarNumeric: "adVarNumeric",
+    adVarWChar: "adVarWChar",
+    adVariant: "adVariant",
+    adWChar: "adWChar",
+}
+
+
+def ado_type_name(ado_type):
+    return adTypeNames.get(ado_type, f"unknown type ({ado_type})")
+
+
+# here in decimal, sorted by value
+# adEmpty 0 Specifies no value (DBTYPE_EMPTY).
+# adSmallInt 2 Indicates a two-byte signed integer (DBTYPE_I2).
+# adInteger 3 Indicates a four-byte signed integer (DBTYPE_I4).
+# adSingle 4 Indicates a single-precision floating-point value (DBTYPE_R4).
+# adDouble 5 Indicates a double-precision floating-point value (DBTYPE_R8).
+# adCurrency 6 Indicates a currency value (DBTYPE_CY). Currency is a fixed-point number
+#   with four digits to the right of the decimal point. It is stored in an eight-byte signed integer scaled by 10,000.
+# adDate 7 Indicates a date value (DBTYPE_DATE). A date is stored as a double, the whole part of which is
+#   the number of days since December 30, 1899, and the fractional part of which is the fraction of a day.
+# adBSTR 8 Indicates a null-terminated character string (Unicode) (DBTYPE_BSTR).
+# adIDispatch 9 Indicates a pointer to an IDispatch interface on a COM object (DBTYPE_IDISPATCH).
+# adError 10 Indicates a 32-bit error code (DBTYPE_ERROR).
+# adBoolean 11 Indicates a boolean value (DBTYPE_BOOL).
+# adVariant 12 Indicates an Automation Variant (DBTYPE_VARIANT).
+# adIUnknown 13 Indicates a pointer to an IUnknown interface on a COM object (DBTYPE_IUNKNOWN).
+# adDecimal 14 Indicates an exact numeric value with a fixed precision and scale (DBTYPE_DECIMAL).
+# adTinyInt 16 Indicates a one-byte signed integer (DBTYPE_I1).
+# adUnsignedTinyInt 17 Indicates a one-byte unsigned integer (DBTYPE_UI1).
+# adUnsignedSmallInt 18 Indicates a two-byte unsigned integer (DBTYPE_UI2).
+# adUnsignedInt 19 Indicates a four-byte unsigned integer (DBTYPE_UI4).
+# adBigInt 20 Indicates an eight-byte signed integer (DBTYPE_I8).
+# adUnsignedBigInt 21 Indicates an eight-byte unsigned integer (DBTYPE_UI8).
+# adFileTime 64 Indicates a 64-bit value representing the number of 100-nanosecond intervals since
+#    January 1, 1601 (DBTYPE_FILETIME).
+# adGUID 72 Indicates a globally unique identifier (GUID) (DBTYPE_GUID).
+# adBinary 128 Indicates a binary value (DBTYPE_BYTES).
+# adChar 129 Indicates a string value (DBTYPE_STR).
+# adWChar 130 Indicates a null-terminated Unicode character string (DBTYPE_WSTR).
+# adNumeric 131 Indicates an exact numeric value with a fixed precision and scale (DBTYPE_NUMERIC).
+#   adUserDefined 132 Indicates a user-defined variable (DBTYPE_UDT).
+# adUserDefined 132 Indicates a user-defined variable (DBTYPE_UDT).
+# adDBDate 133 Indicates a date value (yyyymmdd) (DBTYPE_DBDATE).
+# adDBTime 134 Indicates a time value (hhmmss) (DBTYPE_DBTIME).
+# adDBTimeStamp 135 Indicates a date/time stamp (yyyymmddhhmmss plus a fraction in billionths) (DBTYPE_DBTIMESTAMP).
+# adChapter 136 Indicates a four-byte chapter value that identifies rows in a child rowset (DBTYPE_HCHAPTER).
+# adPropVariant 138 Indicates an Automation PROPVARIANT (DBTYPE_PROP_VARIANT).
+# adVarNumeric 139 Indicates a numeric value (Parameter object only).
+# adVarChar 200 Indicates a string value (Parameter object only).
+# adLongVarChar 201 Indicates a long string value (Parameter object only).
+# adVarWChar 202 Indicates a null-terminated Unicode character string (Parameter object only).
+# adLongVarWChar 203 Indicates a long null-terminated Unicode string value (Parameter object only).
+# adVarBinary 204 Indicates a binary value (Parameter object only).
+# adLongVarBinary 205 Indicates a long binary value (Parameter object only).
+# adArray (Does not apply to ADOX.) 0x2000 A flag value, always combined with another data type constant,
+#   that indicates an array of that other data type.
+
+# Error codes to names
+adoErrors = {
+    0xE7B: "adErrBoundToCommand",
+    0xE94: "adErrCannotComplete",
+    0xEA4: "adErrCantChangeConnection",
+    0xC94: "adErrCantChangeProvider",
+    0xE8C: "adErrCantConvertvalue",
+    0xE8D: "adErrCantCreate",
+    0xEA3: "adErrCatalogNotSet",
+    0xE8E: "adErrColumnNotOnThisRow",
+    0xD5D: "adErrDataConversion",
+    0xE89: "adErrDataOverflow",
+    0xE9A: "adErrDelResOutOfScope",
+    0xEA6: "adErrDenyNotSupported",
+    0xEA7: "adErrDenyTypeNotSupported",
+    0xCB3: "adErrFeatureNotAvailable",
+    0xEA5: "adErrFieldsUpdateFailed",
+    0xC93: "adErrIllegalOperation",
+    0xCAE: "adErrInTransaction",
+    0xE87: "adErrIntegrityViolation",
+    0xBB9: "adErrInvalidArgument",
+    0xE7D: "adErrInvalidConnection",
+    0xE7C: "adErrInvalidParamInfo",
+    0xE82: "adErrInvalidTransaction",
+    0xE91: "adErrInvalidURL",
+    0xCC1: "adErrItemNotFound",
+    0xBCD: "adErrNoCurrentRecord",
+    0xE83: "adErrNotExecuting",
+    0xE7E: "adErrNotReentrant",
+    0xE78: "adErrObjectClosed",
+    0xD27: "adErrObjectInCollection",
+    0xD5C: "adErrObjectNotSet",
+    0xE79: "adErrObjectOpen",
+    0xBBA: "adErrOpeningFile",
+    0xE80: "adErrOperationCancelled",
+    0xE96: "adErrOutOfSpace",
+    0xE88: "adErrPermissionDenied",
+    0xE9E: "adErrPropConflicting",
+    0xE9B: "adErrPropInvalidColumn",
+    0xE9C: "adErrPropInvalidOption",
+    0xE9D: "adErrPropInvalidValue",
+    0xE9F: "adErrPropNotAllSettable",
+    0xEA0: "adErrPropNotSet",
+    0xEA1: "adErrPropNotSettable",
+    0xEA2: "adErrPropNotSupported",
+    0xBB8: "adErrProviderFailed",
+    0xE7A: "adErrProviderNotFound",
+    0xBBB: "adErrReadFile",
+    0xE93: "adErrResourceExists",
+    0xE92: "adErrResourceLocked",
+    0xE97: "adErrResourceOutOfScope",
+    0xE8A: "adErrSchemaViolation",
+    0xE8B: "adErrSignMismatch",
+    0xE81: "adErrStillConnecting",
+    0xE7F: "adErrStillExecuting",
+    0xE90: "adErrTreePermissionDenied",
+    0xE8F: "adErrURLDoesNotExist",
+    0xE99: "adErrURLNamedRowDoesNotExist",
+    0xE98: "adErrUnavailable",
+    0xE84: "adErrUnsafeOperation",
+    0xE95: "adErrVolumeNotFound",
+    0xBBC: "adErrWriteFile",
+}

myenv/Lib/site-packages/adodbapi/adodbapi.py

@@ -0,0 +1,1157 @@
+"""adodbapi - A python DB API 2.0 (PEP 249) interface to Microsoft ADO
+
+Copyright (C) 2002 Henrik Ekelund, versions 2.1 and later by Vernon Cole
+* http://sourceforge.net/projects/pywin32
+* https://github.com/mhammond/pywin32
+* http://sourceforge.net/projects/adodbapi
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+    django adaptations and refactoring by Adam Vandenberg
+
+DB-API 2.0 specification: http://www.python.org/dev/peps/pep-0249/
+
+This module source should run correctly in CPython versions 2.7 and later,
+or CPython 3.4 or later.
+"""
+
+__version__ = "2.6.2.0"
+version = "adodbapi v" + __version__
+
+import copy
+import decimal
+import os
+import sys
+import weakref
+
+from . import ado_consts as adc, apibase as api, process_connect_string
+
+try:
+    verbose = int(os.environ["ADODBAPI_VERBOSE"])
+except:
+    verbose = False
+if verbose:
+    print(version)
+
+try:
+    import pythoncom
+    import pywintypes
+    from win32com.client import Dispatch
+except ImportError:
+    import warnings
+
+    warnings.warn("pywin32 package required for adodbapi.", ImportWarning)
+
+
+def getIndexedValue(obj, index):
+    return obj(index)
+
+
+from collections.abc import Mapping
+
+
+# -----------------  The .connect method -----------------
+def make_COM_connecter():
+    try:
+        pythoncom.CoInitialize()  # v2.1 Paj
+        c = Dispatch("ADODB.Connection")  # connect _after_ CoIninialize v2.1.1 adamvan
+    except:
+        raise api.InterfaceError(
+            "Windows COM Error: Dispatch('ADODB.Connection') failed."
+        )
+    return c
+
+
+def connect(*args, **kwargs):  # --> a db-api connection object
+    """Connect to a database.
+
+    call using:
+    :connection_string -- An ADODB formatted connection string, see:
+         * http://www.connectionstrings.com
+         * http://www.asp101.com/articles/john/connstring/default.asp
+    :timeout -- A command timeout value, in seconds (default 30 seconds)
+    """
+    co = Connection()  # make an empty connection object
+
+    kwargs = process_connect_string.process(args, kwargs, True)
+
+    try:  # connect to the database, using the connection information in kwargs
+        co.connect(kwargs)
+        return co
+    except Exception as e:
+        message = 'Error opening connection to "%s"' % co.connection_string
+        raise api.OperationalError(e, message)
+
+
+# so you could use something like:
+#   myConnection.paramstyle = 'named'
+# The programmer may also change the default.
+#   For example, if I were using django, I would say:
+#     import adodbapi as Database
+#     Database.adodbapi.paramstyle = 'format'
+
+# ------- other module level defaults --------
+defaultIsolationLevel = adc.adXactReadCommitted
+#  Set defaultIsolationLevel on module level before creating the connection.
+#   For example:
+#   import adodbapi, ado_consts
+#   adodbapi.adodbapi.defaultIsolationLevel=ado_consts.adXactBrowse"
+#
+#  Set defaultCursorLocation on module level before creating the connection.
+# It may be one of the "adUse..." consts.
+defaultCursorLocation = adc.adUseClient  # changed from adUseServer as of v 2.3.0
+
+dateconverter = api.pythonDateTimeConverter()  # default
+
+
+def format_parameters(ADOparameters, show_value=False):
+    """Format a collection of ADO Command Parameters.
+
+    Used by error reporting in _execute_command.
+    """
+    try:
+        if show_value:
+            desc = [
+                'Name: %s, Dir.: %s, Type: %s, Size: %s, Value: "%s", Precision: %s, NumericScale: %s'
+                % (
+                    p.Name,
+                    adc.directions[p.Direction],
+                    adc.adTypeNames.get(p.Type, str(p.Type) + " (unknown type)"),
+                    p.Size,
+                    p.Value,
+                    p.Precision,
+                    p.NumericScale,
+                )
+                for p in ADOparameters
+            ]
+        else:
+            desc = [
+                "Name: %s, Dir.: %s, Type: %s, Size: %s, Precision: %s, NumericScale: %s"
+                % (
+                    p.Name,
+                    adc.directions[p.Direction],
+                    adc.adTypeNames.get(p.Type, str(p.Type) + " (unknown type)"),
+                    p.Size,
+                    p.Precision,
+                    p.NumericScale,
+                )
+                for p in ADOparameters
+            ]
+        return "[" + "\n".join(desc) + "]"
+    except:
+        return "[]"
+
+
+def _configure_parameter(p, value, adotype, settings_known):
+    """Configure the given ADO Parameter 'p' with the Python 'value'."""
+
+    if adotype in api.adoBinaryTypes:
+        p.Size = len(value)
+        p.AppendChunk(value)
+
+    elif isinstance(value, str):  # v2.1 Jevon
+        L = len(value)
+        if adotype in api.adoStringTypes:  # v2.2.1 Cole
+            if settings_known:
+                L = min(L, p.Size)  # v2.1 Cole limit data to defined size
+            p.Value = value[:L]  # v2.1 Jevon & v2.1 Cole
+        else:
+            p.Value = value  # don't limit if db column is numeric
+        if L > 0:  # v2.1 Cole something does not like p.Size as Zero
+            p.Size = L  # v2.1 Jevon
+
+    elif isinstance(value, decimal.Decimal):
+        p.Value = value
+        exponent = value.as_tuple()[2]
+        digit_count = len(value.as_tuple()[1])
+        p.Precision = digit_count
+        if exponent == 0:
+            p.NumericScale = 0
+        elif exponent < 0:
+            p.NumericScale = -exponent
+            if p.Precision < p.NumericScale:
+                p.Precision = p.NumericScale
+        else:  # exponent > 0:
+            p.NumericScale = 0
+            p.Precision = digit_count + exponent
+
+    elif type(value) in dateconverter.types:
+        if settings_known and adotype in api.adoDateTimeTypes:
+            p.Value = dateconverter.COMDate(value)
+        else:  # probably a string
+            # provide the date as a string in the format 'YYYY-MM-dd'
+            s = dateconverter.DateObjectToIsoFormatString(value)
+            p.Value = s
+            p.Size = len(s)
+
+    elif adotype == adc.adEmpty:  # ADO will not let you specify a null column
+        p.Type = (
+            adc.adInteger
+        )  # so we will fake it to be an integer (just to have something)
+        p.Value = None  # and pass in a Null *value*
+
+        # For any other type, set the value and let pythoncom do the right thing.
+    else:
+        p.Value = value
+
+
+# # # # # ----- the Class that defines a connection ----- # # # # #
+class Connection:
+    # include connection attributes as class attributes required by api definition.
+    Warning = api.Warning
+    Error = api.Error
+    InterfaceError = api.InterfaceError
+    DataError = api.DataError
+    DatabaseError = api.DatabaseError
+    OperationalError = api.OperationalError
+    IntegrityError = api.IntegrityError
+    InternalError = api.InternalError
+    NotSupportedError = api.NotSupportedError
+    ProgrammingError = api.ProgrammingError
+    FetchFailedError = api.FetchFailedError  # (special for django)
+    # ...class attributes... (can be overridden by instance attributes)
+    verbose = api.verbose
+
+    @property
+    def dbapi(self):  # a proposed db-api version 3 extension.
+        "Return a reference to the DBAPI module for this Connection."
+        return api
+
+    def __init__(self):  # now define the instance attributes
+        self.connector = None
+        self.paramstyle = api.paramstyle
+        self.supportsTransactions = False
+        self.connection_string = ""
+        self.cursors = weakref.WeakValueDictionary()
+        self.dbms_name = ""
+        self.dbms_version = ""
+        self.errorhandler = None  # use the standard error handler for this instance
+        self.transaction_level = 0  # 0 == Not in a transaction, at the top level
+        self._autocommit = False
+
+    def connect(self, kwargs, connection_maker=make_COM_connecter):
+        if verbose > 9:
+            print(f"kwargs={kwargs!r}")
+        try:
+            self.connection_string = (
+                kwargs["connection_string"] % kwargs
+            )  # insert keyword arguments
+        except Exception as e:
+            self._raiseConnectionError(
+                KeyError, "Python string format error in connection string->"
+            )
+        self.timeout = kwargs.get("timeout", 30)
+        self.mode = kwargs.get("mode", adc.adModeUnknown)
+        self.kwargs = kwargs
+        if verbose:
+            print('%s attempting: "%s"' % (version, self.connection_string))
+        self.connector = connection_maker()
+        self.connector.ConnectionTimeout = self.timeout
+        self.connector.ConnectionString = self.connection_string
+        self.connector.Mode = self.mode
+
+        try:
+            self.connector.Open()  # Open the ADO connection
+        except api.Error:
+            self._raiseConnectionError(
+                api.DatabaseError,
+                "ADO error trying to Open=%s" % self.connection_string,
+            )
+
+        try:  # Stefan Fuchs; support WINCCOLEDBProvider
+            if getIndexedValue(self.connector.Properties, "Transaction DDL").Value != 0:
+                self.supportsTransactions = True
+        except pywintypes.com_error:
+            pass  # Stefan Fuchs
+        self.dbms_name = getIndexedValue(self.connector.Properties, "DBMS Name").Value
+        try:  # Stefan Fuchs
+            self.dbms_version = getIndexedValue(
+                self.connector.Properties, "DBMS Version"
+            ).Value
+        except pywintypes.com_error:
+            pass  # Stefan Fuchs
+        self.connector.CursorLocation = defaultCursorLocation  # v2.1 Rose
+        if self.supportsTransactions:
+            self.connector.IsolationLevel = defaultIsolationLevel
+            self._autocommit = bool(kwargs.get("autocommit", False))
+            if not self._autocommit:
+                self.transaction_level = (
+                    self.connector.BeginTrans()
+                )  # Disables autocommit & inits transaction_level
+        else:
+            self._autocommit = True
+        if "paramstyle" in kwargs:
+            self.paramstyle = kwargs["paramstyle"]  # let setattr do the error checking
+        self.messages = []
+        if verbose:
+            print("adodbapi New connection at %X" % id(self))
+
+    def _raiseConnectionError(self, errorclass, errorvalue):
+        eh = self.errorhandler
+        if eh is None:
+            eh = api.standardErrorHandler
+        eh(self, None, errorclass, errorvalue)
+
+    def _closeAdoConnection(self):  # all v2.1 Rose
+        """close the underlying ADO Connection object,
+        rolling it back first if it supports transactions."""
+        if self.connector is None:
+            return
+        if not self._autocommit:
+            if self.transaction_level:
+                try:
+                    self.connector.RollbackTrans()
+                except:
+                    pass
+        self.connector.Close()
+        if verbose:
+            print("adodbapi Closed connection at %X" % id(self))
+
+    def close(self):
+        """Close the connection now (rather than whenever __del__ is called).
+
+        The connection will be unusable from this point forward;
+        an Error (or subclass) exception will be raised if any operation is attempted with the connection.
+        The same applies to all cursor objects trying to use the connection.
+        """
+        for crsr in list(self.cursors.values())[
+            :
+        ]:  # copy the list, then close each one
+            crsr.close(dont_tell_me=True)  # close without back-link clearing
+        self.messages = []
+        try:
+            self._closeAdoConnection()  # v2.1 Rose
+        except Exception as e:
+            self._raiseConnectionError(sys.exc_info()[0], sys.exc_info()[1])
+
+        self.connector = None  # v2.4.2.2 fix subtle timeout bug
+        # per M.Hammond: "I expect the benefits of uninitializing are probably fairly small,
+        #    so never uninitializing will probably not cause any problems."
+
+    def commit(self):
+        """Commit any pending transaction to the database.
+
+        Note that if the database supports an auto-commit feature,
+        this must be initially off. An interface method may be provided to turn it back on.
+        Database modules that do not support transactions should implement this method with void functionality.
+        """
+        self.messages = []
+        if not self.supportsTransactions:
+            return
+
+        try:
+            self.transaction_level = self.connector.CommitTrans()
+            if verbose > 1:
+                print("commit done on connection at %X" % id(self))
+            if not (
+                self._autocommit
+                or (self.connector.Attributes & adc.adXactAbortRetaining)
+            ):
+                # If attributes has adXactCommitRetaining it performs retaining commits that is,
+                # calling CommitTrans automatically starts a new transaction. Not all providers support this.
+                # If not, we will have to start a new transaction by this command:
+                self.transaction_level = self.connector.BeginTrans()
+        except Exception as e:
+            self._raiseConnectionError(api.ProgrammingError, e)
+
+    def _rollback(self):
+        """In case a database does provide transactions this method causes the the database to roll back to
+        the start of any pending transaction. Closing a connection without committing the changes first will
+        cause an implicit rollback to be performed.
+
+        If the database does not support the functionality required by the method, the interface should
+        throw an exception in case the method is used.
+        The preferred approach is to not implement the method and thus have Python generate
+        an AttributeError in case the method is requested. This allows the programmer to check for database
+        capabilities using the standard hasattr() function.
+
+        For some dynamically configured interfaces it may not be appropriate to require dynamically making
+        the method available. These interfaces should then raise a NotSupportedError to indicate the
+        non-ability to perform the roll back when the method is invoked.
+        """
+        self.messages = []
+        if (
+            self.transaction_level
+        ):  # trying to roll back with no open transaction causes an error
+            try:
+                self.transaction_level = self.connector.RollbackTrans()
+                if verbose > 1:
+                    print("rollback done on connection at %X" % id(self))
+                if not self._autocommit and not (
+                    self.connector.Attributes & adc.adXactAbortRetaining
+                ):
+                    # If attributes has adXactAbortRetaining it performs retaining aborts that is,
+                    # calling RollbackTrans automatically starts a new transaction. Not all providers support this.
+                    # If not, we will have to start a new transaction by this command:
+                    if (
+                        not self.transaction_level
+                    ):  # if self.transaction_level == 0 or self.transaction_level is None:
+                        self.transaction_level = self.connector.BeginTrans()
+            except Exception as e:
+                self._raiseConnectionError(api.ProgrammingError, e)
+
+    def __setattr__(self, name, value):
+        if name == "autocommit":  # extension: allow user to turn autocommit on or off
+            if self.supportsTransactions:
+                object.__setattr__(self, "_autocommit", bool(value))
+                try:
+                    self._rollback()  # must clear any outstanding transactions
+                except:
+                    pass
+            return
+        elif name == "paramstyle":
+            if value not in api.accepted_paramstyles:
+                self._raiseConnectionError(
+                    api.NotSupportedError,
+                    f"paramstyle={value!r} not in:{api.accepted_paramstyles!r}",
+                )
+        elif name == "variantConversions":
+            # make a new copy -- no changes in the default, please
+            value = copy.copy(value)
+        object.__setattr__(self, name, value)
+
+    def __getattr__(self, item):
+        if (
+            item == "rollback"
+        ):  # the rollback method only appears if the database supports transactions
+            if self.supportsTransactions:
+                return (
+                    self._rollback
+                )  # return the rollback method so the caller can execute it.
+            else:
+                raise AttributeError("this data provider does not support Rollback")
+        elif item == "autocommit":
+            return self._autocommit
+        else:
+            raise AttributeError(
+                'no such attribute in ADO connection object as="%s"' % item
+            )
+
+    def cursor(self):
+        "Return a new Cursor Object using the connection."
+        self.messages = []
+        c = Cursor(self)
+        return c
+
+    def _i_am_here(self, crsr):
+        "message from a new cursor proclaiming its existence"
+        oid = id(crsr)
+        self.cursors[oid] = crsr
+
+    def _i_am_closing(self, crsr):
+        "message from a cursor giving connection a chance to clean up"
+        try:
+            del self.cursors[id(crsr)]
+        except:
+            pass
+
+    def printADOerrors(self):
+        j = self.connector.Errors.Count
+        if j:
+            print("ADO Errors:(%i)" % j)
+        for e in self.connector.Errors:
+            print("Description: %s" % e.Description)
+            print("Error: %s %s " % (e.Number, adc.adoErrors.get(e.Number, "unknown")))
+            if e.Number == adc.ado_error_TIMEOUT:
+                print(
+                    "Timeout Error: Try using adodbpi.connect(constr,timeout=Nseconds)"
+                )
+            print("Source: %s" % e.Source)
+            print("NativeError: %s" % e.NativeError)
+            print("SQL State: %s" % e.SQLState)
+
+    def _suggest_error_class(self):
+        """Introspect the current ADO Errors and determine an appropriate error class.
+
+        Error.SQLState is a SQL-defined error condition, per the SQL specification:
+        http://www.contrib.andrew.cmu.edu/~shadow/sql/sql1992.txt
+
+        The 23000 class of errors are integrity errors.
+        Error 40002 is a transactional integrity error.
+        """
+        if self.connector is not None:
+            for e in self.connector.Errors:
+                state = str(e.SQLState)
+                if state.startswith("23") or state == "40002":
+                    return api.IntegrityError
+        return api.DatabaseError
+
+    def __del__(self):
+        try:
+            self._closeAdoConnection()  # v2.1 Rose
+        except:
+            pass
+        self.connector = None
+
+    def __enter__(self):  # Connections are context managers
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        if exc_type:
+            self._rollback()  # automatic rollback on errors
+        else:
+            self.commit()
+
+    def get_table_names(self):
+        schema = self.connector.OpenSchema(20)  # constant = adSchemaTables
+
+        tables = []
+        while not schema.EOF:
+            name = getIndexedValue(schema.Fields, "TABLE_NAME").Value
+            tables.append(name)
+            schema.MoveNext()
+        del schema
+        return tables
+
+
+# # # # # ----- the Class that defines a cursor ----- # # # # #
+class Cursor:
+    ## ** api required attributes:
+    ## description...
+    ##    This read-only attribute is a sequence of 7-item sequences.
+    ##    Each of these sequences contains information describing one result column:
+    ##        (name, type_code, display_size, internal_size, precision, scale, null_ok).
+    ##    This attribute will be None for operations that do not return rows or if the
+    ##    cursor has not had an operation invoked via the executeXXX() method yet.
+    ##    The type_code can be interpreted by comparing it to the Type Objects specified in the section below.
+    ## rowcount...
+    ##    This read-only attribute specifies the number of rows that the last executeXXX() produced
+    ##    (for DQL statements like select) or affected (for DML statements like update or insert).
+    ##    The attribute is -1 in case no executeXXX() has been performed on the cursor or
+    ##    the rowcount of the last operation is not determinable by the interface.[7]
+    ## arraysize...
+    ##    This read/write attribute specifies the number of rows to fetch at a time with fetchmany().
+    ##    It defaults to 1 meaning to fetch a single row at a time.
+    ##    Implementations must observe this value with respect to the fetchmany() method,
+    ##    but are free to interact with the database a single row at a time.
+    ##    It may also be used in the implementation of executemany().
+    ## ** extension attributes:
+    ## paramstyle...
+    ##   allows the programmer to override the connection's default paramstyle
+    ## errorhandler...
+    ##   allows the programmer to override the connection's default error handler
+
+    def __init__(self, connection):
+        self.command = None
+        self._ado_prepared = False
+        self.messages = []
+        self.connection = connection
+        self.paramstyle = connection.paramstyle  # used for overriding the paramstyle
+        self._parameter_names = []
+        self.recordset_is_remote = False
+        self.rs = None  # the ADO recordset for this cursor
+        self.converters = []  # conversion function for each column
+        self.columnNames = {}  # names of columns {lowercase name : number,...}
+        self.numberOfColumns = 0
+        self._description = None
+        self.rowcount = -1
+        self.errorhandler = connection.errorhandler
+        self.arraysize = 1
+        connection._i_am_here(self)
+        if verbose:
+            print(
+                "%s New cursor at %X on conn %X"
+                % (version, id(self), id(self.connection))
+            )
+
+    def __iter__(self):  # [2.1 Zamarev]
+        return iter(self.fetchone, None)  # [2.1 Zamarev]
+
+    def prepare(self, operation):
+        self.command = operation
+        self._description = None
+        self._ado_prepared = "setup"
+
+    def __next__(self):
+        r = self.fetchone()
+        if r:
+            return r
+        raise StopIteration
+
+    def __enter__(self):
+        "Allow database cursors to be used with context managers."
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        "Allow database cursors to be used with context managers."
+        self.close()
+
+    def _raiseCursorError(self, errorclass, errorvalue):
+        eh = self.errorhandler
+        if eh is None:
+            eh = api.standardErrorHandler
+        eh(self.connection, self, errorclass, errorvalue)
+
+    def build_column_info(self, recordset):
+        self.converters = []  # convertion function for each column
+        self.columnNames = {}  # names of columns {lowercase name : number,...}
+        self._description = None
+
+        # if EOF and BOF are true at the same time, there are no records in the recordset
+        if (recordset is None) or (recordset.State == adc.adStateClosed):
+            self.rs = None
+            self.numberOfColumns = 0
+            return
+        self.rs = recordset  # v2.1.1 bkline
+        self.recordset_format = api.RS_WIN_32
+        self.numberOfColumns = recordset.Fields.Count
+        try:
+            varCon = self.connection.variantConversions
+        except AttributeError:
+            varCon = api.variantConversions
+        for i in range(self.numberOfColumns):
+            f = getIndexedValue(self.rs.Fields, i)
+            try:
+                self.converters.append(
+                    varCon[f.Type]
+                )  # conversion function for this column
+            except KeyError:
+                self._raiseCursorError(
+                    api.InternalError, "Data column of Unknown ADO type=%s" % f.Type
+                )
+            self.columnNames[f.Name.lower()] = i  # columnNames lookup
+
+    def _makeDescriptionFromRS(self):
+        # Abort if closed or no recordset.
+        if self.rs is None:
+            self._description = None
+            return
+        desc = []
+        for i in range(self.numberOfColumns):
+            f = getIndexedValue(self.rs.Fields, i)
+            if self.rs.EOF or self.rs.BOF:
+                display_size = None
+            else:
+                display_size = (
+                    f.ActualSize
+                )  # TODO: Is this the correct defintion according to the DB API 2 Spec ?
+            null_ok = bool(f.Attributes & adc.adFldMayBeNull)  # v2.1 Cole
+            desc.append(
+                (
+                    f.Name,
+                    f.Type,
+                    display_size,
+                    f.DefinedSize,
+                    f.Precision,
+                    f.NumericScale,
+                    null_ok,
+                )
+            )
+        self._description = desc
+
+    def get_description(self):
+        if not self._description:
+            self._makeDescriptionFromRS()
+        return self._description
+
+    def __getattr__(self, item):
+        if item == "description":
+            return self.get_description()
+        object.__getattribute__(
+            self, item
+        )  # may get here on Remote attribute calls for existing attributes
+
+    def format_description(self, d):
+        """Format db_api description tuple for printing."""
+        if self.description is None:
+            self._makeDescriptionFromRS()
+        if isinstance(d, int):
+            d = self.description[d]
+        desc = (
+            "Name= %s, Type= %s, DispSize= %s, IntSize= %s, Precision= %s, Scale= %s NullOK=%s"
+            % (
+                d[0],
+                adc.adTypeNames.get(d[1], str(d[1]) + " (unknown type)"),
+                d[2],
+                d[3],
+                d[4],
+                d[5],
+                d[6],
+            )
+        )
+        return desc
+
+    def close(self, dont_tell_me=False):
+        """Close the cursor now (rather than whenever __del__ is called).
+        The cursor will be unusable from this point forward; an Error (or subclass)
+        exception will be raised if any operation is attempted with the cursor.
+        """
+        if self.connection is None:
+            return
+        self.messages = []
+        if (
+            self.rs and self.rs.State != adc.adStateClosed
+        ):  # rs exists and is open      #v2.1 Rose
+            self.rs.Close()  # v2.1 Rose
+            self.rs = None  # let go of the recordset so ADO will let it be disposed #v2.1 Rose
+        if not dont_tell_me:
+            self.connection._i_am_closing(
+                self
+            )  # take me off the connection's cursors list
+        self.connection = (
+            None  # this will make all future method calls on me throw an exception
+        )
+        if verbose:
+            print("adodbapi Closed cursor at %X" % id(self))
+
+    def __del__(self):
+        try:
+            self.close()
+        except:
+            pass
+
+    def _new_command(self, command_type=adc.adCmdText):
+        self.cmd = None
+        self.messages = []
+
+        if self.connection is None:
+            self._raiseCursorError(api.InterfaceError, None)
+            return
+        try:
+            self.cmd = Dispatch("ADODB.Command")
+            self.cmd.ActiveConnection = self.connection.connector
+            self.cmd.CommandTimeout = self.connection.timeout
+            self.cmd.CommandType = command_type
+            self.cmd.CommandText = self.commandText
+            self.cmd.Prepared = bool(self._ado_prepared)
+        except:
+            self._raiseCursorError(
+                api.DatabaseError,
+                f"Error creating new ADODB.Command object for {self.commandText!r}",
+            )
+
+    def _execute_command(self):
+        # Stored procedures may have an integer return value
+        self.return_value = None
+        recordset = None
+        count = -1  # default value
+        if verbose:
+            print('Executing command="%s"' % self.commandText)
+        try:
+            # ----- the actual SQL is executed here ---
+            recordset, count = self.cmd.Execute()
+            # ----- ------------------------------- ---
+        except Exception as e:
+            _message = ""
+            if hasattr(e, "args"):
+                _message += str(e.args) + "\n"
+            _message += "Command:\n%s\nParameters:\n%s" % (
+                self.commandText,
+                format_parameters(self.cmd.Parameters, True),
+            )
+            klass = self.connection._suggest_error_class()
+            self._raiseCursorError(klass, _message)
+        try:
+            self.rowcount = recordset.RecordCount
+        except:
+            self.rowcount = count
+        self.build_column_info(recordset)
+
+        # The ADO documentation hints that obtaining the recordcount may be timeconsuming
+        #   "If the Recordset object does not support approximate positioning, this property
+        #    may be a significant drain on resources # [ekelund]
+        # Therefore, COM will not return rowcount for server-side cursors. [Cole]
+        # Client-side cursors (the default since v2.8) will force a static
+        # cursor, and rowcount will then be set accurately [Cole]
+
+    def get_rowcount(self):
+        return self.rowcount
+
+    def get_returned_parameters(self):
+        """with some providers, returned parameters and the .return_value are not available until
+        after the last recordset has been read.  In that case, you must coll nextset() until it
+        returns None, then call this method to get your returned information."""
+
+        retLst = (
+            []
+        )  # store procedures may return altered parameters, including an added "return value" item
+        for p in tuple(self.cmd.Parameters):
+            if verbose > 2:
+                print(
+                    'Returned=Name: %s, Dir.: %s, Type: %s, Size: %s, Value: "%s",'
+                    " Precision: %s, NumericScale: %s"
+                    % (
+                        p.Name,
+                        adc.directions[p.Direction],
+                        adc.adTypeNames.get(p.Type, str(p.Type) + " (unknown type)"),
+                        p.Size,
+                        p.Value,
+                        p.Precision,
+                        p.NumericScale,
+                    )
+                )
+            pyObject = api.convert_to_python(p.Value, api.variantConversions[p.Type])
+            if p.Direction == adc.adParamReturnValue:
+                self.returnValue = (
+                    pyObject  # also load the undocumented attribute (Vernon's Error!)
+                )
+                self.return_value = pyObject
+            else:
+                retLst.append(pyObject)
+        return retLst  # return the parameter list to the caller
+
+    def callproc(self, procname, parameters=None):
+        """Call a stored database procedure with the given name.
+        The sequence of parameters must contain one entry for each
+        argument that the sproc expects. The result of the
+        call is returned as modified copy of the input
+        sequence.  Input parameters are left untouched, output and
+        input/output parameters replaced with possibly new values.
+
+        The sproc may also provide a result set as output,
+        which is available through the standard .fetch*() methods.
+        Extension: A "return_value" property may be set on the
+        cursor if the sproc defines an integer return value.
+        """
+        self._parameter_names = []
+        self.commandText = procname
+        self._new_command(command_type=adc.adCmdStoredProc)
+        self._buildADOparameterList(parameters, sproc=True)
+        if verbose > 2:
+            print(
+                "Calling Stored Proc with Params=",
+                format_parameters(self.cmd.Parameters, True),
+            )
+        self._execute_command()
+        return self.get_returned_parameters()
+
+    def _reformat_operation(self, operation, parameters):
+        if self.paramstyle in ("format", "pyformat"):  # convert %s to ?
+            operation, self._parameter_names = api.changeFormatToQmark(operation)
+        elif self.paramstyle == "named" or (
+            self.paramstyle == "dynamic" and isinstance(parameters, Mapping)
+        ):
+            operation, self._parameter_names = api.changeNamedToQmark(
+                operation
+            )  # convert :name to ?
+        return operation
+
+    def _buildADOparameterList(self, parameters, sproc=False):
+        self.parameters = parameters
+        if parameters is None:
+            parameters = []
+
+        # Note: ADO does not preserve the parameter list, even if "Prepared" is True, so we must build every time.
+        parameters_known = False
+        if sproc:  # needed only if we are calling a stored procedure
+            try:  # attempt to use ADO's parameter list
+                self.cmd.Parameters.Refresh()
+                if verbose > 2:
+                    print(
+                        "ADO detected Params=",
+                        format_parameters(self.cmd.Parameters, True),
+                    )
+                    print(f"Program Parameters={parameters!r}")
+                parameters_known = True
+            except api.Error:
+                if verbose:
+                    print("ADO Parameter Refresh failed")
+                pass
+            else:
+                if len(parameters) != self.cmd.Parameters.Count - 1:
+                    raise api.ProgrammingError(
+                        "You must supply %d parameters for this stored procedure"
+                        % (self.cmd.Parameters.Count - 1)
+                    )
+        if sproc or parameters != []:
+            i = 0
+            if parameters_known:  # use ado parameter list
+                if self._parameter_names:  # named parameters
+                    for i, pm_name in enumerate(self._parameter_names):
+                        p = getIndexedValue(self.cmd.Parameters, i)
+                        try:
+                            _configure_parameter(
+                                p, parameters[pm_name], p.Type, parameters_known
+                            )
+                        except Exception as e:
+                            _message = "Error Converting Parameter {}: {}, {} <- {!r}\n".format(
+                                p.Name,
+                                adc.ado_type_name(p.Type),
+                                p.Value,
+                                parameters[pm_name],
+                            )
+                            self._raiseCursorError(
+                                api.DataError, f"{_message}->{e.args!r}"
+                            )
+                else:  # regular sequence of parameters
+                    for value in parameters:
+                        p = getIndexedValue(self.cmd.Parameters, i)
+                        if (
+                            p.Direction == adc.adParamReturnValue
+                        ):  # this is an extra parameter added by ADO
+                            i += 1  # skip the extra
+                            p = getIndexedValue(self.cmd.Parameters, i)
+                        try:
+                            _configure_parameter(p, value, p.Type, parameters_known)
+                        except Exception as e:
+                            _message = "Error Converting Parameter {}: {}, {} <- {!r}\n".format(
+                                p.Name,
+                                adc.ado_type_name(p.Type),
+                                p.Value,
+                                value,
+                            )
+                            self._raiseCursorError(
+                                api.DataError, f"{_message}->{e.args!r}"
+                            )
+                        i += 1
+            else:  # -- build own parameter list
+                if (
+                    self._parameter_names
+                ):  # we expect a dictionary of parameters, this is the list of expected names
+                    for parm_name in self._parameter_names:
+                        elem = parameters[parm_name]
+                        adotype = api.pyTypeToADOType(elem)
+                        p = self.cmd.CreateParameter(
+                            parm_name, adotype, adc.adParamInput
+                        )
+                        _configure_parameter(p, elem, adotype, parameters_known)
+                        try:
+                            self.cmd.Parameters.Append(p)
+                        except Exception as e:
+                            _message = (
+                                "Error Building Parameter {}: {}, {} <- {!r}\n".format(
+                                    p.Name,
+                                    adc.ado_type_name(p.Type),
+                                    p.Value,
+                                    elem,
+                                )
+                            )
+                            self._raiseCursorError(
+                                api.DataError, f"{_message}->{e.args!r}"
+                            )
+                else:  # expecting the usual sequence of parameters
+                    if sproc:
+                        p = self.cmd.CreateParameter(
+                            "@RETURN_VALUE", adc.adInteger, adc.adParamReturnValue
+                        )
+                        self.cmd.Parameters.Append(p)
+
+                    for elem in parameters:
+                        name = "p%i" % i
+                        adotype = api.pyTypeToADOType(elem)
+                        p = self.cmd.CreateParameter(
+                            name, adotype, adc.adParamInput
+                        )  # Name, Type, Direction, Size, Value
+                        _configure_parameter(p, elem, adotype, parameters_known)
+                        try:
+                            self.cmd.Parameters.Append(p)
+                        except Exception as e:
+                            _message = (
+                                "Error Building Parameter {}: {}, {} <- {!r}\n".format(
+                                    p.Name,
+                                    adc.ado_type_name(p.Type),
+                                    p.Value,
+                                    elem,
+                                )
+                            )
+                            self._raiseCursorError(
+                                api.DataError, f"{_message}->{e.args!r}"
+                            )
+                        i += 1
+                if self._ado_prepared == "setup":
+                    self._ado_prepared = (
+                        True  # parameters will be "known" by ADO next loop
+                    )
+
+    def execute(self, operation, parameters=None):
+        """Prepare and execute a database operation (query or command).
+
+        Parameters may be provided as sequence or mapping and will be bound to variables in the operation.
+        Variables are specified in a database-specific notation
+        (see the module's paramstyle attribute for details). [5]
+        A reference to the operation will be retained by the cursor.
+        If the same operation object is passed in again, then the cursor
+        can optimize its behavior. This is most effective for algorithms
+        where the same operation is used, but different parameters are bound to it (many times).
+
+        For maximum efficiency when reusing an operation, it is best to use
+        the setinputsizes() method to specify the parameter types and sizes ahead of time.
+        It is legal for a parameter to not match the predefined information;
+        the implementation should compensate, possibly with a loss of efficiency.
+
+        The parameters may also be specified as list of tuples to e.g. insert multiple rows in
+        a single operation, but this kind of usage is depreciated: executemany() should be used instead.
+
+        Return value is not defined.
+
+        [5] The module will use the __getitem__ method of the parameters object to map either positions
+        (integers) or names (strings) to parameter values. This allows for both sequences and mappings
+        to be used as input.
+        The term "bound" refers to the process of binding an input value to a database execution buffer.
+        In practical terms, this means that the input value is directly used as a value in the operation.
+        The client should not be required to "escape" the value so that it can be used -- the value
+        should be equal to the actual database value."""
+        if (
+            self.command is not operation
+            or self._ado_prepared == "setup"
+            or not hasattr(self, "commandText")
+        ):
+            if self.command is not operation:
+                self._ado_prepared = False
+                self.command = operation
+            self._parameter_names = []
+            self.commandText = (
+                operation
+                if (self.paramstyle == "qmark" or not parameters)
+                else self._reformat_operation(operation, parameters)
+            )
+        self._new_command()
+        self._buildADOparameterList(parameters)
+        if verbose > 3:
+            print("Params=", format_parameters(self.cmd.Parameters, True))
+        self._execute_command()
+
+    def executemany(self, operation, seq_of_parameters):
+        """Prepare a database operation (query or command)
+        and then execute it against all parameter sequences or mappings found in the sequence seq_of_parameters.
+
+            Return values are not defined.
+        """
+        self.messages = list()
+        total_recordcount = 0
+
+        self.prepare(operation)
+        for params in seq_of_parameters:
+            self.execute(self.command, params)
+            if self.rowcount == -1:
+                total_recordcount = -1
+            if total_recordcount != -1:
+                total_recordcount += self.rowcount
+        self.rowcount = total_recordcount
+
+    def _fetch(self, limit=None):
+        """Fetch rows from the current recordset.
+
+        limit -- Number of rows to fetch, or None (default) to fetch all rows.
+        """
+        if self.connection is None or self.rs is None:
+            self._raiseCursorError(
+                api.FetchFailedError, "fetch() on closed connection or empty query set"
+            )
+            return
+
+        if self.rs.State == adc.adStateClosed or self.rs.BOF or self.rs.EOF:
+            return list()
+        if limit:  # limit number of rows retrieved
+            ado_results = self.rs.GetRows(limit)
+        else:  # get all rows
+            ado_results = self.rs.GetRows()
+        if (
+            self.recordset_format == api.RS_ARRAY
+        ):  # result of GetRows is a two-dimension array
+            length = (
+                len(ado_results) // self.numberOfColumns
+            )  # length of first dimension
+        else:  # pywin32
+            length = len(ado_results[0])  # result of GetRows is tuples in a tuple
+        fetchObject = api.SQLrows(
+            ado_results, length, self
+        )  # new object to hold the results of the fetch
+        return fetchObject
+
+    def fetchone(self):
+        """Fetch the next row of a query result set, returning a single sequence,
+        or None when no more data is available.
+
+        An Error (or subclass) exception is raised if the previous call to executeXXX()
+        did not produce any result set or no call was issued yet.
+        """
+        self.messages = []
+        result = self._fetch(1)
+        if result:  # return record (not list of records)
+            return result[0]
+        return None
+
+    def fetchmany(self, size=None):
+        """Fetch the next set of rows of a query result, returning a list of tuples. An empty sequence is returned when no more rows are available.
+
+        The number of rows to fetch per call is specified by the parameter.
+        If it is not given, the cursor's arraysize determines the number of rows to be fetched.
+        The method should try to fetch as many rows as indicated by the size parameter.
+        If this is not possible due to the specified number of rows not being available,
+        fewer rows may be returned.
+
+        An Error (or subclass) exception is raised if the previous call to executeXXX()
+        did not produce any result set or no call was issued yet.
+
+        Note there are performance considerations involved with the size parameter.
+        For optimal performance, it is usually best to use the arraysize attribute.
+        If the size parameter is used, then it is best for it to retain the same value from
+        one fetchmany() call to the next.
+        """
+        self.messages = []
+        if size is None:
+            size = self.arraysize
+        return self._fetch(size)
+
+    def fetchall(self):
+        """Fetch all (remaining) rows of a query result, returning them as a sequence of sequences (e.g. a list of tuples).
+
+        Note that the cursor's arraysize attribute
+        can affect the performance of this operation.
+        An Error (or subclass) exception is raised if the previous call to executeXXX()
+        did not produce any result set or no call was issued yet.
+        """
+        self.messages = []
+        return self._fetch()
+
+    def nextset(self):
+        """Skip to the next available recordset, discarding any remaining rows from the current recordset.
+
+        If there are no more sets, the method returns None. Otherwise, it returns a true
+        value and subsequent calls to the fetch methods will return rows from the next result set.
+
+        An Error (or subclass) exception is raised if the previous call to executeXXX()
+        did not produce any result set or no call was issued yet.
+        """
+        self.messages = []
+        if self.connection is None or self.rs is None:
+            self._raiseCursorError(
+                api.OperationalError,
+                ("nextset() on closed connection or empty query set"),
+            )
+            return None
+
+        try:  # [begin 2.1 ekelund]
+            rsTuple = self.rs.NextRecordset()  #
+        except pywintypes.com_error as exc:  # return appropriate error
+            self._raiseCursorError(api.NotSupportedError, exc.args)  # [end 2.1 ekelund]
+        recordset = rsTuple[0]
+        if recordset is None:
+            return None
+        self.build_column_info(recordset)
+        return True
+
+    def setinputsizes(self, sizes):
+        pass
+
+    def setoutputsize(self, size, column=None):
+        pass
+
+    def _last_query(self):  # let the programmer see what query we actually used
+        try:
+            if self.parameters is None:
+                ret = self.commandText
+            else:
+                ret = f"{self.commandText},parameters={self.parameters!r}"
+        except:
+            ret = None
+        return ret
+
+    query = property(_last_query, None, None, "returns the last query executed")
+
+
+if __name__ == "__main__":
+    raise api.ProgrammingError(version + " cannot be run as a main program.")

myenv/Lib/site-packages/adodbapi/apibase.py

@@ -0,0 +1,724 @@
+"""adodbapi.apibase - A python DB API 2.0 (PEP 249) interface to Microsoft ADO
+
+Copyright (C) 2002 Henrik Ekelund, version 2.1 by Vernon Cole
+* http://sourceforge.net/projects/pywin32
+* http://sourceforge.net/projects/adodbapi
+"""
+
+from __future__ import annotations
+
+import datetime
+import decimal
+import numbers
+import sys
+import time
+from collections.abc import Callable, Iterable, Mapping
+from typing import Dict
+
+# noinspection PyUnresolvedReferences
+from . import ado_consts as adc
+
+verbose = False  # debugging flag
+
+
+# ------- Error handlers ------
+def standardErrorHandler(connection, cursor, errorclass, errorvalue):
+    err = (errorclass, errorvalue)
+    try:
+        connection.messages.append(err)
+    except:
+        pass
+    if cursor is not None:
+        try:
+            cursor.messages.append(err)
+        except:
+            pass
+    raise errorclass(errorvalue)
+
+
+class Error(Exception):
+    pass  # Exception that is the base class of all other error
+    # exceptions. You can use this to catch all errors with one
+    # single 'except' statement. Warnings are not considered
+    # errors and thus should not use this class as base. It must
+    # be a subclass of the Python StandardError (defined in the
+    # module exceptions).
+
+
+class Warning(Exception):
+    pass
+
+
+class InterfaceError(Error):
+    pass
+
+
+class DatabaseError(Error):
+    pass
+
+
+class InternalError(DatabaseError):
+    pass
+
+
+class OperationalError(DatabaseError):
+    pass
+
+
+class ProgrammingError(DatabaseError):
+    pass
+
+
+class IntegrityError(DatabaseError):
+    pass
+
+
+class DataError(DatabaseError):
+    pass
+
+
+class NotSupportedError(DatabaseError):
+    pass
+
+
+class FetchFailedError(OperationalError):
+    """
+    Error is used by RawStoredProcedureQuerySet to determine when a fetch
+    failed due to a connection being closed or there is no record set
+    returned. (Non-standard, added especially for django)
+    """
+
+    pass
+
+
+# # # # # ----- Type Objects and Constructors ----- # # # # #
+# Many databases need to have the input in a particular format for binding to an operation's input parameters.
+# For example, if an input is destined for a DATE column, then it must be bound to the database in a particular
+# string format. Similar problems exist for "Row ID" columns or large binary items (e.g. blobs or RAW columns).
+# This presents problems for Python since the parameters to the executeXXX() method are untyped.
+# When the database module sees a Python string object, it doesn't know if it should be bound as a simple CHAR
+# column, as a raw BINARY item, or as a DATE.
+#
+# To overcome this problem, a module must provide the constructors defined below to create objects that can
+# hold special values. When passed to the cursor methods, the module can then detect the proper type of
+# the input parameter and bind it accordingly.
+
+# A Cursor Object's description attribute returns information about each of the result columns of a query.
+# The type_code must compare equal to one of Type Objects defined below. Type Objects may be equal to more than
+# one type code (e.g. DATETIME could be equal to the type codes for date, time and timestamp columns;
+# see the Implementation Hints below for details).
+
+# SQL NULL values are represented by the Python None singleton on input and output.
+
+# Note: Usage of Unix ticks for database interfacing can cause troubles because of the limited date range they cover.
+
+
+# def Date(year,month,day):
+#     "This function constructs an object holding a date value. "
+#     return dateconverter.date(year,month,day)  #dateconverter.Date(year,month,day)
+#
+# def Time(hour,minute,second):
+#     "This function constructs an object holding a time value. "
+#     return dateconverter.time(hour, minute, second) # dateconverter.Time(hour,minute,second)
+#
+# def Timestamp(year,month,day,hour,minute,second):
+#     "This function constructs an object holding a time stamp value. "
+#     return dateconverter.datetime(year,month,day,hour,minute,second)
+#
+# def DateFromTicks(ticks):
+#     """This function constructs an object holding a date value from the given ticks value
+#     (number of seconds since the epoch; see the documentation of the standard Python time module for details). """
+#     return Date(*time.gmtime(ticks)[:3])
+#
+# def TimeFromTicks(ticks):
+#     """This function constructs an object holding a time value from the given ticks value
+#     (number of seconds since the epoch; see the documentation of the standard Python time module for details). """
+#     return Time(*time.gmtime(ticks)[3:6])
+#
+# def TimestampFromTicks(ticks):
+#     """This function constructs an object holding a time stamp value from the given
+#     ticks value (number of seconds since the epoch;
+#     see the documentation of the standard Python time module for details). """
+#     return Timestamp(*time.gmtime(ticks)[:6])
+#
+# def Binary(aString):
+#     """This function constructs an object capable of holding a binary (long) string value. """
+#     b = bytes(aString)
+#     return b
+# -----     Time converters ----------------------------------------------
+class TimeConverter:  # this is a generic time converter skeleton
+    def __init__(self):  # the details will be filled in by instances
+        self._ordinal_1899_12_31 = datetime.date(1899, 12, 31).toordinal() - 1
+        # Use cls.types to compare if an input parameter is a datetime
+        self.types = {
+            # Dynamically get the types as the methods may be overriden
+            type(self.Date(2000, 1, 1)),
+            type(self.Time(12, 1, 1)),
+            type(self.Timestamp(2000, 1, 1, 12, 1, 1)),
+            datetime.datetime,
+            datetime.time,
+            datetime.date,
+        }
+
+    def COMDate(self, obj):
+        """Returns a ComDate from a date-time"""
+        try:  # most likely a datetime
+            tt = obj.timetuple()
+
+            try:
+                ms = obj.microsecond
+            except:
+                ms = 0
+            return self.ComDateFromTuple(tt, ms)
+        except:  # might be a tuple
+            try:
+                return self.ComDateFromTuple(obj)
+            except:
+                raise ValueError(f'Cannot convert "{obj!r}" to COMdate.')
+
+    def ComDateFromTuple(self, t, microseconds=0):
+        d = datetime.date(t[0], t[1], t[2])
+        integerPart = d.toordinal() - self._ordinal_1899_12_31
+        ms = (t[3] * 3600 + t[4] * 60 + t[5]) * 1000000 + microseconds
+        fractPart = float(ms) / 86400000000.0
+        return integerPart + fractPart
+
+    def DateObjectFromCOMDate(self, comDate):
+        "Returns an object of the wanted type from a ComDate"
+        raise NotImplementedError  # "Abstract class"
+
+    def Date(self, year, month, day):
+        "This function constructs an object holding a date value."
+        raise NotImplementedError  # "Abstract class"
+
+    def Time(self, hour, minute, second):
+        "This function constructs an object holding a time value."
+        raise NotImplementedError  # "Abstract class"
+
+    def Timestamp(self, year, month, day, hour, minute, second):
+        "This function constructs an object holding a time stamp value."
+        raise NotImplementedError  # "Abstract class"
+        # all purpose date to ISO format converter
+
+    def DateObjectToIsoFormatString(self, obj):
+        "This function should return a string in the format 'YYYY-MM-dd HH:MM:SS:ms' (ms optional)"
+        try:  # most likely, a datetime.datetime
+            s = obj.isoformat(" ")
+        except (TypeError, AttributeError):
+            if isinstance(obj, datetime.date):
+                s = obj.isoformat() + " 00:00:00"  # return exact midnight
+            else:
+                try:  # but may be time.struct_time
+                    s = time.strftime("%Y-%m-%d %H:%M:%S", obj)
+                except:
+                    raise ValueError(f'Cannot convert "{obj!r}" to isoformat')
+        return s
+
+
+class pythonDateTimeConverter(TimeConverter):  # standard since Python 2.3
+    def __init__(self):
+        TimeConverter.__init__(self)
+
+    def DateObjectFromCOMDate(self, comDate):
+        if isinstance(comDate, datetime.datetime):
+            odn = comDate.toordinal()
+            tim = comDate.time()
+            new = datetime.datetime.combine(datetime.datetime.fromordinal(odn), tim)
+            return new
+            # return comDate.replace(tzinfo=None) # make non aware
+        else:
+            fComDate = float(comDate)  # ComDate is number of days since 1899-12-31
+        integerPart = int(fComDate)
+        floatpart = fComDate - integerPart
+        ##if floatpart == 0.0:
+        ##    return datetime.date.fromordinal(integerPart + self._ordinal_1899_12_31)
+        dte = datetime.datetime.fromordinal(
+            integerPart + self._ordinal_1899_12_31
+        ) + datetime.timedelta(milliseconds=floatpart * 86400000)
+        # millisecondsperday=86400000 # 24*60*60*1000
+        return dte
+
+    def Date(self, year, month, day):
+        return datetime.date(year, month, day)
+
+    def Time(self, hour, minute, second):
+        return datetime.time(hour, minute, second)
+
+    def Timestamp(self, year, month, day, hour, minute, second):
+        return datetime.datetime(year, month, day, hour, minute, second)
+
+
+class pythonTimeConverter(TimeConverter):  # the old, ?nix type date and time
+    def __init__(self):  # caution: this Class gets confised by timezones and DST
+        TimeConverter.__init__(self)
+        self.types.add(time.struct_time)
+
+    def DateObjectFromCOMDate(self, comDate):
+        "Returns ticks since 1970"
+        if isinstance(comDate, datetime.datetime):
+            return comDate.timetuple()
+        else:
+            fcomDate = float(comDate)
+        secondsperday = 86400  # 24*60*60
+        # ComDate is number of days since 1899-12-31, gmtime epoch is 1970-1-1 = 25569 days
+        t = time.gmtime(secondsperday * (fcomDate - 25569.0))
+        return t  # year,month,day,hour,minute,second,weekday,julianday,daylightsaving=t
+
+    def Date(self, year, month, day):
+        return self.Timestamp(year, month, day, 0, 0, 0)
+
+    def Time(self, hour, minute, second):
+        return time.gmtime((hour * 60 + minute) * 60 + second)
+
+    def Timestamp(self, year, month, day, hour, minute, second):
+        return time.localtime(
+            time.mktime((year, month, day, hour, minute, second, 0, 0, -1))
+        )
+
+
+base_dateconverter = pythonDateTimeConverter()
+
+# ------ DB API required module attributes ---------------------
+threadsafety = 1  # TODO -- find out whether this module is actually BETTER than 1.
+
+apilevel = "2.0"  # String constant stating the supported DB API level.
+
+paramstyle = "qmark"  # the default parameter style
+
+# ------ control for an extension which may become part of DB API 3.0 ---
+accepted_paramstyles = ("qmark", "named", "format", "pyformat", "dynamic")
+
+# ------------------------------------------------------------------------------------------
+# define similar types for generic conversion routines
+adoIntegerTypes = (
+    adc.adInteger,
+    adc.adSmallInt,
+    adc.adTinyInt,
+    adc.adUnsignedInt,
+    adc.adUnsignedSmallInt,
+    adc.adUnsignedTinyInt,
+    adc.adBoolean,
+    adc.adError,
+)  # max 32 bits
+adoRowIdTypes = (adc.adChapter,)  # v2.1 Rose
+adoLongTypes = (adc.adBigInt, adc.adFileTime, adc.adUnsignedBigInt)
+adoExactNumericTypes = (
+    adc.adDecimal,
+    adc.adNumeric,
+    adc.adVarNumeric,
+    adc.adCurrency,
+)  # v2.3 Cole
+adoApproximateNumericTypes = (adc.adDouble, adc.adSingle)  # v2.1 Cole
+adoStringTypes = (
+    adc.adBSTR,
+    adc.adChar,
+    adc.adLongVarChar,
+    adc.adLongVarWChar,
+    adc.adVarChar,
+    adc.adVarWChar,
+    adc.adWChar,
+)
+adoBinaryTypes = (adc.adBinary, adc.adLongVarBinary, adc.adVarBinary)
+adoDateTimeTypes = (adc.adDBTime, adc.adDBTimeStamp, adc.adDate, adc.adDBDate)
+adoRemainingTypes = (
+    adc.adEmpty,
+    adc.adIDispatch,
+    adc.adIUnknown,
+    adc.adPropVariant,
+    adc.adArray,
+    adc.adUserDefined,
+    adc.adVariant,
+    adc.adGUID,
+)
+
+
+# this class is a trick to determine whether a type is a member of a related group of types. see PEP notes
+class DBAPITypeObject:
+    def __init__(self, valuesTuple):
+        self.values = frozenset(valuesTuple)
+
+    def __eq__(self, other):
+        return other in self.values
+
+    def __ne__(self, other):
+        return other not in self.values
+
+
+"""This type object is used to describe columns in a database that are string-based (e.g. CHAR). """
+STRING = DBAPITypeObject(adoStringTypes)
+
+"""This type object is used to describe (long) binary columns in a database (e.g. LONG, RAW, BLOBs). """
+BINARY = DBAPITypeObject(adoBinaryTypes)
+
+"""This type object is used to describe numeric columns in a database. """
+NUMBER = DBAPITypeObject(
+    adoIntegerTypes + adoLongTypes + adoExactNumericTypes + adoApproximateNumericTypes
+)
+
+"""This type object is used to describe date/time columns in a database. """
+
+DATETIME = DBAPITypeObject(adoDateTimeTypes)
+"""This type object is used to describe the "Row ID" column in a database. """
+ROWID = DBAPITypeObject(adoRowIdTypes)
+
+OTHER = DBAPITypeObject(adoRemainingTypes)
+
+# ------- utilities for translating python data types to ADO data types ---------------------------------
+typeMap = {
+    memoryview: adc.adVarBinary,
+    float: adc.adDouble,
+    type(None): adc.adEmpty,
+    str: adc.adBSTR,
+    bool: adc.adBoolean,  # v2.1 Cole
+    decimal.Decimal: adc.adDecimal,
+    int: adc.adBigInt,
+    bytes: adc.adVarBinary,
+}
+
+
+def pyTypeToADOType(d):
+    tp = type(d)
+    try:
+        return typeMap[tp]
+    except KeyError:  #   The type was not defined in the pre-computed Type table
+        from . import dateconverter
+
+        # maybe it is one of our supported Date/Time types
+        if tp in dateconverter.types:
+            return adc.adDate
+        #  otherwise, attempt to discern the type by probing the data object itself -- to handle duck typing
+        if isinstance(d, str):
+            return adc.adBSTR
+        if isinstance(d, numbers.Integral):
+            return adc.adBigInt
+        if isinstance(d, numbers.Real):
+            return adc.adDouble
+        raise DataError(f'cannot convert "{d!r}" (type={tp}) to ADO')
+
+
+# # # # # # # # # # # # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+# functions to convert database values to Python objects
+# ------------------------------------------------------------------------
+# variant type : function converting variant to Python value
+def variantConvertDate(v):
+    from . import dateconverter  # this function only called when adodbapi is running
+
+    return dateconverter.DateObjectFromCOMDate(v)
+
+
+def cvtString(variant):  # use to get old action of adodbapi v1 if desired
+    return str(variant)
+
+
+def cvtDecimal(variant):  # better name
+    return _convertNumberWithCulture(variant, decimal.Decimal)
+
+
+def cvtNumeric(variant):  # older name - don't break old code
+    return cvtDecimal(variant)
+
+
+def cvtFloat(variant):
+    return _convertNumberWithCulture(variant, float)
+
+
+def _convertNumberWithCulture(variant, f):
+    try:
+        return f(variant)
+    except (ValueError, TypeError, decimal.InvalidOperation):
+        try:
+            europeVsUS = str(variant).replace(",", ".")
+            return f(europeVsUS)
+        except (ValueError, TypeError, decimal.InvalidOperation):
+            pass
+
+
+def cvtInt(variant):
+    return int(variant)
+
+
+def cvtLong(variant):  # only important in old versions where long and int differ
+    return int(variant)
+
+
+def cvtBuffer(variant):
+    return bytes(variant)
+
+
+def cvtUnicode(variant):
+    return str(variant)
+
+
+def identity(x):
+    return x
+
+
+def cvtUnusual(variant):
+    if verbose > 1:
+        sys.stderr.write(f"Conversion called for Unusual data={variant!r}\n")
+    return variant  # cannot find conversion function -- just give the data to the user
+
+
+def convert_to_python(variant, func):  # convert DB value into Python value
+    if variant is None:
+        return None
+    return func(variant)  # call the appropriate conversion function
+
+
+class MultiMap(Dict[int, Callable[[object], object]]):
+    # builds a dictionary from {(iterable,of,keys) : function}
+    """A dictionary of ado.type : function
+    -- but you can set multiple items by passing an iterable of keys"""
+
+    # useful for defining conversion functions for groups of similar data types.
+    def __init__(self, aDict: Mapping[Iterable[int] | int, Callable[[object], object]]):
+        for k, v in aDict.items():
+            self[k] = v  # we must call __setitem__
+
+    def __setitem__(
+        self, adoType: Iterable[int] | int, cvtFn: Callable[[object], object]
+    ):
+        "set a single item, or a whole iterable of items"
+        if isinstance(adoType, Iterable):
+            # user passed us an iterable, set them individually
+            for type in adoType:
+                dict.__setitem__(self, type, cvtFn)
+        else:
+            dict.__setitem__(self, adoType, cvtFn)
+
+
+# initialize variantConversions dictionary used to convert SQL to Python
+# this is the dictionary of default conversion functions, built by the class above.
+# this becomes a class attribute for the Connection, and that attribute is used
+# to build the list of column conversion functions for the Cursor
+variantConversions = MultiMap(
+    {
+        adoDateTimeTypes: variantConvertDate,
+        adoApproximateNumericTypes: cvtFloat,
+        adoExactNumericTypes: cvtDecimal,  # use to force decimal rather than unicode
+        adoLongTypes: cvtLong,
+        adoIntegerTypes: cvtInt,
+        adoRowIdTypes: cvtInt,
+        adoStringTypes: identity,
+        adoBinaryTypes: cvtBuffer,
+        adoRemainingTypes: cvtUnusual,
+    }
+)
+
+# # # # # classes to emulate the result of cursor.fetchxxx() as a sequence of sequences # # # # #
+# "an ENUM of how my low level records are laid out"
+RS_WIN_32, RS_ARRAY, RS_REMOTE = list(range(1, 4))
+
+
+class SQLrow:  # a single database row
+    # class to emulate a sequence, so that a column may be retrieved by either number or name
+    def __init__(self, rows, index):  # "rows" is an _SQLrows object, index is which row
+        self.rows = rows  # parent 'fetch' container object
+        self.index = index  # my row number within parent
+
+    def __getattr__(self, name):  # used for row.columnName type of value access
+        try:
+            return self._getValue(self.rows.columnNames[name.lower()])
+        except KeyError:
+            raise AttributeError('Unknown column name "{}"'.format(name))
+
+    def _getValue(self, key):  # key must be an integer
+        if (
+            self.rows.recordset_format == RS_ARRAY
+        ):  # retrieve from two-dimensional array
+            v = self.rows.ado_results[key, self.index]
+        elif self.rows.recordset_format == RS_REMOTE:
+            v = self.rows.ado_results[self.index][key]
+        else:  # pywin32 - retrieve from tuple of tuples
+            v = self.rows.ado_results[key][self.index]
+        if self.rows.converters is NotImplemented:
+            return v
+        return convert_to_python(v, self.rows.converters[key])
+
+    def __len__(self):
+        return self.rows.numberOfColumns
+
+    def __getitem__(self, key):  # used for row[key] type of value access
+        if isinstance(key, int):  # normal row[1] designation
+            try:
+                return self._getValue(key)
+            except IndexError:
+                raise
+        if isinstance(key, slice):
+            indices = key.indices(self.rows.numberOfColumns)
+            vl = [self._getValue(i) for i in range(*indices)]
+            return tuple(vl)
+        try:
+            return self._getValue(
+                self.rows.columnNames[key.lower()]
+            )  # extension row[columnName] designation
+        except (KeyError, TypeError):
+            er, st, tr = sys.exc_info()
+            raise er(f'No such key as "{key!r}" in {self!r}').with_traceback(tr)
+
+    def __iter__(self):
+        return iter(self.__next__())
+
+    def __next__(self):
+        for n in range(self.rows.numberOfColumns):
+            yield self._getValue(n)
+
+    def __repr__(self):  # create a human readable representation
+        taglist = sorted(list(self.rows.columnNames.items()), key=lambda x: x[1])
+        s = "<SQLrow={"
+        for name, i in taglist:
+            s += f"{name}:{self._getValue(i)!r}, "
+        return s[:-2] + "}>"
+
+    def __str__(self):  # create a pretty human readable representation
+        return str(
+            tuple(str(self._getValue(i)) for i in range(self.rows.numberOfColumns))
+        )
+
+    # TO-DO implement pickling an SQLrow directly
+    # def __getstate__(self): return self.__dict__
+    # def __setstate__(self, d): self.__dict__.update(d)
+    # which basically tell pickle to treat your class just like a normal one,
+    # taking self.__dict__ as representing the whole of the instance state,
+    #  despite the existence of the __getattr__.
+    # # # #
+
+
+class SQLrows:
+    # class to emulate a sequence for multiple rows using a container object
+    def __init__(self, ado_results, numberOfRows, cursor):
+        self.ado_results = ado_results  # raw result of SQL get
+        try:
+            self.recordset_format = cursor.recordset_format
+            self.numberOfColumns = cursor.numberOfColumns
+            self.converters = cursor.converters
+            self.columnNames = cursor.columnNames
+        except AttributeError:
+            self.recordset_format = RS_ARRAY
+            self.numberOfColumns = 0
+            self.converters = []
+            self.columnNames = {}
+        self.numberOfRows = numberOfRows
+
+    def __len__(self):
+        return self.numberOfRows
+
+    def __getitem__(self, item):  # used for row or row,column access
+        if not self.ado_results:
+            return []
+        if isinstance(item, slice):  # will return a list of row objects
+            indices = item.indices(self.numberOfRows)
+            return [SQLrow(self, k) for k in range(*indices)]
+        elif isinstance(item, tuple) and len(item) == 2:
+            # d = some_rowsObject[i,j] will return a datum from a two-dimension address
+            i, j = item
+            if not isinstance(j, int):
+                try:
+                    j = self.columnNames[j.lower()]  # convert named column to numeric
+                except KeyError:
+                    raise KeyError(f"adodbapi: no such column name as {j!r}")
+            if self.recordset_format == RS_ARRAY:  # retrieve from two-dimensional array
+                v = self.ado_results[j, i]
+            elif self.recordset_format == RS_REMOTE:
+                v = self.ado_results[i][j]
+            else:  # pywin32 - retrieve from tuple of tuples
+                v = self.ado_results[j][i]
+            if self.converters is NotImplemented:
+                return v
+            return convert_to_python(v, self.converters[j])
+        else:
+            row = SQLrow(self, item)  # new row descriptor
+            return row
+
+    def __iter__(self):
+        return iter(self.__next__())
+
+    def __next__(self):
+        for n in range(self.numberOfRows):
+            row = SQLrow(self, n)
+            yield row
+            # # # # #
+
+    # # # # # functions to re-format SQL requests to other paramstyle requirements # # # # # # # # # #
+
+
+def changeNamedToQmark(
+    op,
+):  # convert from 'named' paramstyle to ADO required '?'mark parameters
+    outOp = ""
+    outparms = []
+    chunks = op.split(
+        "'"
+    )  # quote all literals -- odd numbered list results are literals.
+    inQuotes = False
+    for chunk in chunks:
+        if inQuotes:  # this is inside a quote
+            if chunk == "":  # double apostrophe to quote one apostrophe
+                outOp = outOp[:-1]  # so take one away
+            else:
+                outOp += "'" + chunk + "'"  # else pass the quoted string as is.
+        else:  # is SQL code -- look for a :namedParameter
+            while chunk:  # some SQL string remains
+                sp = chunk.split(":", 1)
+                outOp += sp[0]  # concat the part up to the :
+                s = ""
+                try:
+                    chunk = sp[1]
+                except IndexError:
+                    chunk = None
+                if chunk:  # there was a parameter - parse it out
+                    i = 0
+                    c = chunk[0]
+                    while c.isalnum() or c == "_":
+                        i += 1
+                        try:
+                            c = chunk[i]
+                        except IndexError:
+                            break
+                    s = chunk[:i]
+                    chunk = chunk[i:]
+                if s:
+                    outparms.append(s)  # list the parameters in order
+                    outOp += "?"  # put in the Qmark
+        inQuotes = not inQuotes
+    return outOp, outparms
+
+
+def changeFormatToQmark(
+    op,
+):  # convert from 'format' paramstyle to ADO required '?'mark parameters
+    outOp = ""
+    outparams = []
+    chunks = op.split(
+        "'"
+    )  # quote all literals -- odd numbered list results are literals.
+    inQuotes = False
+    for chunk in chunks:
+        if inQuotes:
+            if (
+                outOp != "" and chunk == ""
+            ):  # he used a double apostrophe to quote one apostrophe
+                outOp = outOp[:-1]  # so take one away
+            else:
+                outOp += "'" + chunk + "'"  # else pass the quoted string as is.
+        else:  # is SQL code -- look for a %s parameter
+            if "%(" in chunk:  # ugh! pyformat!
+                while chunk:  # some SQL string remains
+                    sp = chunk.split("%(", 1)
+                    outOp += sp[0]  # concat the part up to the %
+                    if len(sp) > 1:
+                        try:
+                            s, chunk = sp[1].split(")s", 1)  # find the ')s'
+                        except ValueError:
+                            raise ProgrammingError(
+                                'Pyformat SQL has incorrect format near "%s"' % chunk
+                            )
+                        outparams.append(s)
+                        outOp += "?"  # put in the Qmark
+                    else:
+                        chunk = None
+            else:  # proper '%s' format
+                sp = chunk.split("%s")  # make each %s
+                outOp += "?".join(sp)  # into ?
+        inQuotes = not inQuotes  # every other chunk is a quoted string
+    return outOp, outparams

myenv/Lib/site-packages/adodbapi/examples/db_print.py

@@ -0,0 +1,72 @@
+""" db_print.py -- a simple demo for ADO database reads."""
+
+import sys
+
+import adodbapi.ado_consts as adc
+
+cmd_args = ("filename", "table_name")
+if "help" in sys.argv:
+    print("possible settings keywords are:", cmd_args)
+    sys.exit()
+
+kw_args = {}  # pick up filename and proxy address from command line (optionally)
+for arg in sys.argv:
+    s = arg.split("=")
+    if len(s) > 1:
+        if s[0] in cmd_args:
+            kw_args[s[0]] = s[1]
+
+kw_args.setdefault(
+    "filename", "test.mdb"
+)  # assumes server is running from examples folder
+kw_args.setdefault("table_name", "Products")  # the name of the demo table
+
+# the server needs to select the provider based on his Python installation
+provider_switch = ["provider", "Microsoft.ACE.OLEDB.12.0", "Microsoft.Jet.OLEDB.4.0"]
+
+# ------------------------ START HERE -------------------------------------
+# create the connection
+constr = "Provider=%(provider)s;Data Source=%(filename)s"
+import adodbapi as db
+
+con = db.connect(constr, kw_args, macro_is64bit=provider_switch)
+
+if kw_args["table_name"] == "?":
+    print("The tables in your database are:")
+    for name in con.get_table_names():
+        print(name)
+else:
+    # make a cursor on the connection
+    with con.cursor() as c:
+        # run an SQL statement on the cursor
+        sql = "select * from %s" % kw_args["table_name"]
+        print('performing query="%s"' % sql)
+        c.execute(sql)
+
+        # check the results
+        print(
+            'result rowcount shows as= %d. (Note: -1 means "not known")' % (c.rowcount,)
+        )
+        print("")
+        print("result data description is:")
+        print("            NAME Type         DispSize IntrnlSz Prec Scale Null?")
+        for d in c.description:
+            print(
+                ("%16s %-12s %8s %8d %4d %5d %s")
+                % (d[0], adc.adTypeNames[d[1]], d[2], d[3], d[4], d[5], bool(d[6]))
+            )
+        print("")
+        print("str() of first five records are...")
+
+        # get the results
+        db = c.fetchmany(5)
+
+        # print them
+        for rec in db:
+            print(rec)
+
+        print("")
+        print("repr() of next row is...")
+        print(repr(c.fetchone()))
+        print("")
+con.close()

myenv/Lib/site-packages/adodbapi/examples/db_table_names.py

@@ -0,0 +1,21 @@
+""" db_table_names.py -- a simple demo for ADO database table listing."""
+
+import sys
+
+import adodbapi
+
+try:
+    databasename = sys.argv[1]
+except IndexError:
+    databasename = "test.mdb"
+
+provider = ["prv", "Microsoft.ACE.OLEDB.12.0", "Microsoft.Jet.OLEDB.4.0"]
+constr = "Provider=%(prv)s;Data Source=%(db)s"
+
+# create the connection
+con = adodbapi.connect(constr, db=databasename, macro_is64bit=provider)
+
+print("Table names in= %s" % databasename)
+
+for table in con.get_table_names():
+    print(table)

myenv/Lib/site-packages/adodbapi/examples/xls_read.py

@@ -0,0 +1,41 @@
+import sys
+
+import adodbapi
+
+try:
+    import adodbapi.is64bit as is64bit
+
+    is64 = is64bit.Python()
+except ImportError:
+    is64 = False
+
+if is64:
+    driver = "Microsoft.ACE.OLEDB.12.0"
+else:
+    driver = "Microsoft.Jet.OLEDB.4.0"
+extended = 'Extended Properties="Excel 8.0;HDR=Yes;IMEX=1;"'
+
+try:  # first command line argument will be xls file name -- default to the one written by xls_write.py
+    filename = sys.argv[1]
+except IndexError:
+    filename = "xx.xls"
+
+constr = "Provider=%s;Data Source=%s;%s" % (driver, filename, extended)
+
+conn = adodbapi.connect(constr)
+
+try:  # second command line argument will be worksheet name -- default to first worksheet
+    sheet = sys.argv[2]
+except IndexError:
+    # use ADO feature to get the name of the first worksheet
+    sheet = conn.get_table_names()[0]
+
+print("Shreadsheet=%s  Worksheet=%s" % (filename, sheet))
+print("------------------------------------------------------------")
+crsr = conn.cursor()
+sql = "SELECT * from [%s]" % sheet
+crsr.execute(sql)
+for row in crsr.fetchmany(10):
+    print(repr(row))
+crsr.close()
+conn.close()

myenv/Lib/site-packages/adodbapi/examples/xls_write.py

@@ -0,0 +1,41 @@
+import datetime
+
+import adodbapi
+
+try:
+    import adodbapi.is64bit as is64bit
+
+    is64 = is64bit.Python()
+except ImportError:
+    is64 = False  # in case the user has an old version of adodbapi
+if is64:
+    driver = "Microsoft.ACE.OLEDB.12.0"
+else:
+    driver = "Microsoft.Jet.OLEDB.4.0"
+filename = "xx.xls"  # file will be created if it does not exist
+extended = 'Extended Properties="Excel 8.0;Readonly=False;"'
+
+constr = "Provider=%s;Data Source=%s;%s" % (driver, filename, extended)
+
+conn = adodbapi.connect(constr)
+with conn:  # will auto commit if no errors
+    with conn.cursor() as crsr:
+        try:
+            crsr.execute("drop table SheetOne")
+        except:
+            pass  # just is case there is one already there
+
+        # create the sheet and the header row and set the types for the columns
+        crsr.execute(
+            "create table SheetOne (Name varchar, Rank varchar, SrvcNum integer, Weight float,  Birth date)"
+        )
+
+        sql = "INSERT INTO SheetOne (name, rank , srvcnum, weight, birth) values (?,?,?,?,?)"
+
+        data = ("Mike Murphy", "SSG", 123456789, 167.8, datetime.date(1922, 12, 27))
+        crsr.execute(sql, data)  # write the first row of data
+        crsr.execute(
+            sql, ["John Jones", "Pvt", 987654321, 140.0, datetime.date(1921, 7, 4)]
+        )  # another row of data
+conn.close()
+print("Created spreadsheet=%s worksheet=%s" % (filename, "SheetOne"))

myenv/Lib/site-packages/adodbapi/is64bit.py

@@ -0,0 +1,34 @@
+"""is64bit.Python() --> boolean value of detected Python word size. is64bit.os() --> os build version"""
+
+import sys
+
+
+def Python():
+    return sys.maxsize > 2147483647
+
+
+def os():
+    import platform
+
+    pm = platform.machine()
+    if pm != ".." and pm.endswith("64"):  # recent 64 bit Python
+        return True
+    else:
+        import os
+
+        if "PROCESSOR_ARCHITEW6432" in os.environ:
+            return True  # 32 bit program running on 64 bit Windows
+        try:
+            return os.environ["PROCESSOR_ARCHITECTURE"].endswith(
+                "64"
+            )  # 64 bit Windows 64 bit program
+        except (IndexError, KeyError):
+            pass  # not Windows
+        try:
+            return "64" in platform.architecture()[0]  # this often works in Linux
+        except:
+            return False  # is an older version of Python, assume also an older os (best we can guess)
+
+
+if __name__ == "__main__":
+    print("is64bit.Python() =", Python(), "is64bit.os() =", os())

myenv/Lib/site-packages/adodbapi/license.txt

@@ -0,0 +1,505 @@
+		  GNU LESSER GENERAL PUBLIC LICENSE
+		       Version 2.1, February 1999
+
+ Copyright (C) 1991, 1999 Free Software Foundation, Inc.
+     59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+[This is the first released version of the Lesser GPL.  It also counts
+ as the successor of the GNU Library Public License, version 2, hence
+ the version number 2.1.]
+
+			    Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+Licenses are intended to guarantee your freedom to share and change
+free software--to make sure the software is free for all its users.
+
+  This license, the Lesser General Public License, applies to some
+specially designated software packages--typically libraries--of the
+Free Software Foundation and other authors who decide to use it.  You
+can use it too, but we suggest you first think carefully about whether
+this license or the ordinary General Public License is the better
+strategy to use in any particular case, based on the explanations below.
+
+  When we speak of free software, we are referring to freedom of use,
+not price.  Our General Public Licenses are designed to make sure that
+you have the freedom to distribute copies of free software (and charge
+for this service if you wish); that you receive source code or can get
+it if you want it; that you can change the software and use pieces of
+it in new free programs; and that you are informed that you can do
+these things.
+
+  To protect your rights, we need to make restrictions that forbid
+distributors to deny you these rights or to ask you to surrender these
+rights.  These restrictions translate to certain responsibilities for
+you if you distribute copies of the library or if you modify it.
+
+  For example, if you distribute copies of the library, whether gratis
+or for a fee, you must give the recipients all the rights that we gave
+you.  You must make sure that they, too, receive or can get the source
+code.  If you link other code with the library, you must provide
+complete object files to the recipients, so that they can relink them
+with the library after making changes to the library and recompiling
+it.  And you must show them these terms so they know their rights.
+
+  We protect your rights with a two-step method: (1) we copyright the
+library, and (2) we offer you this license, which gives you legal
+permission to copy, distribute and/or modify the library.
+
+  To protect each distributor, we want to make it very clear that
+there is no warranty for the free library.  Also, if the library is
+modified by someone else and passed on, the recipients should know
+that what they have is not the original version, so that the original
+author's reputation will not be affected by problems that might be
+introduced by others.
+
+
+
+  Finally, software patents pose a constant threat to the existence of
+any free program.  We wish to make sure that a company cannot
+effectively restrict the users of a free program by obtaining a
+restrictive license from a patent holder.  Therefore, we insist that
+any patent license obtained for a version of the library must be
+consistent with the full freedom of use specified in this license.
+
+  Most GNU software, including some libraries, is covered by the
+ordinary GNU General Public License.  This license, the GNU Lesser
+General Public License, applies to certain designated libraries, and
+is quite different from the ordinary General Public License.  We use
+this license for certain libraries in order to permit linking those
+libraries into non-free programs.
+
+  When a program is linked with a library, whether statically or using
+a shared library, the combination of the two is legally speaking a
+combined work, a derivative of the original library.  The ordinary
+General Public License therefore permits such linking only if the
+entire combination fits its criteria of freedom.  The Lesser General
+Public License permits more lax criteria for linking other code with
+the library.
+
+  We call this license the "Lesser" General Public License because it
+does Less to protect the user's freedom than the ordinary General
+Public License.  It also provides other free software developers Less
+of an advantage over competing non-free programs.  These disadvantages
+are the reason we use the ordinary General Public License for many
+libraries.  However, the Lesser license provides advantages in certain
+special circumstances.
+
+  For example, on rare occasions, there may be a special need to
+encourage the widest possible use of a certain library, so that it becomes
+a de-facto standard.  To achieve this, non-free programs must be
+allowed to use the library.  A more frequent case is that a free
+library does the same job as widely used non-free libraries.  In this
+case, there is little to gain by limiting the free library to free
+software only, so we use the Lesser General Public License.
+
+  In other cases, permission to use a particular library in non-free
+programs enables a greater number of people to use a large body of
+free software.  For example, permission to use the GNU C Library in
+non-free programs enables many more people to use the whole GNU
+operating system, as well as its variant, the GNU/Linux operating
+system.
+
+  Although the Lesser General Public License is Less protective of the
+users' freedom, it does ensure that the user of a program that is
+linked with the Library has the freedom and the wherewithal to run
+that program using a modified version of the Library.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.  Pay close attention to the difference between a
+"work based on the library" and a "work that uses the library".  The
+former contains code derived from the library, whereas the latter must
+be combined with the library in order to run.
+
+
+
+		  GNU LESSER GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License Agreement applies to any software library or other
+program which contains a notice placed by the copyright holder or
+other authorized party saying it may be distributed under the terms of
+this Lesser General Public License (also called "this License").
+Each licensee is addressed as "you".
+
+  A "library" means a collection of software functions and/or data
+prepared so as to be conveniently linked with application programs
+(which use some of those functions and data) to form executables.
+
+  The "Library", below, refers to any such software library or work
+which has been distributed under these terms.  A "work based on the
+Library" means either the Library or any derivative work under
+copyright law: that is to say, a work containing the Library or a
+portion of it, either verbatim or with modifications and/or translated
+straightforwardly into another language.  (Hereinafter, translation is
+included without limitation in the term "modification".)
+
+  "Source code" for a work means the preferred form of the work for
+making modifications to it.  For a library, complete source code means
+all the source code for all modules it contains, plus any associated
+interface definition files, plus the scripts used to control compilation
+and installation of the library.
+
+  Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running a program using the Library is not restricted, and output from
+such a program is covered only if its contents constitute a work based
+on the Library (independent of the use of the Library in a tool for
+writing it).  Whether that is true depends on what the Library does
+and what the program that uses the Library does.
+
+  1. You may copy and distribute verbatim copies of the Library's
+complete source code as you receive it, in any medium, provided that
+you conspicuously and appropriately publish on each copy an
+appropriate copyright notice and disclaimer of warranty; keep intact
+all the notices that refer to this License and to the absence of any
+warranty; and distribute a copy of this License along with the
+Library.
+  You may charge a fee for the physical act of transferring a copy,
+and you may at your option offer warranty protection in exchange for a
+fee.
+
+  2. You may modify your copy or copies of the Library or any portion
+of it, thus forming a work based on the Library, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) The modified work must itself be a software library.
+
+    b) You must cause the files modified to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    c) You must cause the whole of the work to be licensed at no
+    charge to all third parties under the terms of this License.
+
+    d) If a facility in the modified Library refers to a function or a
+    table of data to be supplied by an application program that uses
+    the facility, other than as an argument passed when the facility
+    is invoked, then you must make a good faith effort to ensure that,
+    in the event an application does not supply such function or
+    table, the facility still operates, and performs whatever part of
+    its purpose remains meaningful.
+
+    (For example, a function in a library to compute square roots has
+    a purpose that is entirely well-defined independent of the
+    application.  Therefore, Subsection 2d requires that any
+    application-supplied function or table used by this function must
+    be optional: if the application does not supply it, the square
+    root function must still compute square roots.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Library,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Library, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote
+it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Library.
+
+In addition, mere aggregation of another work not based on the Library
+with the Library (or with a work based on the Library) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may opt to apply the terms of the ordinary GNU General Public
+License instead of this License to a given copy of the Library.  To do
+this, you must alter all the notices that refer to this License, so
+that they refer to the ordinary GNU General Public License, version 2,
+instead of to this License.  (If a newer version than version 2 of the
+ordinary GNU General Public License has appeared, then you can specify
+that version instead if you wish.)  Do not make any other change in
+these notices.
+
+  Once this change is made in a given copy, it is irreversible for
+that copy, so the ordinary GNU General Public License applies to all
+subsequent copies and derivative works made from that copy.
+
+  This option is useful when you wish to copy part of the code of
+the Library into a program that is not a library.
+
+  4. You may copy and distribute the Library (or a portion or
+derivative of it, under Section 2) in object code or executable form
+under the terms of Sections 1 and 2 above provided that you accompany
+it with the complete corresponding machine-readable source code, which
+must be distributed under the terms of Sections 1 and 2 above on a
+medium customarily used for software interchange.
+
+  If distribution of object code is made by offering access to copy
+from a designated place, then offering equivalent access to copy the
+source code from the same place satisfies the requirement to
+distribute the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  5. A program that contains no derivative of any portion of the
+Library, but is designed to work with the Library by being compiled or
+linked with it, is called a "work that uses the Library".  Such a
+work, in isolation, is not a derivative work of the Library, and
+therefore falls outside the scope of this License.
+
+  However, linking a "work that uses the Library" with the Library
+creates an executable that is a derivative of the Library (because it
+contains portions of the Library), rather than a "work that uses the
+library".  The executable is therefore covered by this License.
+Section 6 states terms for distribution of such executables.
+
+  When a "work that uses the Library" uses material from a header file
+that is part of the Library, the object code for the work may be a
+derivative work of the Library even though the source code is not.
+Whether this is true is especially significant if the work can be
+linked without the Library, or if the work is itself a library.  The
+threshold for this to be true is not precisely defined by law.
+
+  If such an object file uses only numerical parameters, data
+structure layouts and accessors, and small macros and small inline
+functions (ten lines or less in length), then the use of the object
+file is unrestricted, regardless of whether it is legally a derivative
+work.  (Executables containing this object code plus portions of the
+Library will still fall under Section 6.)
+
+  Otherwise, if the work is a derivative of the Library, you may
+distribute the object code for the work under the terms of Section 6.
+Any executables containing that work also fall under Section 6,
+whether or not they are linked directly with the Library itself.
+
+  6. As an exception to the Sections above, you may also combine or
+link a "work that uses the Library" with the Library to produce a
+work containing portions of the Library, and distribute that work
+under terms of your choice, provided that the terms permit
+modification of the work for the customer's own use and reverse
+engineering for debugging such modifications.
+
+  You must give prominent notice with each copy of the work that the
+Library is used in it and that the Library and its use are covered by
+this License.  You must supply a copy of this License.  If the work
+during execution displays copyright notices, you must include the
+copyright notice for the Library among them, as well as a reference
+directing the user to the copy of this License.  Also, you must do one
+of these things:
+
+    a) Accompany the work with the complete corresponding
+    machine-readable source code for the Library including whatever
+    changes were used in the work (which must be distributed under
+    Sections 1 and 2 above); and, if the work is an executable linked
+    with the Library, with the complete machine-readable "work that
+    uses the Library", as object code and/or source code, so that the
+    user can modify the Library and then relink to produce a modified
+    executable containing the modified Library.  (It is understood
+    that the user who changes the contents of definitions files in the
+    Library will not necessarily be able to recompile the application
+    to use the modified definitions.)
+
+    b) Use a suitable shared library mechanism for linking with the
+    Library.  A suitable mechanism is one that (1) uses at run time a
+    copy of the library already present on the user's computer system,
+    rather than copying library functions into the executable, and (2)
+    will operate properly with a modified version of the library, if
+    the user installs one, as long as the modified version is
+    interface-compatible with the version that the work was made with.
+
+    c) Accompany the work with a written offer, valid for at
+    least three years, to give the same user the materials
+    specified in Subsection 6a, above, for a charge no more
+    than the cost of performing this distribution.
+
+    d) If distribution of the work is made by offering access to copy
+    from a designated place, offer equivalent access to copy the above
+    specified materials from the same place.
+
+    e) Verify that the user has already received a copy of these
+    materials or that you have already sent this user a copy.
+
+  For an executable, the required form of the "work that uses the
+Library" must include any data and utility programs needed for
+reproducing the executable from it.  However, as a special exception,
+the materials to be distributed need not include anything that is
+normally distributed (in either source or binary form) with the major
+components (compiler, kernel, and so on) of the operating system on
+which the executable runs, unless that component itself accompanies
+the executable.
+
+  It may happen that this requirement contradicts the license
+restrictions of other proprietary libraries that do not normally
+accompany the operating system.  Such a contradiction means you cannot
+use both them and the Library together in an executable that you
+distribute.
+
+  7. You may place library facilities that are a work based on the
+Library side-by-side in a single library together with other library
+facilities not covered by this License, and distribute such a combined
+library, provided that the separate distribution of the work based on
+the Library and of the other library facilities is otherwise
+permitted, and provided that you do these two things:
+
+    a) Accompany the combined library with a copy of the same work
+    based on the Library, uncombined with any other library
+    facilities.  This must be distributed under the terms of the
+    Sections above.
+
+    b) Give prominent notice with the combined library of the fact
+    that part of it is a work based on the Library, and explaining
+    where to find the accompanying uncombined form of the same work.
+
+  8. You may not copy, modify, sublicense, link with, or distribute
+the Library except as expressly provided under this License.  Any
+attempt otherwise to copy, modify, sublicense, link with, or
+distribute the Library is void, and will automatically terminate your
+rights under this License.  However, parties who have received copies,
+or rights, from you under this License will not have their licenses
+terminated so long as such parties remain in full compliance.
+
+  9. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Library or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Library (or any work based on the
+Library), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Library or works based on it.
+
+  10. Each time you redistribute the Library (or any work based on the
+Library), the recipient automatically receives a license from the
+original licensor to copy, distribute, link with or modify the Library
+subject to these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties with
+this License.
+
+  11. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Library at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Library by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Library.
+
+If any portion of this section is held invalid or unenforceable under any
+particular circumstance, the balance of the section is intended to apply,
+and the section as a whole is intended to apply in other circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  12. If the distribution and/or use of the Library is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Library under this License may add
+an explicit geographical distribution limitation excluding those countries,
+so that distribution is permitted only in or among countries not thus
+excluded.  In such case, this License incorporates the limitation as if
+written in the body of this License.
+
+  13. The Free Software Foundation may publish revised and/or new
+versions of the Lesser General Public License from time to time.
+Such new versions will be similar in spirit to the present version,
+but may differ in detail to address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Library
+specifies a version number of this License which applies to it and
+"any later version", you have the option of following the terms and
+conditions either of that version or of any later version published by
+the Free Software Foundation.  If the Library does not specify a
+license version number, you may choose any version ever published by
+the Free Software Foundation.
+
+  14. If you wish to incorporate parts of the Library into other free
+programs whose distribution conditions are incompatible with these,
+write to the author to ask for permission.  For software which is
+copyrighted by the Free Software Foundation, write to the Free
+Software Foundation; we sometimes make exceptions for this.  Our
+decision will be guided by the two goals of preserving the free status
+of all derivatives of our free software and of promoting the sharing
+and reuse of software generally.
+
+			    NO WARRANTY
+
+  15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
+WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
+EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
+OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
+KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
+LIBRARY IS WITH YOU.  SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
+THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
+WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
+AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
+FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
+CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
+LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
+RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
+FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
+SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
+DAMAGES.
+
+		     END OF TERMS AND CONDITIONS
+
+           How to Apply These Terms to Your New Libraries
+
+  If you develop a new library, and you want it to be of the greatest
+possible use to the public, we recommend making it free software that
+everyone can redistribute and change.  You can do so by permitting
+redistribution under these terms (or, alternatively, under the terms of the
+ordinary General Public License).
+
+  To apply these terms, attach the following notices to the library.  It is
+safest to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least the
+"copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the library's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+Also add information on how to contact you by electronic and paper mail.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the library, if
+necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the
+  library `Frob' (a library for tweaking knobs) written by James Random Hacker.
+
+  <signature of Ty Coon>, 1 April 1990
+  Ty Coon, President of Vice
+
+That's all there is to it!

myenv/Lib/site-packages/adodbapi/process_connect_string.py

@@ -0,0 +1,137 @@
+""" a clumsy attempt at a macro language to let the programmer execute code on the server (ex: determine 64bit)"""
+
+from . import is64bit
+
+
+def macro_call(macro_name, args, kwargs):
+    """allow the programmer to perform limited processing on the server by passing macro names and args
+
+    :new_key - the key name the macro will create
+    :args[0] - macro name
+    :args[1:] - any arguments
+    :code - the value of the keyword item
+    :kwargs - the connection keyword dictionary. ??key has been removed
+    --> the value to put in for kwargs['name'] = value
+    """
+    if isinstance(args, (str, str)):
+        args = [
+            args
+        ]  # the user forgot to pass a sequence, so make a string into args[0]
+    new_key = args[0]
+    try:
+        if macro_name == "is64bit":
+            if is64bit.Python():  # if on 64 bit Python
+                return new_key, args[1]  # return first argument
+            else:
+                try:
+                    return new_key, args[2]  # else return second argument (if defined)
+                except IndexError:
+                    return new_key, ""  # else return blank
+
+        elif (
+            macro_name == "getuser"
+        ):  # get the name of the user the server is logged in under
+            if not new_key in kwargs:
+                import getpass
+
+                return new_key, getpass.getuser()
+
+        elif macro_name == "getnode":  # get the name of the computer running the server
+            import platform
+
+            try:
+                return new_key, args[1] % platform.node()
+            except IndexError:
+                return new_key, platform.node()
+
+        elif macro_name == "getenv":  # expand the server's environment variable args[1]
+            try:
+                dflt = args[2]  # if not found, default from args[2]
+            except IndexError:  # or blank
+                dflt = ""
+            return new_key, os.environ.get(args[1], dflt)
+
+        elif macro_name == "auto_security":
+            if (
+                not "user" in kwargs or not kwargs["user"]
+            ):  # missing, blank, or Null username
+                return new_key, "Integrated Security=SSPI"
+            return new_key, "User ID=%(user)s; Password=%(password)s" % kwargs
+
+        elif (
+            macro_name == "find_temp_test_path"
+        ):  # helper function for testing ado operation -- undocumented
+            import os
+            import tempfile
+
+            return new_key, os.path.join(
+                tempfile.gettempdir(), "adodbapi_test", args[1]
+            )
+
+        raise ValueError(f"Unknown connect string macro={macro_name}")
+    except:
+        raise ValueError(f"Error in macro processing {macro_name} {args!r}")
+
+
+def process(
+    args, kwargs, expand_macros=False
+):  # --> connection string with keyword arguments processed.
+    """attempts to inject arguments into a connection string using Python "%" operator for strings
+
+    co: adodbapi connection object
+    args: positional parameters from the .connect() call
+    kvargs: keyword arguments from the .connect() call
+    """
+    try:
+        dsn = args[0]
+    except IndexError:
+        dsn = None
+    if isinstance(
+        dsn, dict
+    ):  # as a convenience the first argument may be django settings
+        kwargs.update(dsn)
+    elif (
+        dsn
+    ):  # the connection string is passed to the connection as part of the keyword dictionary
+        kwargs["connection_string"] = dsn
+    try:
+        a1 = args[1]
+    except IndexError:
+        a1 = None
+    # historically, the second positional argument might be a timeout value
+    if isinstance(a1, int):
+        kwargs["timeout"] = a1
+    # if the second positional argument is a string, then it is user
+    elif isinstance(a1, str):
+        kwargs["user"] = a1
+    # if the second positional argument is a dictionary, use it as keyword arguments, too
+    elif isinstance(a1, dict):
+        kwargs.update(a1)
+    try:
+        kwargs["password"] = args[2]  # the third positional argument is password
+        kwargs["host"] = args[3]  # the fourth positional argument is host name
+        kwargs["database"] = args[4]  # the fifth positional argument is database name
+    except IndexError:
+        pass
+
+    # make sure connection string is defined somehow
+    if not "connection_string" in kwargs:
+        try:  # perhaps 'dsn' was defined
+            kwargs["connection_string"] = kwargs["dsn"]
+        except KeyError:
+            try:  # as a last effort, use the "host" keyword
+                kwargs["connection_string"] = kwargs["host"]
+            except KeyError:
+                raise TypeError("Must define 'connection_string' for ado connections")
+    if expand_macros:
+        for kwarg in list(kwargs.keys()):
+            if kwarg.startswith("macro_"):  # If a key defines a macro
+                macro_name = kwarg[6:]  # name without the "macro_"
+                macro_code = kwargs.pop(
+                    kwarg
+                )  # we remove the macro_key and get the code to execute
+                new_key, rslt = macro_call(
+                    macro_name, macro_code, kwargs
+                )  # run the code in the local context
+                kwargs[new_key] = rslt  # put the result back in the keywords dict
+    return kwargs

myenv/Lib/site-packages/adodbapi/readme.txt

@@ -0,0 +1,87 @@
+Project
+-------
+adodbapi
+
+A Python DB-API 2.0 (PEP-249) module that makes it easy to use Microsoft ADO
+for connecting with databases and other data sources using CPython.
+
+Home page: <http://sourceforge.net/projects/adodbapi>
+
+Features:
+* 100% DB-API 2.0 (PEP-249) compliant (including most extensions and recommendations).
+* Includes pyunit testcases that describe how to use the module.
+* Fully implemented in Python. -- runs in current versions of Python 3
+* Licensed under the LGPL license, which means that it can be used freely even in commercial programs subject to certain restrictions.
+* The user can choose between paramstyles: 'qmark' 'named' 'format' 'pyformat' 'dynamic'
+* Supports data retrieval by column name e.g.:
+  for row in myCurser.execute("select name,age from students"):
+     print("Student", row.name, "is", row.age, "years old.")
+* Supports user-definable system-to-Python data conversion functions (selected by ADO data type, or by column)
+
+Prerequisites:
+* C Python 3.6 or higher
+ and pywin32 (Mark Hammond's python for windows extensions.)
+
+Installation:
+* (C-Python on Windows): Install pywin32 ("pip install pywin32") which includes adodbapi.
+* (IronPython on Windows): Download adodbapi from http://sf.net/projects/adodbapi.  Unpack the zip.
+
+NOTE: ...........
+If you do not like the new default operation of returning Numeric columns as decimal.Decimal,
+you can select other options by the user defined conversion feature.
+Try:
+        adodbapi.apibase.variantConversions[adodbapi.ado_consts.adNumeric] = adodbapi.apibase.cvtString
+or:
+        adodbapi.apibase.variantConversions[adodbapi.ado_consts.adNumeric] = adodbapi.apibase.cvtFloat
+or:
+        adodbapi.apibase.variantConversions[adodbapi.ado_consts.adNumeric] = write_your_own_convertion_function
+		............
+notes for 2.6.2:
+    The definitive source has been moved to https://github.com/mhammond/pywin32/tree/master/adodbapi.
+    Remote has proven too hard to configure and test with Pyro4. I am moving it to unsupported status
+    until I can change to a different connection method.
+what's new in version 2.6
+   A cursor.prepare() method and support for prepared SQL statements.
+   Lots of refactoring, especially of the Remote and Server modules (still to be treated as Beta code).
+   The quick start document 'quick_reference.odt' will export as a nice-looking pdf.
+   Added paramstyles 'pyformat' and 'dynamic'. If your 'paramstyle' is 'named' you _must_ pass a dictionary of
+      parameters to your .execute() method. If your 'paramstyle' is 'format' 'pyformat' or 'dynamic', you _may_
+      pass a dictionary of parameters -- provided your SQL operation string is formatted correctly.
+
+what's new in version 2.5
+   Remote module: (works on Linux!) allows a Windows computer to serve ADO databases via PyRO
+   Server module: PyRO server for ADO.  Run using a command like= C:>python -m adodbapi.server
+   (server has simple connection string macros: is64bit, getuser, sql_provider, auto_security)
+   Brief documentation included.  See adodbapi/examples folder adodbapi.rtf
+   New connection method conn.get_table_names() --> list of names of tables in database
+
+   Vastly refactored. Data conversion things have been moved to the new adodbapi.apibase module.
+   Many former module-level attributes are now class attributes. (Should be more thread-safe)
+   Connection objects are now context managers for transactions and will commit or rollback.
+   Cursor objects are context managers and will automatically close themselves.
+   Autocommit can be switched on and off.
+   Keyword and positional arguments on the connect() method work as documented in PEP 249.
+   Keyword arguments from the connect call can be formatted into the connection string.
+   New keyword arguments defined, such as: autocommit, paramstyle, remote_proxy, remote_port.
+  *** Breaking change: variantConversion lookups are simplified: the following will raise KeyError:
+         oldconverter=adodbapi.variantConversions[adodbapi.adoStringTypes]
+      Refactor as: oldconverter=adodbapi.variantConversions[adodbapi.adoStringTypes[0]]
+
+License
+-------
+LGPL, see http://www.opensource.org/licenses/lgpl-license.php
+
+Documentation
+-------------
+
+Look at adodbapi/quick_reference.md
+http://www.python.org/topics/database/DatabaseAPI-2.0.html
+read the examples in adodbapi/examples
+and look at the test cases in adodbapi/test directory.
+
+Mailing lists
+-------------
+The adodbapi mailing lists have been deactivated. Submit comments to the
+pywin32 mailing lists.
+  -- the bug tracker on sourceforge.net/projects/adodbapi may be checked, (infrequently).
+  -- please use: https://github.com/mhammond/pywin32/issues

myenv/Lib/site-packages/adodbapi/schema_table.py

@@ -0,0 +1,16 @@
+"""call using an open ADO connection --> list of table names"""
+
+from . import adodbapi
+
+
+def names(connection_object):
+    ado = connection_object.adoConn
+    schema = ado.OpenSchema(20)  # constant = adSchemaTables
+
+    tables = []
+    while not schema.EOF:
+        name = adodbapi.getIndexedValue(schema.Fields, "TABLE_NAME").Value
+        tables.append(name)
+        schema.MoveNext()
+    del schema
+    return tables

myenv/Lib/site-packages/adodbapi/setup.py

@@ -0,0 +1,68 @@
+"""adodbapi -- a pure Python PEP 249 DB-API package using Microsoft ADO
+
+Adodbapi can be run on CPython 3.5 and later.
+"""
+
+NAME = "adodbapi"
+MAINTAINER = "Vernon Cole"
+MAINTAINER_EMAIL = "vernondcole@gmail.com"
+DESCRIPTION = (
+    """A pure Python package implementing PEP 249 DB-API using Microsoft ADO."""
+)
+URL = "http://sourceforge.net/projects/adodbapi"
+LICENSE = "LGPL"
+CLASSIFIERS = [
+    "Development Status :: 5 - Production/Stable",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: GNU Library or Lesser General Public License (LGPL)",
+    "Operating System :: Microsoft :: Windows",
+    "Operating System :: POSIX :: Linux",
+    "Programming Language :: Python",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: SQL",
+    "Topic :: Software Development",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+    "Topic :: Database",
+]
+AUTHOR = "Henrik Ekelund, Vernon Cole, et.al."
+AUTHOR_EMAIL = "vernondcole@gmail.com"
+PLATFORMS = ["Windows", "Linux"]
+
+VERSION = None  # in case searching for version fails
+a = open("adodbapi.py")  # find the version string in the source code
+for line in a:
+    if "__version__" in line:
+        VERSION = line.split("'")[1]
+        print('adodbapi version="%s"' % VERSION)
+        break
+a.close()
+
+
+def setup_package():
+    from setuptools import setup
+    from setuptools.command.build_py import build_py
+
+    setup(
+        cmdclass={"build_py": build_py},
+        name=NAME,
+        maintainer=MAINTAINER,
+        maintainer_email=MAINTAINER_EMAIL,
+        description=DESCRIPTION,
+        url=URL,
+        keywords="database ado odbc dbapi db-api Microsoft SQL",
+        ##        download_url=DOWNLOAD_URL,
+        long_description=open("README.txt").read(),
+        license=LICENSE,
+        classifiers=CLASSIFIERS,
+        author=AUTHOR,
+        author_email=AUTHOR_EMAIL,
+        platforms=PLATFORMS,
+        version=VERSION,
+        package_dir={"adodbapi": ""},
+        packages=["adodbapi"],
+    )
+    return
+
+
+if __name__ == "__main__":
+    setup_package()

myenv/Lib/site-packages/adodbapi/test/adodbapitest.py

@@ -0,0 +1,1599 @@
+""" Unit tests version 2.6.1.0 for adodbapi"""
+
+"""
+    adodbapi - A python DB API 2.0 interface to Microsoft ADO
+
+    Copyright (C) 2002  Henrik Ekelund
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+    Updates by Vernon Cole
+"""
+
+import copy
+import datetime
+import decimal
+import random
+import string
+import sys
+import time
+import unittest
+
+import adodbapitestconfig as config  # run the configuration module. # will set sys.path to find correct version of adodbapi
+import tryconnection  # in our code below, all our switches are from config.whatever
+import win32com.client
+
+import adodbapi
+import adodbapi.apibase as api
+
+try:
+    import adodbapi.ado_consts as ado_consts
+except ImportError:  # we are doing a shortcut import as a module -- so
+    try:
+        import ado_consts
+    except ImportError:
+        from adodbapi import ado_consts
+
+
+def randomstring(length):
+    return "".join([random.choice(string.ascii_letters) for n in range(32)])
+
+
+class CommonDBTests(unittest.TestCase):
+    "Self contained super-simple tests in easy syntax, should work on everything between mySQL and Oracle"
+
+    def setUp(self):
+        self.engine = "unknown"
+
+    def getEngine(self):
+        return self.engine
+
+    def getConnection(self):
+        raise NotImplementedError  # "This method must be overriden by a subclass"
+
+    def getCursor(self):
+        return self.getConnection().cursor()
+
+    def testConnection(self):
+        crsr = self.getCursor()
+        assert crsr.__class__.__name__ == "Cursor"
+
+    def testErrorHandlerInherits(self):
+        conn = self.getConnection()
+        mycallable = lambda connection, cursor, errorclass, errorvalue: 1
+        conn.errorhandler = mycallable
+        crsr = conn.cursor()
+        assert (
+            crsr.errorhandler == mycallable
+        ), "Error handler on crsr should be same as on connection"
+
+    def testDefaultErrorHandlerConnection(self):
+        conn = self.getConnection()
+        del conn.messages[:]
+        try:
+            conn.close()
+            conn.commit()  # Should not be able to use connection after it is closed
+        except:
+            assert len(conn.messages) == 1
+            assert len(conn.messages[0]) == 2
+            assert conn.messages[0][0] == api.ProgrammingError
+
+    def testOwnErrorHandlerConnection(self):
+        mycallable = (
+            lambda connection, cursor, errorclass, errorvalue: 1
+        )  # does not raise anything
+        conn = self.getConnection()
+        conn.errorhandler = mycallable
+        conn.close()
+        conn.commit()  # Should not be able to use connection after it is closed
+        assert len(conn.messages) == 0
+
+        conn.errorhandler = None  # This should bring back the standard error handler
+        try:
+            conn.close()
+            conn.commit()  # Should not be able to use connection after it is closed
+        except:
+            pass
+        # The Standard errorhandler appends error to messages attribute
+        assert (
+            len(conn.messages) > 0
+        ), "Setting errorhandler to none  should bring back the standard error handler"
+
+    def testDefaultErrorHandlerCursor(self):
+        crsr = self.getConnection().cursor()
+        del crsr.messages[:]
+        try:
+            crsr.execute("SELECT abbtytddrf FROM dasdasd")
+        except:
+            assert len(crsr.messages) == 1
+            assert len(crsr.messages[0]) == 2
+            assert crsr.messages[0][0] == api.DatabaseError
+
+    def testOwnErrorHandlerCursor(self):
+        mycallable = (
+            lambda connection, cursor, errorclass, errorvalue: 1
+        )  # does not raise anything
+        crsr = self.getConnection().cursor()
+        crsr.errorhandler = mycallable
+        crsr.execute("SELECT abbtytddrf FROM dasdasd")
+        assert len(crsr.messages) == 0
+
+        crsr.errorhandler = None  # This should bring back the standard error handler
+        try:
+            crsr.execute("SELECT abbtytddrf FROM dasdasd")
+        except:
+            pass
+        # The Standard errorhandler appends error to messages attribute
+        assert (
+            len(crsr.messages) > 0
+        ), "Setting errorhandler to none  should bring back the standard error handler"
+
+    def testUserDefinedConversions(self):
+        try:
+            duplicatingConverter = lambda aStringField: aStringField * 2
+            assert duplicatingConverter("gabba") == "gabbagabba"
+
+            self.helpForceDropOnTblTemp()
+            conn = self.getConnection()
+            # the variantConversions attribute should not exist on a normal connection object
+            self.assertRaises(AttributeError, lambda x: conn.variantConversions[x], [2])
+            # create a variantConversions attribute on the connection
+            conn.variantConversions = copy.copy(api.variantConversions)
+            crsr = conn.cursor()
+            tabdef = (
+                "CREATE TABLE xx_%s (fldData VARCHAR(100) NOT NULL, fld2 VARCHAR(20))"
+                % config.tmp
+            )
+            crsr.execute(tabdef)
+            crsr.execute(
+                "INSERT INTO xx_%s(fldData,fld2) VALUES('gabba','booga')" % config.tmp
+            )
+            crsr.execute(
+                "INSERT INTO xx_%s(fldData,fld2) VALUES('hey','yo')" % config.tmp
+            )
+            # change converter for ALL adoStringTypes columns
+            conn.variantConversions[api.adoStringTypes] = duplicatingConverter
+            crsr.execute("SELECT fldData,fld2 FROM xx_%s ORDER BY fldData" % config.tmp)
+
+            rows = crsr.fetchall()
+            row = rows[0]
+            self.assertEqual(row[0], "gabbagabba")
+            row = rows[1]
+            self.assertEqual(row[0], "heyhey")
+            self.assertEqual(row[1], "yoyo")
+
+            upcaseConverter = lambda aStringField: aStringField.upper()
+            assert upcaseConverter("upThis") == "UPTHIS"
+
+            # now use a single column converter
+            rows.converters[1] = upcaseConverter  # convert second column
+            self.assertEqual(row[0], "heyhey")  # first will be unchanged
+            self.assertEqual(row[1], "YO")  # second will convert to upper case
+
+        finally:
+            try:
+                del conn.variantConversions  # Restore the default
+            except:
+                pass
+            self.helpRollbackTblTemp()
+
+    def testUserDefinedConversionForExactNumericTypes(self):
+        # variantConversions is a dictionary of conversion functions
+        # held internally in adodbapi.apibase
+        #
+        # !!! this test intentionally alters the value of what should be constant in the module
+        # !!! no new code should use this example, to is only a test to see that the
+        # !!! deprecated way of doing this still works.  (use connection.variantConversions)
+        #
+        if sys.version_info < (3, 0):  ### Py3 need different test
+            oldconverter = adodbapi.variantConversions[
+                ado_consts.adNumeric
+            ]  # keep old function to restore later
+            # By default decimal and "numbers" are returned as decimals.
+            # Instead, make numbers return as  floats
+            try:
+                adodbapi.variantConversions[ado_consts.adNumeric] = adodbapi.cvtFloat
+                self.helpTestDataType(
+                    "decimal(18,2)", "NUMBER", 3.45, compareAlmostEqual=1
+                )
+                self.helpTestDataType(
+                    "numeric(18,2)", "NUMBER", 3.45, compareAlmostEqual=1
+                )
+                # now return strings
+                adodbapi.variantConversions[ado_consts.adNumeric] = adodbapi.cvtString
+                self.helpTestDataType("numeric(18,2)", "NUMBER", "3.45")
+                # now a completly weird user defined convertion
+                adodbapi.variantConversions[ado_consts.adNumeric] = (
+                    lambda x: "!!This function returns a funny unicode string %s!!" % x
+                )
+                self.helpTestDataType(
+                    "numeric(18,2)",
+                    "NUMBER",
+                    "3.45",
+                    allowedReturnValues=[
+                        "!!This function returns a funny unicode string 3.45!!"
+                    ],
+                )
+            finally:
+                # now reset the converter to its original function
+                adodbapi.variantConversions[ado_consts.adNumeric] = (
+                    oldconverter  # Restore the original convertion function
+                )
+
+    def helpTestDataType(
+        self,
+        sqlDataTypeString,
+        DBAPIDataTypeString,
+        pyData,
+        pyDataInputAlternatives=None,
+        compareAlmostEqual=None,
+        allowedReturnValues=None,
+    ):
+        self.helpForceDropOnTblTemp()
+        conn = self.getConnection()
+        crsr = conn.cursor()
+        tabdef = (
+            """
+            CREATE TABLE xx_%s (
+                fldId integer NOT NULL,
+                fldData """
+            % config.tmp
+            + sqlDataTypeString
+            + ")\n"
+        )
+
+        crsr.execute(tabdef)
+
+        # Test Null values mapped to None
+        crsr.execute("INSERT INTO xx_%s (fldId) VALUES (1)" % config.tmp)
+
+        crsr.execute("SELECT fldId,fldData FROM xx_%s" % config.tmp)
+        rs = crsr.fetchone()
+        self.assertEqual(rs[1], None)  # Null should be mapped to None
+        assert rs[0] == 1
+
+        # Test description related
+        descTuple = crsr.description[1]
+        assert descTuple[0] in ["fldData", "flddata"], 'was "%s" expected "%s"' % (
+            descTuple[0],
+            "fldData",
+        )
+
+        if DBAPIDataTypeString == "STRING":
+            assert descTuple[1] == api.STRING, 'was "%s" expected "%s"' % (
+                descTuple[1],
+                api.STRING.values,
+            )
+        elif DBAPIDataTypeString == "NUMBER":
+            assert descTuple[1] == api.NUMBER, 'was "%s" expected "%s"' % (
+                descTuple[1],
+                api.NUMBER.values,
+            )
+        elif DBAPIDataTypeString == "BINARY":
+            assert descTuple[1] == api.BINARY, 'was "%s" expected "%s"' % (
+                descTuple[1],
+                api.BINARY.values,
+            )
+        elif DBAPIDataTypeString == "DATETIME":
+            assert descTuple[1] == api.DATETIME, 'was "%s" expected "%s"' % (
+                descTuple[1],
+                api.DATETIME.values,
+            )
+        elif DBAPIDataTypeString == "ROWID":
+            assert descTuple[1] == api.ROWID, 'was "%s" expected "%s"' % (
+                descTuple[1],
+                api.ROWID.values,
+            )
+        elif DBAPIDataTypeString == "UUID":
+            assert descTuple[1] == api.OTHER, 'was "%s" expected "%s"' % (
+                descTuple[1],
+                api.OTHER.values,
+            )
+        else:
+            raise NotImplementedError  # "DBAPIDataTypeString not provided"
+
+        # Test data binding
+        inputs = [pyData]
+        if pyDataInputAlternatives:
+            inputs.extend(pyDataInputAlternatives)
+        inputs = set(inputs)  # removes redundant string==unicode tests
+        fldId = 1
+        for inParam in inputs:
+            fldId += 1
+            try:
+                crsr.execute(
+                    "INSERT INTO xx_%s (fldId,fldData) VALUES (?,?)" % config.tmp,
+                    (fldId, inParam),
+                )
+            except:
+                conn.printADOerrors()
+                raise
+            crsr.execute(
+                "SELECT fldData FROM xx_%s WHERE ?=fldID" % config.tmp, [fldId]
+            )
+            rs = crsr.fetchone()
+            if allowedReturnValues:
+                allowedTypes = tuple([type(aRV) for aRV in allowedReturnValues])
+                assert isinstance(
+                    rs[0], allowedTypes
+                ), 'result type "%s" must be one of %s' % (type(rs[0]), allowedTypes)
+            else:
+                assert isinstance(
+                    rs[0], type(pyData)
+                ), 'result type "%s" must be instance of %s' % (
+                    type(rs[0]),
+                    type(pyData),
+                )
+
+            if compareAlmostEqual and DBAPIDataTypeString == "DATETIME":
+                iso1 = adodbapi.dateconverter.DateObjectToIsoFormatString(rs[0])
+                iso2 = adodbapi.dateconverter.DateObjectToIsoFormatString(pyData)
+                self.assertEqual(iso1, iso2)
+            elif compareAlmostEqual:
+                s = float(pyData)
+                v = float(rs[0])
+                assert (
+                    abs(v - s) / s < 0.00001
+                ), "Values not almost equal recvd=%s, expected=%f" % (rs[0], s)
+            else:
+                if allowedReturnValues:
+                    ok = False
+                    self.assertTrue(
+                        rs[0] in allowedReturnValues,
+                        f'Value "{rs[0]!r}" not in {allowedReturnValues}',
+                    )
+                else:
+                    self.assertEqual(
+                        rs[0],
+                        pyData,
+                        'Values are not equal recvd="%s", expected="%s"'
+                        % (rs[0], pyData),
+                    )
+
+    def testDataTypeFloat(self):
+        self.helpTestDataType("real", "NUMBER", 3.45, compareAlmostEqual=True)
+        self.helpTestDataType("float", "NUMBER", 1.79e37, compareAlmostEqual=True)
+
+    def testDataTypeDecmal(self):
+        self.helpTestDataType(
+            "decimal(18,2)",
+            "NUMBER",
+            3.45,
+            allowedReturnValues=["3.45", "3,45", decimal.Decimal("3.45")],
+        )
+        self.helpTestDataType(
+            "numeric(18,2)",
+            "NUMBER",
+            3.45,
+            allowedReturnValues=["3.45", "3,45", decimal.Decimal("3.45")],
+        )
+        self.helpTestDataType(
+            "decimal(20,2)",
+            "NUMBER",
+            444444444444444444,
+            allowedReturnValues=[
+                "444444444444444444.00",
+                "444444444444444444,00",
+                decimal.Decimal("444444444444444444"),
+            ],
+        )
+        if self.getEngine() == "MSSQL":
+            self.helpTestDataType(
+                "uniqueidentifier",
+                "UUID",
+                "{71A4F49E-39F3-42B1-A41E-48FF154996E6}",
+                allowedReturnValues=["{71A4F49E-39F3-42B1-A41E-48FF154996E6}"],
+            )
+
+    def testDataTypeMoney(self):  # v2.1 Cole -- use decimal for money
+        if self.getEngine() == "MySQL":
+            self.helpTestDataType(
+                "DECIMAL(20,4)", "NUMBER", decimal.Decimal("-922337203685477.5808")
+            )
+        elif self.getEngine() == "PostgreSQL":
+            self.helpTestDataType(
+                "money",
+                "NUMBER",
+                decimal.Decimal("-922337203685477.5808"),
+                compareAlmostEqual=True,
+                allowedReturnValues=[
+                    -922337203685477.5808,
+                    decimal.Decimal("-922337203685477.5808"),
+                ],
+            )
+        else:
+            self.helpTestDataType("smallmoney", "NUMBER", decimal.Decimal("214748.02"))
+            self.helpTestDataType(
+                "money", "NUMBER", decimal.Decimal("-922337203685477.5808")
+            )
+
+    def testDataTypeInt(self):
+        if self.getEngine() != "PostgreSQL":
+            self.helpTestDataType("tinyint", "NUMBER", 115)
+        self.helpTestDataType("smallint", "NUMBER", -32768)
+        if self.getEngine() not in ["ACCESS", "PostgreSQL"]:
+            self.helpTestDataType(
+                "bit", "NUMBER", 1
+            )  # Does not work correctly with access
+        if self.getEngine() in ["MSSQL", "PostgreSQL"]:
+            self.helpTestDataType(
+                "bigint",
+                "NUMBER",
+                3000000000,
+                allowedReturnValues=[3000000000, int(3000000000)],
+            )
+        self.helpTestDataType("int", "NUMBER", 2147483647)
+
+    def testDataTypeChar(self):
+        for sqlDataType in ("char(6)", "nchar(6)"):
+            self.helpTestDataType(
+                sqlDataType,
+                "STRING",
+                "spam  ",
+                allowedReturnValues=["spam", "spam", "spam  ", "spam  "],
+            )
+
+    def testDataTypeVarChar(self):
+        if self.getEngine() == "MySQL":
+            stringKinds = ["varchar(10)", "text"]
+        elif self.getEngine() == "PostgreSQL":
+            stringKinds = ["varchar(10)", "text", "character varying"]
+        else:
+            stringKinds = [
+                "varchar(10)",
+                "nvarchar(10)",
+                "text",
+                "ntext",
+            ]  # ,"varchar(max)"]
+
+        for sqlDataType in stringKinds:
+            self.helpTestDataType(sqlDataType, "STRING", "spam", ["spam"])
+
+    def testDataTypeDate(self):
+        if self.getEngine() == "PostgreSQL":
+            dt = "timestamp"
+        else:
+            dt = "datetime"
+        self.helpTestDataType(
+            dt, "DATETIME", adodbapi.Date(2002, 10, 28), compareAlmostEqual=True
+        )
+        if self.getEngine() not in ["MySQL", "PostgreSQL"]:
+            self.helpTestDataType(
+                "smalldatetime",
+                "DATETIME",
+                adodbapi.Date(2002, 10, 28),
+                compareAlmostEqual=True,
+            )
+        if tag != "pythontime" and self.getEngine() not in [
+            "MySQL",
+            "PostgreSQL",
+        ]:  # fails when using pythonTime
+            self.helpTestDataType(
+                dt,
+                "DATETIME",
+                adodbapi.Timestamp(2002, 10, 28, 12, 15, 1),
+                compareAlmostEqual=True,
+            )
+
+    def testDataTypeBinary(self):
+        binfld = b"\x07\x00\xE2\x40*"
+        arv = [binfld, adodbapi.Binary(binfld), bytes(binfld)]
+        if self.getEngine() == "PostgreSQL":
+            self.helpTestDataType(
+                "bytea", "BINARY", adodbapi.Binary(binfld), allowedReturnValues=arv
+            )
+        else:
+            self.helpTestDataType(
+                "binary(5)", "BINARY", adodbapi.Binary(binfld), allowedReturnValues=arv
+            )
+            self.helpTestDataType(
+                "varbinary(100)",
+                "BINARY",
+                adodbapi.Binary(binfld),
+                allowedReturnValues=arv,
+            )
+            if self.getEngine() != "MySQL":
+                self.helpTestDataType(
+                    "image", "BINARY", adodbapi.Binary(binfld), allowedReturnValues=arv
+                )
+
+    def helpRollbackTblTemp(self):
+        self.helpForceDropOnTblTemp()
+
+    def helpForceDropOnTblTemp(self):
+        conn = self.getConnection()
+        with conn.cursor() as crsr:
+            try:
+                crsr.execute("DROP TABLE xx_%s" % config.tmp)
+                if not conn.autocommit:
+                    conn.commit()
+            except:
+                pass
+
+    def helpCreateAndPopulateTableTemp(self, crsr):
+        tabdef = (
+            """
+            CREATE TABLE xx_%s (
+                fldData INTEGER
+            )
+            """
+            % config.tmp
+        )
+        try:  # EAFP
+            crsr.execute(tabdef)
+        except api.DatabaseError:  # was not dropped before
+            self.helpForceDropOnTblTemp()  # so drop it now
+            crsr.execute(tabdef)
+        for i in range(9):  # note: this poor SQL code, but a valid test
+            crsr.execute("INSERT INTO xx_%s (fldData) VALUES (%i)" % (config.tmp, i))
+            # NOTE: building the test table without using parameter substitution
+
+    def testFetchAll(self):
+        crsr = self.getCursor()
+        self.helpCreateAndPopulateTableTemp(crsr)
+        crsr.execute("SELECT fldData FROM xx_%s" % config.tmp)
+        rs = crsr.fetchall()
+        assert len(rs) == 9
+        # test slice of rows
+        i = 3
+        for row in rs[3:-2]:  # should have rowid 3..6
+            assert row[0] == i
+            i += 1
+        self.helpRollbackTblTemp()
+
+    def testPreparedStatement(self):
+        crsr = self.getCursor()
+        self.helpCreateAndPopulateTableTemp(crsr)
+        crsr.prepare("SELECT fldData FROM xx_%s" % config.tmp)
+        crsr.execute(crsr.command)  # remember the one that was prepared
+        rs = crsr.fetchall()
+        assert len(rs) == 9
+        assert rs[2][0] == 2
+        self.helpRollbackTblTemp()
+
+    def testWrongPreparedStatement(self):
+        crsr = self.getCursor()
+        self.helpCreateAndPopulateTableTemp(crsr)
+        crsr.prepare("SELECT * FROM nowhere")
+        crsr.execute(
+            "SELECT fldData FROM xx_%s" % config.tmp
+        )  # should execute this one, not the prepared one
+        rs = crsr.fetchall()
+        assert len(rs) == 9
+        assert rs[2][0] == 2
+        self.helpRollbackTblTemp()
+
+    def testIterator(self):
+        crsr = self.getCursor()
+        self.helpCreateAndPopulateTableTemp(crsr)
+        crsr.execute("SELECT fldData FROM xx_%s" % config.tmp)
+        for i, row in enumerate(
+            crsr
+        ):  # using cursor as an iterator, rather than fetchxxx
+            assert row[0] == i
+        self.helpRollbackTblTemp()
+
+    def testExecuteMany(self):
+        crsr = self.getCursor()
+        self.helpCreateAndPopulateTableTemp(crsr)
+        seq_of_values = [(111,), (222,)]
+        crsr.executemany(
+            "INSERT INTO xx_%s (fldData) VALUES (?)" % config.tmp, seq_of_values
+        )
+        if crsr.rowcount == -1:
+            print(
+                self.getEngine()
+                + " Provider does not support rowcount (on .executemany())"
+            )
+        else:
+            self.assertEqual(crsr.rowcount, 2)
+        crsr.execute("SELECT fldData FROM xx_%s" % config.tmp)
+        rs = crsr.fetchall()
+        assert len(rs) == 11
+        self.helpRollbackTblTemp()
+
+    def testRowCount(self):
+        crsr = self.getCursor()
+        self.helpCreateAndPopulateTableTemp(crsr)
+        crsr.execute("SELECT fldData FROM xx_%s" % config.tmp)
+        if crsr.rowcount == -1:
+            # print("provider does not support rowcount on select")
+            pass
+        else:
+            self.assertEqual(crsr.rowcount, 9)
+        self.helpRollbackTblTemp()
+
+    def testRowCountNoRecordset(self):
+        crsr = self.getCursor()
+        self.helpCreateAndPopulateTableTemp(crsr)
+        crsr.execute("DELETE FROM xx_%s WHERE fldData >= 5" % config.tmp)
+        if crsr.rowcount == -1:
+            print(self.getEngine() + " Provider does not support rowcount (on DELETE)")
+        else:
+            self.assertEqual(crsr.rowcount, 4)
+        self.helpRollbackTblTemp()
+
+    def testFetchMany(self):
+        crsr = self.getCursor()
+        self.helpCreateAndPopulateTableTemp(crsr)
+        crsr.execute("SELECT fldData FROM xx_%s" % config.tmp)
+        rs = crsr.fetchmany(3)
+        assert len(rs) == 3
+        rs = crsr.fetchmany(5)
+        assert len(rs) == 5
+        rs = crsr.fetchmany(5)
+        assert len(rs) == 1  # Asked for five, but there is only one left
+        self.helpRollbackTblTemp()
+
+    def testFetchManyWithArraySize(self):
+        crsr = self.getCursor()
+        self.helpCreateAndPopulateTableTemp(crsr)
+        crsr.execute("SELECT fldData FROM xx_%s" % config.tmp)
+        rs = crsr.fetchmany()
+        assert len(rs) == 1  # arraysize Defaults to one
+        crsr.arraysize = 4
+        rs = crsr.fetchmany()
+        assert len(rs) == 4
+        rs = crsr.fetchmany()
+        assert len(rs) == 4
+        rs = crsr.fetchmany()
+        assert len(rs) == 0
+        self.helpRollbackTblTemp()
+
+    def testErrorConnect(self):
+        conn = self.getConnection()
+        conn.close()
+        self.assertRaises(api.DatabaseError, self.db, "not a valid connect string", {})
+
+    def testRowIterator(self):
+        self.helpForceDropOnTblTemp()
+        conn = self.getConnection()
+        crsr = conn.cursor()
+        tabdef = (
+            """
+            CREATE TABLE xx_%s (
+                fldId integer NOT NULL,
+                fldTwo integer,
+                fldThree integer,
+                fldFour integer)
+                """
+            % config.tmp
+        )
+        crsr.execute(tabdef)
+
+        inputs = [(2, 3, 4), (102, 103, 104)]
+        fldId = 1
+        for inParam in inputs:
+            fldId += 1
+            try:
+                crsr.execute(
+                    "INSERT INTO xx_%s (fldId,fldTwo,fldThree,fldFour) VALUES (?,?,?,?)"
+                    % config.tmp,
+                    (fldId, inParam[0], inParam[1], inParam[2]),
+                )
+            except:
+                conn.printADOerrors()
+                raise
+            crsr.execute(
+                "SELECT fldTwo,fldThree,fldFour FROM xx_%s WHERE ?=fldID" % config.tmp,
+                [fldId],
+            )
+            rec = crsr.fetchone()
+            # check that stepping through an emulated row works
+            for j in range(len(inParam)):
+                assert (
+                    rec[j] == inParam[j]
+                ), 'returned value:"%s" != test value:"%s"' % (rec[j], inParam[j])
+            # check that we can get a complete tuple from a row
+            assert (
+                tuple(rec) == inParam
+            ), f'returned value:"{rec!r}" != test value:"{inParam!r}"'
+            # test that slices of rows work
+            slice1 = tuple(rec[:-1])
+            slice2 = tuple(inParam[0:2])
+            assert (
+                slice1 == slice2
+            ), f'returned value:"{slice1!r}" != test value:"{slice2!r}"'
+            # now test named column retrieval
+            assert rec["fldTwo"] == inParam[0]
+            assert rec.fldThree == inParam[1]
+            assert rec.fldFour == inParam[2]
+        # test array operation
+        # note that the fields vv        vv     vv    are out of order
+        crsr.execute("select fldThree,fldFour,fldTwo from xx_%s" % config.tmp)
+        recs = crsr.fetchall()
+        assert recs[1][0] == 103
+        assert recs[0][1] == 4
+        assert recs[1]["fldFour"] == 104
+        assert recs[0, 0] == 3
+        assert recs[0, "fldTwo"] == 2
+        assert recs[1, 2] == 102
+        for i in range(1):
+            for j in range(2):
+                assert recs[i][j] == recs[i, j]
+
+    def testFormatParamstyle(self):
+        self.helpForceDropOnTblTemp()
+        conn = self.getConnection()
+        conn.paramstyle = "format"  # test nonstandard use of paramstyle
+        crsr = conn.cursor()
+        tabdef = (
+            """
+            CREATE TABLE xx_%s (
+                fldId integer NOT NULL,
+                fldData varchar(10),
+                fldConst varchar(30))
+                """
+            % config.tmp
+        )
+        crsr.execute(tabdef)
+
+        inputs = ["one", "two", "three"]
+        fldId = 2
+        for inParam in inputs:
+            fldId += 1
+            sql = (
+                "INSERT INTO xx_"
+                + config.tmp
+                + " (fldId,fldConst,fldData) VALUES (%s,'thi%s :may cause? trouble', %s)"
+            )
+            try:
+                crsr.execute(sql, (fldId, inParam))
+            except:
+                conn.printADOerrors()
+                raise
+            crsr.execute(
+                "SELECT fldData, fldConst FROM xx_" + config.tmp + " WHERE %s=fldID",
+                [fldId],
+            )
+            rec = crsr.fetchone()
+            self.assertEqual(
+                rec[0],
+                inParam,
+                'returned value:"%s" != test value:"%s"' % (rec[0], inParam),
+            )
+            self.assertEqual(rec[1], "thi%s :may cause? trouble")
+
+        # now try an operation with a "%s" as part of a literal
+        sel = (
+            "insert into xx_" + config.tmp + " (fldId,fldData) VALUES (%s,'four%sfive')"
+        )
+        params = (20,)
+        crsr.execute(sel, params)
+
+        # test the .query implementation
+        assert "(?," in crsr.query, 'expected:"%s" in "%s"' % ("(?,", crsr.query)
+        # test the .command attribute
+        assert crsr.command == sel, 'expected:"%s" but found "%s"' % (sel, crsr.command)
+
+        # test the .parameters attribute
+        self.assertEqual(crsr.parameters, params)
+        # now make sure the data made it
+        crsr.execute("SELECT fldData FROM xx_%s WHERE fldID=20" % config.tmp)
+        rec = crsr.fetchone()
+        self.assertEqual(rec[0], "four%sfive")
+
+    def testNamedParamstyle(self):
+        self.helpForceDropOnTblTemp()
+        conn = self.getConnection()
+        crsr = conn.cursor()
+        crsr.paramstyle = "named"  # test nonstandard use of paramstyle
+        tabdef = (
+            """
+            CREATE TABLE xx_%s (
+                fldId integer NOT NULL,
+                fldData varchar(10))
+                """
+            % config.tmp
+        )
+        crsr.execute(tabdef)
+
+        inputs = ["four", "five", "six"]
+        fldId = 10
+        for inParam in inputs:
+            fldId += 1
+            try:
+                crsr.execute(
+                    "INSERT INTO xx_%s (fldId,fldData) VALUES (:Id,:f_Val)"
+                    % config.tmp,
+                    {"f_Val": inParam, "Id": fldId},
+                )
+            except:
+                conn.printADOerrors()
+                raise
+            crsr.execute(
+                "SELECT fldData FROM xx_%s WHERE fldID=:Id" % config.tmp, {"Id": fldId}
+            )
+            rec = crsr.fetchone()
+            self.assertEqual(
+                rec[0],
+                inParam,
+                'returned value:"%s" != test value:"%s"' % (rec[0], inParam),
+            )
+        # now a test with a ":" as part of a literal
+        crsr.execute(
+            "insert into xx_%s (fldId,fldData) VALUES (:xyz,'six:five')" % config.tmp,
+            {"xyz": 30},
+        )
+        crsr.execute("SELECT fldData FROM xx_%s WHERE fldID=30" % config.tmp)
+        rec = crsr.fetchone()
+        self.assertEqual(rec[0], "six:five")
+
+    def testPyformatParamstyle(self):
+        self.helpForceDropOnTblTemp()
+        conn = self.getConnection()
+        crsr = conn.cursor()
+        crsr.paramstyle = "pyformat"  # test nonstandard use of paramstyle
+        tabdef = (
+            """
+            CREATE TABLE xx_%s (
+                fldId integer NOT NULL,
+                fldData varchar(10))
+                """
+            % config.tmp
+        )
+        crsr.execute(tabdef)
+
+        inputs = ["four", "five", "six"]
+        fldId = 10
+        for inParam in inputs:
+            fldId += 1
+            try:
+                crsr.execute(
+                    "INSERT INTO xx_%s (fldId,fldData) VALUES (%%(Id)s,%%(f_Val)s)"
+                    % config.tmp,
+                    {"f_Val": inParam, "Id": fldId},
+                )
+            except:
+                conn.printADOerrors()
+                raise
+            crsr.execute(
+                "SELECT fldData FROM xx_%s WHERE fldID=%%(Id)s" % config.tmp,
+                {"Id": fldId},
+            )
+            rec = crsr.fetchone()
+            self.assertEqual(
+                rec[0],
+                inParam,
+                'returned value:"%s" != test value:"%s"' % (rec[0], inParam),
+            )
+        # now a test with a "%" as part of a literal
+        crsr.execute(
+            "insert into xx_%s (fldId,fldData) VALUES (%%(xyz)s,'six%%five')"
+            % config.tmp,
+            {"xyz": 30},
+        )
+        crsr.execute("SELECT fldData FROM xx_%s WHERE fldID=30" % config.tmp)
+        rec = crsr.fetchone()
+        self.assertEqual(rec[0], "six%five")
+
+    def testAutomaticParamstyle(self):
+        self.helpForceDropOnTblTemp()
+        conn = self.getConnection()
+        conn.paramstyle = "dynamic"  # test nonstandard use of paramstyle
+        crsr = conn.cursor()
+        tabdef = (
+            """
+            CREATE TABLE xx_%s (
+                fldId integer NOT NULL,
+                fldData varchar(10),
+                fldConst varchar(30))
+                """
+            % config.tmp
+        )
+        crsr.execute(tabdef)
+        inputs = ["one", "two", "three"]
+        fldId = 2
+        for inParam in inputs:
+            fldId += 1
+            try:
+                crsr.execute(
+                    "INSERT INTO xx_"
+                    + config.tmp
+                    + " (fldId,fldConst,fldData) VALUES (?,'thi%s :may cause? troub:1e', ?)",
+                    (fldId, inParam),
+                )
+            except:
+                conn.printADOerrors()
+                raise
+            trouble = "thi%s :may cause? troub:1e"
+            crsr.execute(
+                "SELECT fldData, fldConst FROM xx_" + config.tmp + " WHERE ?=fldID",
+                [fldId],
+            )
+            rec = crsr.fetchone()
+            self.assertEqual(
+                rec[0],
+                inParam,
+                'returned value:"%s" != test value:"%s"' % (rec[0], inParam),
+            )
+            self.assertEqual(rec[1], trouble)
+        #     inputs = [u'four',u'five',u'six']
+        fldId = 10
+        for inParam in inputs:
+            fldId += 1
+            try:
+                crsr.execute(
+                    "INSERT INTO xx_%s (fldId,fldData) VALUES (:Id,:f_Val)"
+                    % config.tmp,
+                    {"f_Val": inParam, "Id": fldId},
+                )
+            except:
+                conn.printADOerrors()
+                raise
+            crsr.execute(
+                "SELECT fldData FROM xx_%s WHERE :Id=fldID" % config.tmp, {"Id": fldId}
+            )
+            rec = crsr.fetchone()
+            self.assertEqual(
+                rec[0],
+                inParam,
+                'returned value:"%s" != test value:"%s"' % (rec[0], inParam),
+            )
+        # now a test with a ":" as part of a literal -- and use a prepared query
+        ppdcmd = (
+            "insert into xx_%s (fldId,fldData) VALUES (:xyz,'six:five')" % config.tmp
+        )
+        crsr.prepare(ppdcmd)
+        crsr.execute(ppdcmd, {"xyz": 30})
+        crsr.execute("SELECT fldData FROM xx_%s WHERE fldID=30" % config.tmp)
+        rec = crsr.fetchone()
+        self.assertEqual(rec[0], "six:five")
+
+    def testRollBack(self):
+        conn = self.getConnection()
+        crsr = conn.cursor()
+        assert not crsr.connection.autocommit, "Unexpected beginning condition"
+        self.helpCreateAndPopulateTableTemp(crsr)
+        crsr.connection.commit()  # commit the first bunch
+
+        crsr.execute("INSERT INTO xx_%s (fldData) VALUES(100)" % config.tmp)
+
+        selectSql = "SELECT fldData FROM xx_%s WHERE fldData=100" % config.tmp
+        crsr.execute(selectSql)
+        rs = crsr.fetchall()
+        assert len(rs) == 1
+        self.conn.rollback()
+        crsr.execute(selectSql)
+        assert (
+            crsr.fetchone() is None
+        ), "cursor.fetchone should return None if a query retrieves no rows"
+        crsr.execute("SELECT fldData from xx_%s" % config.tmp)
+        rs = crsr.fetchall()
+        assert len(rs) == 9, "the original records should still be present"
+        self.helpRollbackTblTemp()
+
+    def testCommit(self):
+        try:
+            con2 = self.getAnotherConnection()
+        except NotImplementedError:
+            return  # should be "SKIP" for ACCESS
+        assert not con2.autocommit, "default should be manual commit"
+        crsr = con2.cursor()
+        self.helpCreateAndPopulateTableTemp(crsr)
+
+        crsr.execute("INSERT INTO xx_%s (fldData) VALUES(100)" % config.tmp)
+        con2.commit()
+
+        selectSql = "SELECT fldData FROM xx_%s WHERE fldData=100" % config.tmp
+        crsr.execute(selectSql)
+        rs = crsr.fetchall()
+        assert len(rs) == 1
+        crsr.close()
+        con2.close()
+        conn = self.getConnection()
+        crsr = self.getCursor()
+        with conn.cursor() as crsr:
+            crsr.execute(selectSql)
+            rs = crsr.fetchall()
+            assert len(rs) == 1
+            assert rs[0][0] == 100
+        self.helpRollbackTblTemp()
+
+    def testAutoRollback(self):
+        try:
+            con2 = self.getAnotherConnection()
+        except NotImplementedError:
+            return  # should be "SKIP" for ACCESS
+        assert not con2.autocommit, "unexpected beginning condition"
+        crsr = con2.cursor()
+        self.helpCreateAndPopulateTableTemp(crsr)
+        crsr.execute("INSERT INTO xx_%s (fldData) VALUES(100)" % config.tmp)
+        selectSql = "SELECT fldData FROM xx_%s WHERE fldData=100" % config.tmp
+        crsr.execute(selectSql)
+        rs = crsr.fetchall()
+        assert len(rs) == 1
+        crsr.close()
+        con2.close()
+        crsr = self.getCursor()
+        try:
+            crsr.execute(
+                selectSql
+            )  # closing the connection should have forced rollback
+            row = crsr.fetchone()
+        except api.DatabaseError:
+            row = None  # if the entire table disappeared the rollback was perfect and the test passed
+        assert (
+            row is None
+        ), f"cursor.fetchone should return None if a query retrieves no rows. Got {row!r}"
+        self.helpRollbackTblTemp()
+
+    def testAutoCommit(self):
+        try:
+            ac_conn = self.getAnotherConnection({"autocommit": True})
+        except NotImplementedError:
+            return  # should be "SKIP" for ACCESS
+        crsr = ac_conn.cursor()
+        self.helpCreateAndPopulateTableTemp(crsr)
+        crsr.execute("INSERT INTO xx_%s (fldData) VALUES(100)" % config.tmp)
+        crsr.close()
+        with self.getCursor() as crsr:
+            selectSql = "SELECT fldData from xx_%s" % config.tmp
+            crsr.execute(
+                selectSql
+            )  # closing the connection should _not_ have forced rollback
+            rs = crsr.fetchall()
+            assert len(rs) == 10, "all records should still be present"
+        ac_conn.close()
+        self.helpRollbackTblTemp()
+
+    def testSwitchedAutoCommit(self):
+        try:
+            ac_conn = self.getAnotherConnection()
+        except NotImplementedError:
+            return  # should be "SKIP" for ACCESS
+        ac_conn.autocommit = True
+        crsr = ac_conn.cursor()
+        self.helpCreateAndPopulateTableTemp(crsr)
+        crsr.execute("INSERT INTO xx_%s (fldData) VALUES(100)" % config.tmp)
+        crsr.close()
+        conn = self.getConnection()
+        ac_conn.close()
+        with self.getCursor() as crsr:
+            selectSql = "SELECT fldData from xx_%s" % config.tmp
+            crsr.execute(
+                selectSql
+            )  # closing the connection should _not_ have forced rollback
+            rs = crsr.fetchall()
+            assert len(rs) == 10, "all records should still be present"
+        self.helpRollbackTblTemp()
+
+    def testExtendedTypeHandling(self):
+        class XtendString(str):
+            pass
+
+        class XtendInt(int):
+            pass
+
+        class XtendFloat(float):
+            pass
+
+        xs = XtendString(randomstring(30))
+        xi = XtendInt(random.randint(-100, 500))
+        xf = XtendFloat(random.random())
+        self.helpForceDropOnTblTemp()
+        conn = self.getConnection()
+        crsr = conn.cursor()
+        tabdef = (
+            """
+            CREATE TABLE xx_%s (
+                s VARCHAR(40) NOT NULL,
+                i INTEGER NOT NULL,
+                f REAL NOT NULL)"""
+            % config.tmp
+        )
+        crsr.execute(tabdef)
+        crsr.execute(
+            "INSERT INTO xx_%s (s, i, f) VALUES (?, ?, ?)" % config.tmp, (xs, xi, xf)
+        )
+        crsr.close()
+        conn = self.getConnection()
+        with self.getCursor() as crsr:
+            selectSql = "SELECT s, i, f from xx_%s" % config.tmp
+            crsr.execute(
+                selectSql
+            )  # closing the connection should _not_ have forced rollback
+            row = crsr.fetchone()
+            self.assertEqual(row.s, xs)
+            self.assertEqual(row.i, xi)
+            self.assertAlmostEqual(row.f, xf)
+        self.helpRollbackTblTemp()
+
+
+class TestADOwithSQLServer(CommonDBTests):
+    def setUp(self):
+        self.conn = config.dbSqlServerconnect(
+            *config.connStrSQLServer[0], **config.connStrSQLServer[1]
+        )
+        self.conn.timeout = 30  # turn timeout back up
+        self.engine = "MSSQL"
+        self.db = config.dbSqlServerconnect
+
+    def tearDown(self):
+        try:
+            self.conn.rollback()
+        except:
+            pass
+        try:
+            self.conn.close()
+        except:
+            pass
+        self.conn = None
+
+    def getConnection(self):
+        return self.conn
+
+    def getAnotherConnection(self, addkeys=None):
+        keys = dict(config.connStrSQLServer[1])
+        if addkeys:
+            keys.update(addkeys)
+        return config.dbSqlServerconnect(*config.connStrSQLServer[0], **keys)
+
+    def testVariableReturningStoredProcedure(self):
+        crsr = self.conn.cursor()
+        spdef = """
+            CREATE PROCEDURE sp_DeleteMeOnlyForTesting
+                @theInput varchar(50),
+                @theOtherInput varchar(50),
+                @theOutput varchar(100) OUTPUT
+            AS
+                SET @theOutput=@theInput+@theOtherInput
+                    """
+        try:
+            crsr.execute("DROP PROCEDURE sp_DeleteMeOnlyForTesting")
+            self.conn.commit()
+        except:  # Make sure it is empty
+            pass
+        crsr.execute(spdef)
+
+        retvalues = crsr.callproc(
+            "sp_DeleteMeOnlyForTesting", ("Dodsworth", "Anne", "              ")
+        )
+        assert retvalues[0] == "Dodsworth", f'{retvalues[0]!r} is not "Dodsworth"'
+        assert retvalues[1] == "Anne", f'{retvalues[1]!r} is not "Anne"'
+        assert (
+            retvalues[2] == "DodsworthAnne"
+        ), f'{retvalues[2]!r} is not "DodsworthAnne"'
+        self.conn.rollback()
+
+    def testMultipleSetReturn(self):
+        crsr = self.getCursor()
+        self.helpCreateAndPopulateTableTemp(crsr)
+
+        spdef = """
+            CREATE PROCEDURE sp_DeleteMe_OnlyForTesting
+            AS
+                SELECT fldData FROM xx_%s ORDER BY fldData ASC
+                SELECT fldData From xx_%s where fldData = -9999
+                SELECT fldData FROM xx_%s ORDER BY fldData DESC
+                    """ % (
+            config.tmp,
+            config.tmp,
+            config.tmp,
+        )
+        try:
+            crsr.execute("DROP PROCEDURE sp_DeleteMe_OnlyForTesting")
+            self.conn.commit()
+        except:  # Make sure it is empty
+            pass
+        crsr.execute(spdef)
+
+        retvalues = crsr.callproc("sp_DeleteMe_OnlyForTesting")
+        row = crsr.fetchone()
+        self.assertEqual(row[0], 0)
+        assert crsr.nextset() == True, "Operation should succeed"
+        assert not crsr.fetchall(), "Should be an empty second set"
+        assert crsr.nextset() == True, "third set should be present"
+        rowdesc = crsr.fetchall()
+        self.assertEqual(rowdesc[0][0], 8)
+        assert crsr.nextset() is None, "No more return sets, should return None"
+
+        self.helpRollbackTblTemp()
+
+    def testDatetimeProcedureParameter(self):
+        crsr = self.conn.cursor()
+        spdef = """
+            CREATE PROCEDURE sp_DeleteMeOnlyForTesting
+                @theInput DATETIME,
+                @theOtherInput varchar(50),
+                @theOutput varchar(100) OUTPUT
+            AS
+                SET @theOutput = CONVERT(CHARACTER(20), @theInput, 0) + @theOtherInput
+                    """
+        try:
+            crsr.execute("DROP PROCEDURE sp_DeleteMeOnlyForTesting")
+            self.conn.commit()
+        except:  # Make sure it is empty
+            pass
+        crsr.execute(spdef)
+
+        result = crsr.callproc(
+            "sp_DeleteMeOnlyForTesting",
+            [adodbapi.Timestamp(2014, 12, 25, 0, 1, 0), "Beep", " " * 30],
+        )
+
+        assert result[2] == "Dec 25 2014 12:01AM Beep", 'value was="%s"' % result[2]
+        self.conn.rollback()
+
+    def testIncorrectStoredProcedureParameter(self):
+        crsr = self.conn.cursor()
+        spdef = """
+            CREATE PROCEDURE sp_DeleteMeOnlyForTesting
+                @theInput DATETIME,
+                @theOtherInput varchar(50),
+                @theOutput varchar(100) OUTPUT
+            AS
+                SET @theOutput = CONVERT(CHARACTER(20), @theInput) + @theOtherInput
+                    """
+        try:
+            crsr.execute("DROP PROCEDURE sp_DeleteMeOnlyForTesting")
+            self.conn.commit()
+        except:  # Make sure it is empty
+            pass
+        crsr.execute(spdef)
+
+        # calling the sproc with a string for the first parameter where a DateTime is expected
+        result = tryconnection.try_operation_with_expected_exception(
+            (api.DataError, api.DatabaseError),
+            crsr.callproc,
+            ["sp_DeleteMeOnlyForTesting"],
+            {"parameters": ["this is wrong", "Anne", "not Alice"]},
+        )
+        if result[0]:  # the expected exception was raised
+            assert "@theInput" in str(result[1]) or "DatabaseError" in str(
+                result
+            ), "Identifies the wrong erroneous parameter"
+        else:
+            assert result[0], result[1]  # incorrect or no exception
+        self.conn.rollback()
+
+
+class TestADOwithAccessDB(CommonDBTests):
+    def setUp(self):
+        self.conn = config.dbAccessconnect(
+            *config.connStrAccess[0], **config.connStrAccess[1]
+        )
+        self.conn.timeout = 30  # turn timeout back up
+        self.engine = "ACCESS"
+        self.db = config.dbAccessconnect
+
+    def tearDown(self):
+        try:
+            self.conn.rollback()
+        except:
+            pass
+        try:
+            self.conn.close()
+        except:
+            pass
+        self.conn = None
+
+    def getConnection(self):
+        return self.conn
+
+    def getAnotherConnection(self, addkeys=None):
+        raise NotImplementedError("Jet cannot use a second connection to the database")
+
+    def testOkConnect(self):
+        c = self.db(*config.connStrAccess[0], **config.connStrAccess[1])
+        assert c is not None
+        c.close()
+
+
+class TestADOwithMySql(CommonDBTests):
+    def setUp(self):
+        self.conn = config.dbMySqlconnect(
+            *config.connStrMySql[0], **config.connStrMySql[1]
+        )
+        self.conn.timeout = 30  # turn timeout back up
+        self.engine = "MySQL"
+        self.db = config.dbMySqlconnect
+
+    def tearDown(self):
+        try:
+            self.conn.rollback()
+        except:
+            pass
+        try:
+            self.conn.close()
+        except:
+            pass
+        self.conn = None
+
+    def getConnection(self):
+        return self.conn
+
+    def getAnotherConnection(self, addkeys=None):
+        keys = dict(config.connStrMySql[1])
+        if addkeys:
+            keys.update(addkeys)
+        return config.dbMySqlconnect(*config.connStrMySql[0], **keys)
+
+    def testOkConnect(self):
+        c = self.db(*config.connStrMySql[0], **config.connStrMySql[1])
+        assert c is not None
+
+    # def testStoredProcedure(self):
+    #     crsr = self.conn.cursor()
+    #     try:
+    #         crsr.execute("DROP PROCEDURE DeleteMeOnlyForTesting")
+    #         self.conn.commit()
+    #     except:  # Make sure it is empty
+    #         pass
+    #     spdef = """
+    #             DELIMITER $$
+    #             CREATE PROCEDURE DeleteMeOnlyForTesting (onein CHAR(10), twoin CHAR(10), OUT theout CHAR(20))
+    #             DETERMINISTIC
+    #              BEGIN
+    #                 SET theout = onein //|| twoin;
+    #                 /* (SELECT 'a small string' as result; */
+    #                 END $$
+    #             """
+    #     crsr.execute(spdef)
+    #     retvalues = crsr.callproc(
+    #         "DeleteMeOnlyForTesting", ("Dodsworth", "Anne", "              ")
+    #     )
+    #     # print(f"return value (mysql)={crsr.returnValue!r}")
+    #     assert retvalues[0] == "Dodsworth", f'{retvalues[0]!r} is not "Dodsworth"'
+    #     assert retvalues[1] == "Anne", f'{retvalues[1]!r} is not "Anne"'
+    #     assert (
+    #         retvalues[2] == "DodsworthAnne"
+    #     ), f'{retvalues[2]!r} is not "DodsworthAnne"'
+    #     try:
+    #         crsr.execute("DROP PROCEDURE, DeleteMeOnlyForTesting")
+    #         self.conn.commit()
+    #     except:  # Make sure it is empty
+    #         pass
+
+
+class TestADOwithPostgres(CommonDBTests):
+    def setUp(self):
+        self.conn = config.dbPostgresConnect(
+            *config.connStrPostgres[0], **config.connStrPostgres[1]
+        )
+        self.conn.timeout = 30  # turn timeout back up
+        self.engine = "PostgreSQL"
+        self.db = config.dbPostgresConnect
+
+    def tearDown(self):
+        try:
+            self.conn.rollback()
+        except:
+            pass
+        try:
+            self.conn.close()
+        except:
+            pass
+        self.conn = None
+
+    def getConnection(self):
+        return self.conn
+
+    def getAnotherConnection(self, addkeys=None):
+        keys = dict(config.connStrPostgres[1])
+        if addkeys:
+            keys.update(addkeys)
+        return config.dbPostgresConnect(*config.connStrPostgres[0], **keys)
+
+    def testOkConnect(self):
+        c = self.db(*config.connStrPostgres[0], **config.connStrPostgres[1])
+        assert c is not None
+
+    # def testStoredProcedure(self):
+    #     crsr = self.conn.cursor()
+    #     spdef = """
+    #         CREATE OR REPLACE FUNCTION DeleteMeOnlyForTesting (text, text)
+    #         RETURNS text AS $funk$
+    #         BEGIN
+    #           RETURN $1 || $2;
+    #         END;
+    #         $funk$
+    #         LANGUAGE SQL;
+    #         """
+
+    #     crsr.execute(spdef)
+    #     retvalues = crsr.callproc(
+    #         "DeleteMeOnlyForTesting", ("Dodsworth", "Anne", "              ")
+    #     )
+    #     # print(f"return value (pg)={crsr.returnValue!r}")
+    #     assert retvalues[0] == "Dodsworth", f'{retvalues[0]!r} is not "Dodsworth"'
+    #     assert retvalues[1] == "Anne", f'{retvalues[1]!r} is not "Anne"'
+    #     assert (
+    #         retvalues[2] == "DodsworthAnne"
+    #     ), f'{retvalues[2]!r} is not "DodsworthAnne"'
+    #     self.conn.rollback()
+    #     try:
+    #         crsr.execute("DROP PROCEDURE, DeleteMeOnlyForTesting")
+    #         self.conn.commit()
+    #     except:  # Make sure it is empty
+    #         pass
+
+
+class TimeConverterInterfaceTest(unittest.TestCase):
+    def testIDate(self):
+        assert self.tc.Date(1990, 2, 2)
+
+    def testITime(self):
+        assert self.tc.Time(13, 2, 2)
+
+    def testITimestamp(self):
+        assert self.tc.Timestamp(1990, 2, 2, 13, 2, 1)
+
+    def testIDateObjectFromCOMDate(self):
+        assert self.tc.DateObjectFromCOMDate(37435.7604282)
+
+    def testICOMDate(self):
+        assert hasattr(self.tc, "COMDate")
+
+    def testExactDate(self):
+        d = self.tc.Date(1994, 11, 15)
+        comDate = self.tc.COMDate(d)
+        correct = 34653.0
+        assert comDate == correct, comDate
+
+    def testExactTimestamp(self):
+        d = self.tc.Timestamp(1994, 11, 15, 12, 0, 0)
+        comDate = self.tc.COMDate(d)
+        correct = 34653.5
+        self.assertEqual(comDate, correct)
+
+        d = self.tc.Timestamp(2003, 5, 6, 14, 15, 17)
+        comDate = self.tc.COMDate(d)
+        correct = 37747.593946759262
+        self.assertEqual(comDate, correct)
+
+    def testIsoFormat(self):
+        d = self.tc.Timestamp(1994, 11, 15, 12, 3, 10)
+        iso = self.tc.DateObjectToIsoFormatString(d)
+        self.assertEqual(str(iso[:19]), "1994-11-15 12:03:10")
+
+        dt = self.tc.Date(2003, 5, 2)
+        iso = self.tc.DateObjectToIsoFormatString(dt)
+        self.assertEqual(str(iso[:10]), "2003-05-02")
+
+
+class TestPythonTimeConverter(TimeConverterInterfaceTest):
+    def setUp(self):
+        self.tc = api.pythonTimeConverter()
+
+    def testCOMDate(self):
+        mk = time.mktime((2002, 6, 28, 18, 15, 1, 4, 31 + 28 + 31 + 30 + 31 + 28, -1))
+        t = time.localtime(mk)
+        # Fri, 28 Jun 2002 18:15:01 +0000
+        cmd = self.tc.COMDate(t)
+        assert abs(cmd - 37435.7604282) < 1.0 / 24, "%f more than an hour wrong" % cmd
+
+    def testDateObjectFromCOMDate(self):
+        cmd = self.tc.DateObjectFromCOMDate(37435.7604282)
+        t1 = time.gmtime(
+            time.mktime((2002, 6, 28, 0, 14, 1, 4, 31 + 28 + 31 + 30 + 31 + 28, -1))
+        )
+        # there are errors in the implementation of gmtime which we ignore
+        t2 = time.gmtime(
+            time.mktime((2002, 6, 29, 12, 14, 2, 4, 31 + 28 + 31 + 30 + 31 + 28, -1))
+        )
+        assert t1 < cmd < t2, f'"{cmd}" should be about 2002-6-28 12:15:01'
+
+    def testDate(self):
+        t1 = time.mktime((2002, 6, 28, 18, 15, 1, 4, 31 + 28 + 31 + 30 + 31 + 30, 0))
+        t2 = time.mktime((2002, 6, 30, 18, 15, 1, 4, 31 + 28 + 31 + 30 + 31 + 28, 0))
+        obj = self.tc.Date(2002, 6, 29)
+        assert t1 < time.mktime(obj) < t2, obj
+
+    def testTime(self):
+        self.assertEqual(
+            self.tc.Time(18, 15, 2), time.gmtime(18 * 60 * 60 + 15 * 60 + 2)
+        )
+
+    def testTimestamp(self):
+        t1 = time.localtime(
+            time.mktime((2002, 6, 28, 18, 14, 1, 4, 31 + 28 + 31 + 30 + 31 + 28, -1))
+        )
+        t2 = time.localtime(
+            time.mktime((2002, 6, 28, 18, 16, 1, 4, 31 + 28 + 31 + 30 + 31 + 28, -1))
+        )
+        obj = self.tc.Timestamp(2002, 6, 28, 18, 15, 2)
+        assert t1 < obj < t2, obj
+
+
+class TestPythonDateTimeConverter(TimeConverterInterfaceTest):
+    def setUp(self):
+        self.tc = api.pythonDateTimeConverter()
+
+    def testCOMDate(self):
+        t = datetime.datetime(2002, 6, 28, 18, 15, 1)
+        # Fri, 28 Jun 2002 18:15:01 +0000
+        cmd = self.tc.COMDate(t)
+        assert abs(cmd - 37435.7604282) < 1.0 / 24, "more than an hour wrong"
+
+    def testDateObjectFromCOMDate(self):
+        cmd = self.tc.DateObjectFromCOMDate(37435.7604282)
+        t1 = datetime.datetime(2002, 6, 28, 18, 14, 1)
+        t2 = datetime.datetime(2002, 6, 28, 18, 16, 1)
+        assert t1 < cmd < t2, cmd
+
+        tx = datetime.datetime(
+            2002, 6, 28, 18, 14, 1, 900000
+        )  # testing that microseconds don't become milliseconds
+        c1 = self.tc.DateObjectFromCOMDate(self.tc.COMDate(tx))
+        assert t1 < c1 < t2, c1
+
+    def testDate(self):
+        t1 = datetime.date(2002, 6, 28)
+        t2 = datetime.date(2002, 6, 30)
+        obj = self.tc.Date(2002, 6, 29)
+        assert t1 < obj < t2, obj
+
+    def testTime(self):
+        self.assertEqual(self.tc.Time(18, 15, 2).isoformat()[:8], "18:15:02")
+
+    def testTimestamp(self):
+        t1 = datetime.datetime(2002, 6, 28, 18, 14, 1)
+        t2 = datetime.datetime(2002, 6, 28, 18, 16, 1)
+        obj = self.tc.Timestamp(2002, 6, 28, 18, 15, 2)
+        assert t1 < obj < t2, obj
+
+
+suites = [
+    unittest.defaultTestLoader.loadTestsFromModule(TestPythonDateTimeConverter, "test")
+]
+if config.doTimeTest:
+    suites.append(
+        unittest.defaultTestLoader.loadTestsFromModule(TestPythonTimeConverter, "test")
+    )
+if config.doAccessTest:
+    suites.append(
+        unittest.defaultTestLoader.loadTestsFromModule(TestADOwithAccessDB, "test")
+    )
+if config.doSqlServerTest:
+    suites.append(
+        unittest.defaultTestLoader.loadTestsFromModule(TestADOwithSQLServer, "test")
+    )
+if config.doMySqlTest:
+    suites.append(
+        unittest.defaultTestLoader.loadTestsFromModule(TestADOwithMySql, "test")
+    )
+if config.doPostgresTest:
+    suites.append(
+        unittest.defaultTestLoader.loadTestsFromModule(TestADOwithPostgres, "test")
+    )
+
+
+class cleanup_manager:
+    def __enter__(self):
+        pass
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        config.cleanup(config.testfolder, config.mdb_name)
+
+
+suite = unittest.TestSuite(suites)
+if __name__ == "__main__":
+    mysuite = copy.deepcopy(suite)
+    with cleanup_manager():
+        defaultDateConverter = adodbapi.dateconverter
+        print(__doc__)
+        print("Default Date Converter is %s" % (defaultDateConverter,))
+        dateconverter = defaultDateConverter
+        unittest.TextTestRunner().run(mysuite)
+
+        if config.doTimeTest:
+            mysuite = copy.deepcopy(
+                suite
+            )  # work around a side effect of unittest.TextTestRunner
+            adodbapi.adodbapi.dateconverter = api.pythonTimeConverter()
+            print("Changed dateconverter to ")
+            print(adodbapi.adodbapi.dateconverter)
+            unittest.TextTestRunner().run(mysuite)

myenv/Lib/site-packages/adodbapi/test/adodbapitestconfig.py

@@ -0,0 +1,184 @@
+# Configure this to _YOUR_ environment in order to run the testcases.
+"testADOdbapiConfig.py v 2.6.2.B00"
+
+# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
+# #
+# #  TESTERS:
+# #
+# #  You will need to make numerous modifications to this file
+# #  to adapt it to your own testing environment.
+# #
+# #  Skip down to the next "# #" line --
+# #  -- the things you need to change are below it.
+# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
+import platform
+import random
+import sys
+
+import is64bit
+import setuptestframework
+import tryconnection
+
+print("\nPython", sys.version)
+node = platform.node()
+try:
+    print(
+        "node=%s, is64bit.os()= %s, is64bit.Python()= %s"
+        % (node, is64bit.os(), is64bit.Python())
+    )
+except:
+    pass
+
+if "--help" in sys.argv:
+    print(
+        """Valid command-line switches are:
+    --package - create a temporary test package
+    --all - run all possible tests
+    --time - do time format test
+    --nojet - do not test against an ACCESS database file
+    --mssql - test against Microsoft SQL server
+    --pg - test against PostgreSQL
+    --mysql - test against MariaDB
+    """
+    )
+    exit()
+try:
+    onWindows = bool(sys.getwindowsversion())  # seems to work on all versions of Python
+except:
+    onWindows = False
+
+# create a random name for temporary table names
+_alphabet = (
+    "PYFGCRLAOEUIDHTNSQJKXBMWVZ"  # why, yes, I do happen to use a dvorak keyboard
+)
+tmp = "".join([random.choice(_alphabet) for x in range(9)])
+mdb_name = "xx_" + tmp + ".mdb"  # generate a non-colliding name for the temporary .mdb
+testfolder = setuptestframework.maketemp()
+
+if "--package" in sys.argv:
+    #  create a new adodbapi module
+    pth = setuptestframework.makeadopackage(testfolder)
+else:
+    #  use the adodbapi module in which this file appears
+    pth = setuptestframework.find_ado_path()
+if pth not in sys.path:
+    #  look here _first_ to find modules
+    sys.path.insert(1, pth)
+
+# function to clean up the temporary folder -- calling program must run this function before exit.
+cleanup = setuptestframework.getcleanupfunction()
+
+import adodbapi  # will (hopefully) be imported using the "pth" discovered above
+
+print(adodbapi.version)  # show version
+print(__doc__)
+
+verbose = False
+for a in sys.argv:
+    if a.startswith("--verbose"):
+        arg = True
+        try:
+            arg = int(a.split("=")[1])
+        except IndexError:
+            pass
+        adodbapi.adodbapi.verbose = arg
+        verbose = arg
+
+doAllTests = "--all" in sys.argv
+doAccessTest = not ("--nojet" in sys.argv)
+doSqlServerTest = "--mssql" in sys.argv or doAllTests
+doMySqlTest = "--mysql" in sys.argv or doAllTests
+doPostgresTest = "--pg" in sys.argv or doAllTests
+doTimeTest = ("--time" in sys.argv or doAllTests) and onWindows
+
+# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
+# # start your environment setup here v v v
+SQL_HOST_NODE = "testsql.2txt.us,1430"
+
+if doAccessTest:
+    c = {
+        "mdb": setuptestframework.makemdb(testfolder, mdb_name),
+        # macro definition for keyword "provider"  using macro "is64bit" -- see documentation
+        # is64bit will return true for 64 bit versions of Python, so the macro will select the ACE provider
+        "macro_is64bit": [
+            "provider",
+            "Microsoft.ACE.OLEDB.12.0",  # 64 bit provider
+            "Microsoft.Jet.OLEDB.4.0",  # 32 bit provider
+        ],
+    }
+
+    # ;Mode=ReadWrite;Persist Security Info=False;Jet OLEDB:Bypass UserInfo Validation=True"
+    connStrAccess = "Provider=%(provider)s;Data Source=%(mdb)s"
+    print("    ...Testing ACCESS connection to {} file...".format(c["mdb"]))
+    doAccessTest, connStrAccess, dbAccessconnect = tryconnection.try_connection(
+        verbose, connStrAccess, 10, **c
+    )
+
+if doSqlServerTest:
+    c = {
+        "host": SQL_HOST_NODE,  # name of computer with SQL Server
+        "database": "adotest",
+        "user": "adotestuser",  # None implies Windows security
+        "password": "Sq1234567",
+        # macro definition for keyword "security" using macro "auto_security"
+        "macro_auto_security": "security",
+        "provider": "MSOLEDBSQL; MARS Connection=True",
+    }
+    connStr = "Provider=%(provider)s; Initial Catalog=%(database)s; Data Source=%(host)s; %(security)s;"
+    print("    ...Testing MS-SQL login to {}...".format(c["host"]))
+    (
+        doSqlServerTest,
+        connStrSQLServer,
+        dbSqlServerconnect,
+    ) = tryconnection.try_connection(verbose, connStr, 30, **c)
+
+if doMySqlTest:
+    c = {
+        "host": "testmysql.2txt.us",
+        "database": "adodbapitest",
+        "user": "adotest",
+        "password": "12345678",
+        "port": "3330",  # note the nonstandard port for obfuscation
+        "driver": "MySQL ODBC 5.1 Driver",
+    }  # or _driver="MySQL ODBC 3.51 Driver
+    c["macro_is64bit"] = [
+        "provider",
+        "Provider=MSDASQL;",
+    ]  # turn on the 64 bit ODBC adapter only if needed
+    cs = (
+        "%(provider)sDriver={%(driver)s};Server=%(host)s;Port=3330;"
+        + "Database=%(database)s;user=%(user)s;password=%(password)s;Option=3;"
+    )
+    print("    ...Testing MySql login to {}...".format(c["host"]))
+    doMySqlTest, connStrMySql, dbMySqlconnect = tryconnection.try_connection(
+        verbose, cs, 5, **c
+    )
+
+
+if doPostgresTest:
+    _computername = "testpg.2txt.us"
+    _databasename = "adotest"
+    _username = "adotestuser"
+    _password = "12345678"
+    kws = {"timeout": 4}
+    kws["macro_is64bit"] = [
+        "prov_drv",
+        "Provider=MSDASQL;Driver={PostgreSQL Unicode(x64)}",
+        "Driver=PostgreSQL Unicode",
+    ]
+    # get driver from http://www.postgresql.org/ftp/odbc/versions/
+    # test using positional and keyword arguments (bad example for real code)
+    print("    ...Testing PostgreSQL login to {}...".format(_computername))
+    doPostgresTest, connStrPostgres, dbPostgresConnect = tryconnection.try_connection(
+        verbose,
+        "%(prov_drv)s;Server=%(host)s;Database=%(database)s;uid=%(user)s;pwd=%(password)s;port=5430;",  # note nonstandard port
+        _username,
+        _password,
+        _computername,
+        _databasename,
+        **kws,
+    )
+
+assert (
+    doAccessTest or doSqlServerTest or doMySqlTest or doPostgresTest
+), "No database engine found for testing"

myenv/Lib/site-packages/adodbapi/test/dbapi20.py

@@ -0,0 +1,885 @@
+#!/usr/bin/env python
+""" Python DB API 2.0 driver compliance unit test suite.
+
+    This software is Public Domain and may be used without restrictions.
+
+ "Now we have booze and barflies entering the discussion, plus rumours of
+  DBAs on drugs... and I won't tell you what flashes through my mind each
+  time I read the subject line with 'Anal Compliance' in it.  All around
+  this is turning out to be a thoroughly unwholesome unit test."
+
+    -- Ian Bicking
+"""
+
+__version__ = "$Revision: 1.15.0 $"[11:-2]
+__author__ = "Stuart Bishop <stuart@stuartbishop.net>"
+
+import sys
+import time
+import unittest
+
+# set this to "True" to follow API 2.0 to the letter
+TEST_FOR_NON_IDEMPOTENT_CLOSE = False
+
+# Revision 1.15  2019/11/22 00:50:00  kf7xm
+# Make Turn off IDEMPOTENT_CLOSE a proper skipTest
+
+# Revision 1.14  2013/05/20 11:02:05  kf7xm
+# Add a literal string to the format insertion test to catch trivial re-format algorithms
+
+# Revision 1.13  2013/05/08 14:31:50  kf7xm
+# Quick switch to Turn off IDEMPOTENT_CLOSE test. Also: Silence teardown failure
+
+
+# Revision 1.12  2009/02/06 03:35:11  kf7xm
+# Tested okay with Python 3.0, includes last minute patches from Mark H.
+#
+# Revision 1.1.1.1.2.1  2008/09/20 19:54:59  rupole
+# Include latest changes from main branch
+# Updates for py3k
+#
+# Revision 1.11  2005/01/02 02:41:01  zenzen
+# Update author email address
+#
+# Revision 1.10  2003/10/09 03:14:14  zenzen
+# Add test for DB API 2.0 optional extension, where database exceptions
+# are exposed as attributes on the Connection object.
+#
+# Revision 1.9  2003/08/13 01:16:36  zenzen
+# Minor tweak from Stefan Fleiter
+#
+# Revision 1.8  2003/04/10 00:13:25  zenzen
+# Changes, as per suggestions by M.-A. Lemburg
+# - Add a table prefix, to ensure namespace collisions can always be avoided
+#
+# Revision 1.7  2003/02/26 23:33:37  zenzen
+# Break out DDL into helper functions, as per request by David Rushby
+#
+# Revision 1.6  2003/02/21 03:04:33  zenzen
+# Stuff from Henrik Ekelund:
+#     added test_None
+#     added test_nextset & hooks
+#
+# Revision 1.5  2003/02/17 22:08:43  zenzen
+# Implement suggestions and code from Henrik Eklund - test that cursor.arraysize
+# defaults to 1 & generic cursor.callproc test added
+#
+# Revision 1.4  2003/02/15 00:16:33  zenzen
+# Changes, as per suggestions and bug reports by M.-A. Lemburg,
+# Matthew T. Kromer, Federico Di Gregorio and Daniel Dittmar
+# - Class renamed
+# - Now a subclass of TestCase, to avoid requiring the driver stub
+#   to use multiple inheritance
+# - Reversed the polarity of buggy test in test_description
+# - Test exception heirarchy correctly
+# - self.populate is now self._populate(), so if a driver stub
+#   overrides self.ddl1 this change propogates
+# - VARCHAR columns now have a width, which will hopefully make the
+#   DDL even more portible (this will be reversed if it causes more problems)
+# - cursor.rowcount being checked after various execute and fetchXXX methods
+# - Check for fetchall and fetchmany returning empty lists after results
+#   are exhausted (already checking for empty lists if select retrieved
+#   nothing
+# - Fix bugs in test_setoutputsize_basic and test_setinputsizes
+#
+
+
+class DatabaseAPI20Test(unittest.TestCase):
+    """Test a database self.driver for DB API 2.0 compatibility.
+    This implementation tests Gadfly, but the TestCase
+    is structured so that other self.drivers can subclass this
+    test case to ensure compiliance with the DB-API. It is
+    expected that this TestCase may be expanded in the future
+    if ambiguities or edge conditions are discovered.
+
+    The 'Optional Extensions' are not yet being tested.
+
+    self.drivers should subclass this test, overriding setUp, tearDown,
+    self.driver, connect_args and connect_kw_args. Class specification
+    should be as follows:
+
+    import dbapi20
+    class mytest(dbapi20.DatabaseAPI20Test):
+       [...]
+
+    Don't 'import DatabaseAPI20Test from dbapi20', or you will
+    confuse the unit tester - just 'import dbapi20'.
+    """
+
+    # The self.driver module. This should be the module where the 'connect'
+    # method is to be found
+    driver = None
+    connect_args = ()  # List of arguments to pass to connect
+    connect_kw_args = {}  # Keyword arguments for connect
+    table_prefix = "dbapi20test_"  # If you need to specify a prefix for tables
+
+    ddl1 = "create table %sbooze (name varchar(20))" % table_prefix
+    ddl2 = "create table %sbarflys (name varchar(20), drink varchar(30))" % table_prefix
+    xddl1 = "drop table %sbooze" % table_prefix
+    xddl2 = "drop table %sbarflys" % table_prefix
+
+    lowerfunc = "lower"  # Name of stored procedure to convert string->lowercase
+
+    # Some drivers may need to override these helpers, for example adding
+    # a 'commit' after the execute.
+    def executeDDL1(self, cursor):
+        cursor.execute(self.ddl1)
+
+    def executeDDL2(self, cursor):
+        cursor.execute(self.ddl2)
+
+    def setUp(self):
+        """self.drivers should override this method to perform required setup
+        if any is necessary, such as creating the database.
+        """
+        pass
+
+    def tearDown(self):
+        """self.drivers should override this method to perform required cleanup
+        if any is necessary, such as deleting the test database.
+        The default drops the tables that may be created.
+        """
+        try:
+            con = self._connect()
+            try:
+                cur = con.cursor()
+                for ddl in (self.xddl1, self.xddl2):
+                    try:
+                        cur.execute(ddl)
+                        con.commit()
+                    except self.driver.Error:
+                        # Assume table didn't exist. Other tests will check if
+                        # execute is busted.
+                        pass
+            finally:
+                con.close()
+        except Exception:
+            pass
+
+    def _connect(self):
+        try:
+            r = self.driver.connect(*self.connect_args, **self.connect_kw_args)
+        except AttributeError:
+            self.fail("No connect method found in self.driver module")
+        return r
+
+    def test_connect(self):
+        con = self._connect()
+        con.close()
+
+    def test_apilevel(self):
+        try:
+            # Must exist
+            apilevel = self.driver.apilevel
+            # Must equal 2.0
+            self.assertEqual(apilevel, "2.0")
+        except AttributeError:
+            self.fail("Driver doesn't define apilevel")
+
+    def test_threadsafety(self):
+        try:
+            # Must exist
+            threadsafety = self.driver.threadsafety
+            # Must be a valid value
+            self.assertTrue(threadsafety in (0, 1, 2, 3))
+        except AttributeError:
+            self.fail("Driver doesn't define threadsafety")
+
+    def test_paramstyle(self):
+        try:
+            # Must exist
+            paramstyle = self.driver.paramstyle
+            # Must be a valid value
+            self.assertTrue(
+                paramstyle in ("qmark", "numeric", "named", "format", "pyformat")
+            )
+        except AttributeError:
+            self.fail("Driver doesn't define paramstyle")
+
+    def test_Exceptions(self):
+        # Make sure required exceptions exist, and are in the
+        # defined heirarchy.
+        if sys.version[0] == "3":  # under Python 3 StardardError no longer exists
+            self.assertTrue(issubclass(self.driver.Warning, Exception))
+            self.assertTrue(issubclass(self.driver.Error, Exception))
+        else:
+            self.failUnless(issubclass(self.driver.Warning, Exception))
+            self.failUnless(issubclass(self.driver.Error, Exception))
+
+        self.assertTrue(issubclass(self.driver.InterfaceError, self.driver.Error))
+        self.assertTrue(issubclass(self.driver.DatabaseError, self.driver.Error))
+        self.assertTrue(issubclass(self.driver.OperationalError, self.driver.Error))
+        self.assertTrue(issubclass(self.driver.IntegrityError, self.driver.Error))
+        self.assertTrue(issubclass(self.driver.InternalError, self.driver.Error))
+        self.assertTrue(issubclass(self.driver.ProgrammingError, self.driver.Error))
+        self.assertTrue(issubclass(self.driver.NotSupportedError, self.driver.Error))
+
+    def test_ExceptionsAsConnectionAttributes(self):
+        # OPTIONAL EXTENSION
+        # Test for the optional DB API 2.0 extension, where the exceptions
+        # are exposed as attributes on the Connection object
+        # I figure this optional extension will be implemented by any
+        # driver author who is using this test suite, so it is enabled
+        # by default.
+        con = self._connect()
+        drv = self.driver
+        self.assertTrue(con.Warning is drv.Warning)
+        self.assertTrue(con.Error is drv.Error)
+        self.assertTrue(con.InterfaceError is drv.InterfaceError)
+        self.assertTrue(con.DatabaseError is drv.DatabaseError)
+        self.assertTrue(con.OperationalError is drv.OperationalError)
+        self.assertTrue(con.IntegrityError is drv.IntegrityError)
+        self.assertTrue(con.InternalError is drv.InternalError)
+        self.assertTrue(con.ProgrammingError is drv.ProgrammingError)
+        self.assertTrue(con.NotSupportedError is drv.NotSupportedError)
+
+    def test_commit(self):
+        con = self._connect()
+        try:
+            # Commit must work, even if it doesn't do anything
+            con.commit()
+        finally:
+            con.close()
+
+    def test_rollback(self):
+        con = self._connect()
+        # If rollback is defined, it should either work or throw
+        # the documented exception
+        if hasattr(con, "rollback"):
+            try:
+                con.rollback()
+            except self.driver.NotSupportedError:
+                pass
+
+    def test_cursor(self):
+        con = self._connect()
+        try:
+            cur = con.cursor()
+        finally:
+            con.close()
+
+    def test_cursor_isolation(self):
+        con = self._connect()
+        try:
+            # Make sure cursors created from the same connection have
+            # the documented transaction isolation level
+            cur1 = con.cursor()
+            cur2 = con.cursor()
+            self.executeDDL1(cur1)
+            cur1.execute(
+                "insert into %sbooze values ('Victoria Bitter')" % (self.table_prefix)
+            )
+            cur2.execute("select name from %sbooze" % self.table_prefix)
+            booze = cur2.fetchall()
+            self.assertEqual(len(booze), 1)
+            self.assertEqual(len(booze[0]), 1)
+            self.assertEqual(booze[0][0], "Victoria Bitter")
+        finally:
+            con.close()
+
+    def test_description(self):
+        con = self._connect()
+        try:
+            cur = con.cursor()
+            self.executeDDL1(cur)
+            self.assertEqual(
+                cur.description,
+                None,
+                "cursor.description should be none after executing a "
+                "statement that can return no rows (such as DDL)",
+            )
+            cur.execute("select name from %sbooze" % self.table_prefix)
+            self.assertEqual(
+                len(cur.description), 1, "cursor.description describes too many columns"
+            )
+            self.assertEqual(
+                len(cur.description[0]),
+                7,
+                "cursor.description[x] tuples must have 7 elements",
+            )
+            self.assertEqual(
+                cur.description[0][0].lower(),
+                "name",
+                "cursor.description[x][0] must return column name",
+            )
+            self.assertEqual(
+                cur.description[0][1],
+                self.driver.STRING,
+                "cursor.description[x][1] must return column type. Got %r"
+                % cur.description[0][1],
+            )
+
+            # Make sure self.description gets reset
+            self.executeDDL2(cur)
+            self.assertEqual(
+                cur.description,
+                None,
+                "cursor.description not being set to None when executing "
+                "no-result statements (eg. DDL)",
+            )
+        finally:
+            con.close()
+
+    def test_rowcount(self):
+        con = self._connect()
+        try:
+            cur = con.cursor()
+            self.executeDDL1(cur)
+            self.assertTrue(
+                cur.rowcount in (-1, 0),  # Bug #543885
+                "cursor.rowcount should be -1 or 0 after executing no-result "
+                "statements",
+            )
+            cur.execute(
+                "insert into %sbooze values ('Victoria Bitter')" % (self.table_prefix)
+            )
+            self.assertTrue(
+                cur.rowcount in (-1, 1),
+                "cursor.rowcount should == number or rows inserted, or "
+                "set to -1 after executing an insert statement",
+            )
+            cur.execute("select name from %sbooze" % self.table_prefix)
+            self.assertTrue(
+                cur.rowcount in (-1, 1),
+                "cursor.rowcount should == number of rows returned, or "
+                "set to -1 after executing a select statement",
+            )
+            self.executeDDL2(cur)
+            self.assertEqual(
+                cur.rowcount,
+                -1,
+                "cursor.rowcount not being reset to -1 after executing "
+                "no-result statements",
+            )
+        finally:
+            con.close()
+
+    lower_func = "lower"
+
+    def test_callproc(self):
+        con = self._connect()
+        try:
+            cur = con.cursor()
+            if self.lower_func and hasattr(cur, "callproc"):
+                r = cur.callproc(self.lower_func, ("FOO",))
+                self.assertEqual(len(r), 1)
+                self.assertEqual(r[0], "FOO")
+                r = cur.fetchall()
+                self.assertEqual(len(r), 1, "callproc produced no result set")
+                self.assertEqual(len(r[0]), 1, "callproc produced invalid result set")
+                self.assertEqual(r[0][0], "foo", "callproc produced invalid results")
+        finally:
+            con.close()
+
+    def test_close(self):
+        con = self._connect()
+        try:
+            cur = con.cursor()
+        finally:
+            con.close()
+
+        # cursor.execute should raise an Error if called after connection
+        # closed
+        self.assertRaises(self.driver.Error, self.executeDDL1, cur)
+
+        # connection.commit should raise an Error if called after connection'
+        # closed.'
+        self.assertRaises(self.driver.Error, con.commit)
+
+        # connection.close should raise an Error if called more than once
+        #!!! reasonable persons differ about the usefulness of this test and this feature !!!
+        if TEST_FOR_NON_IDEMPOTENT_CLOSE:
+            self.assertRaises(self.driver.Error, con.close)
+        else:
+            self.skipTest(
+                "Non-idempotent close is considered a bad thing by some people."
+            )
+
+    def test_execute(self):
+        con = self._connect()
+        try:
+            cur = con.cursor()
+            self._paraminsert(cur)
+        finally:
+            con.close()
+
+    def _paraminsert(self, cur):
+        self.executeDDL2(cur)
+        cur.execute(
+            "insert into %sbarflys values ('Victoria Bitter', 'thi%%s :may ca%%(u)se? troub:1e')"
+            % (self.table_prefix)
+        )
+        self.assertTrue(cur.rowcount in (-1, 1))
+
+        if self.driver.paramstyle == "qmark":
+            cur.execute(
+                "insert into %sbarflys values (?, 'thi%%s :may ca%%(u)se? troub:1e')"
+                % self.table_prefix,
+                ("Cooper's",),
+            )
+        elif self.driver.paramstyle == "numeric":
+            cur.execute(
+                "insert into %sbarflys values (:1, 'thi%%s :may ca%%(u)se? troub:1e')"
+                % self.table_prefix,
+                ("Cooper's",),
+            )
+        elif self.driver.paramstyle == "named":
+            cur.execute(
+                "insert into %sbarflys values (:beer, 'thi%%s :may ca%%(u)se? troub:1e')"
+                % self.table_prefix,
+                {"beer": "Cooper's"},
+            )
+        elif self.driver.paramstyle == "format":
+            cur.execute(
+                "insert into %sbarflys values (%%s, 'thi%%s :may ca%%(u)se? troub:1e')"
+                % self.table_prefix,
+                ("Cooper's",),
+            )
+        elif self.driver.paramstyle == "pyformat":
+            cur.execute(
+                "insert into %sbarflys values (%%(beer)s, 'thi%%s :may ca%%(u)se? troub:1e')"
+                % self.table_prefix,
+                {"beer": "Cooper's"},
+            )
+        else:
+            self.fail("Invalid paramstyle")
+        self.assertTrue(cur.rowcount in (-1, 1))
+
+        cur.execute("select name, drink from %sbarflys" % self.table_prefix)
+        res = cur.fetchall()
+        self.assertEqual(len(res), 2, "cursor.fetchall returned too few rows")
+        beers = [res[0][0], res[1][0]]
+        beers.sort()
+        self.assertEqual(
+            beers[0],
+            "Cooper's",
+            "cursor.fetchall retrieved incorrect data, or data inserted incorrectly",
+        )
+        self.assertEqual(
+            beers[1],
+            "Victoria Bitter",
+            "cursor.fetchall retrieved incorrect data, or data inserted incorrectly",
+        )
+        trouble = "thi%s :may ca%(u)se? troub:1e"
+        self.assertEqual(
+            res[0][1],
+            trouble,
+            "cursor.fetchall retrieved incorrect data, or data inserted "
+            f"incorrectly. Got={res[0][1]!r}, Expected={trouble!r}",
+        )
+        self.assertEqual(
+            res[1][1],
+            trouble,
+            "cursor.fetchall retrieved incorrect data, or data inserted "
+            f"incorrectly. Got={res[1][1]!r}, Expected={trouble!r}",
+        )
+
+    def test_executemany(self):
+        con = self._connect()
+        try:
+            cur = con.cursor()
+            self.executeDDL1(cur)
+            largs = [("Cooper's",), ("Boag's",)]
+            margs = [{"beer": "Cooper's"}, {"beer": "Boag's"}]
+            if self.driver.paramstyle == "qmark":
+                cur.executemany(
+                    "insert into %sbooze values (?)" % self.table_prefix, largs
+                )
+            elif self.driver.paramstyle == "numeric":
+                cur.executemany(
+                    "insert into %sbooze values (:1)" % self.table_prefix, largs
+                )
+            elif self.driver.paramstyle == "named":
+                cur.executemany(
+                    "insert into %sbooze values (:beer)" % self.table_prefix, margs
+                )
+            elif self.driver.paramstyle == "format":
+                cur.executemany(
+                    "insert into %sbooze values (%%s)" % self.table_prefix, largs
+                )
+            elif self.driver.paramstyle == "pyformat":
+                cur.executemany(
+                    "insert into %sbooze values (%%(beer)s)" % (self.table_prefix),
+                    margs,
+                )
+            else:
+                self.fail("Unknown paramstyle")
+            self.assertTrue(
+                cur.rowcount in (-1, 2),
+                "insert using cursor.executemany set cursor.rowcount to "
+                "incorrect value %r" % cur.rowcount,
+            )
+            cur.execute("select name from %sbooze" % self.table_prefix)
+            res = cur.fetchall()
+            self.assertEqual(
+                len(res), 2, "cursor.fetchall retrieved incorrect number of rows"
+            )
+            beers = [res[0][0], res[1][0]]
+            beers.sort()
+            self.assertEqual(
+                beers[0], "Boag's", 'incorrect data "%s" retrieved' % beers[0]
+            )
+            self.assertEqual(beers[1], "Cooper's", "incorrect data retrieved")
+        finally:
+            con.close()
+
+    def test_fetchone(self):
+        con = self._connect()
+        try:
+            cur = con.cursor()
+
+            # cursor.fetchone should raise an Error if called before
+            # executing a select-type query
+            self.assertRaises(self.driver.Error, cur.fetchone)
+
+            # cursor.fetchone should raise an Error if called after
+            # executing a query that cannnot return rows
+            self.executeDDL1(cur)
+            self.assertRaises(self.driver.Error, cur.fetchone)
+
+            cur.execute("select name from %sbooze" % self.table_prefix)
+            self.assertEqual(
+                cur.fetchone(),
+                None,
+                "cursor.fetchone should return None if a query retrieves no rows",
+            )
+            self.assertTrue(cur.rowcount in (-1, 0))
+
+            # cursor.fetchone should raise an Error if called after
+            # executing a query that cannnot return rows
+            cur.execute(
+                "insert into %sbooze values ('Victoria Bitter')" % (self.table_prefix)
+            )
+            self.assertRaises(self.driver.Error, cur.fetchone)
+
+            cur.execute("select name from %sbooze" % self.table_prefix)
+            r = cur.fetchone()
+            self.assertEqual(
+                len(r), 1, "cursor.fetchone should have retrieved a single row"
+            )
+            self.assertEqual(
+                r[0], "Victoria Bitter", "cursor.fetchone retrieved incorrect data"
+            )
+            self.assertEqual(
+                cur.fetchone(),
+                None,
+                "cursor.fetchone should return None if no more rows available",
+            )
+            self.assertTrue(cur.rowcount in (-1, 1))
+        finally:
+            con.close()
+
+    samples = [
+        "Carlton Cold",
+        "Carlton Draft",
+        "Mountain Goat",
+        "Redback",
+        "Victoria Bitter",
+        "XXXX",
+    ]
+
+    def _populate(self):
+        """Return a list of sql commands to setup the DB for the fetch
+        tests.
+        """
+        populate = [
+            "insert into %sbooze values ('%s')" % (self.table_prefix, s)
+            for s in self.samples
+        ]
+        return populate
+
+    def test_fetchmany(self):
+        con = self._connect()
+        try:
+            cur = con.cursor()
+
+            # cursor.fetchmany should raise an Error if called without
+            # issuing a query
+            self.assertRaises(self.driver.Error, cur.fetchmany, 4)
+
+            self.executeDDL1(cur)
+            for sql in self._populate():
+                cur.execute(sql)
+
+            cur.execute("select name from %sbooze" % self.table_prefix)
+            r = cur.fetchmany()
+            self.assertEqual(
+                len(r),
+                1,
+                "cursor.fetchmany retrieved incorrect number of rows, "
+                "default of arraysize is one.",
+            )
+            cur.arraysize = 10
+            r = cur.fetchmany(3)  # Should get 3 rows
+            self.assertEqual(
+                len(r), 3, "cursor.fetchmany retrieved incorrect number of rows"
+            )
+            r = cur.fetchmany(4)  # Should get 2 more
+            self.assertEqual(
+                len(r), 2, "cursor.fetchmany retrieved incorrect number of rows"
+            )
+            r = cur.fetchmany(4)  # Should be an empty sequence
+            self.assertEqual(
+                len(r),
+                0,
+                "cursor.fetchmany should return an empty sequence after "
+                "results are exhausted",
+            )
+            self.assertTrue(cur.rowcount in (-1, 6))
+
+            # Same as above, using cursor.arraysize
+            cur.arraysize = 4
+            cur.execute("select name from %sbooze" % self.table_prefix)
+            r = cur.fetchmany()  # Should get 4 rows
+            self.assertEqual(
+                len(r), 4, "cursor.arraysize not being honoured by fetchmany"
+            )
+            r = cur.fetchmany()  # Should get 2 more
+            self.assertEqual(len(r), 2)
+            r = cur.fetchmany()  # Should be an empty sequence
+            self.assertEqual(len(r), 0)
+            self.assertTrue(cur.rowcount in (-1, 6))
+
+            cur.arraysize = 6
+            cur.execute("select name from %sbooze" % self.table_prefix)
+            rows = cur.fetchmany()  # Should get all rows
+            self.assertTrue(cur.rowcount in (-1, 6))
+            self.assertEqual(len(rows), 6)
+            self.assertEqual(len(rows), 6)
+            rows = [r[0] for r in rows]
+            rows.sort()
+
+            # Make sure we get the right data back out
+            for i in range(0, 6):
+                self.assertEqual(
+                    rows[i],
+                    self.samples[i],
+                    "incorrect data retrieved by cursor.fetchmany",
+                )
+
+            rows = cur.fetchmany()  # Should return an empty list
+            self.assertEqual(
+                len(rows),
+                0,
+                "cursor.fetchmany should return an empty sequence if "
+                "called after the whole result set has been fetched",
+            )
+            self.assertTrue(cur.rowcount in (-1, 6))
+
+            self.executeDDL2(cur)
+            cur.execute("select name from %sbarflys" % self.table_prefix)
+            r = cur.fetchmany()  # Should get empty sequence
+            self.assertEqual(
+                len(r),
+                0,
+                "cursor.fetchmany should return an empty sequence if "
+                "query retrieved no rows",
+            )
+            self.assertTrue(cur.rowcount in (-1, 0))
+
+        finally:
+            con.close()
+
+    def test_fetchall(self):
+        con = self._connect()
+        try:
+            cur = con.cursor()
+            # cursor.fetchall should raise an Error if called
+            # without executing a query that may return rows (such
+            # as a select)
+            self.assertRaises(self.driver.Error, cur.fetchall)
+
+            self.executeDDL1(cur)
+            for sql in self._populate():
+                cur.execute(sql)
+
+            # cursor.fetchall should raise an Error if called
+            # after executing a a statement that cannot return rows
+            self.assertRaises(self.driver.Error, cur.fetchall)
+
+            cur.execute("select name from %sbooze" % self.table_prefix)
+            rows = cur.fetchall()
+            self.assertTrue(cur.rowcount in (-1, len(self.samples)))
+            self.assertEqual(
+                len(rows),
+                len(self.samples),
+                "cursor.fetchall did not retrieve all rows",
+            )
+            rows = [r[0] for r in rows]
+            rows.sort()
+            for i in range(0, len(self.samples)):
+                self.assertEqual(
+                    rows[i], self.samples[i], "cursor.fetchall retrieved incorrect rows"
+                )
+            rows = cur.fetchall()
+            self.assertEqual(
+                len(rows),
+                0,
+                "cursor.fetchall should return an empty list if called "
+                "after the whole result set has been fetched",
+            )
+            self.assertTrue(cur.rowcount in (-1, len(self.samples)))
+
+            self.executeDDL2(cur)
+            cur.execute("select name from %sbarflys" % self.table_prefix)
+            rows = cur.fetchall()
+            self.assertTrue(cur.rowcount in (-1, 0))
+            self.assertEqual(
+                len(rows),
+                0,
+                "cursor.fetchall should return an empty list if "
+                "a select query returns no rows",
+            )
+
+        finally:
+            con.close()
+
+    def test_mixedfetch(self):
+        con = self._connect()
+        try:
+            cur = con.cursor()
+            self.executeDDL1(cur)
+            for sql in self._populate():
+                cur.execute(sql)
+
+            cur.execute("select name from %sbooze" % self.table_prefix)
+            rows1 = cur.fetchone()
+            rows23 = cur.fetchmany(2)
+            rows4 = cur.fetchone()
+            rows56 = cur.fetchall()
+            self.assertTrue(cur.rowcount in (-1, 6))
+            self.assertEqual(
+                len(rows23), 2, "fetchmany returned incorrect number of rows"
+            )
+            self.assertEqual(
+                len(rows56), 2, "fetchall returned incorrect number of rows"
+            )
+
+            rows = [rows1[0]]
+            rows.extend([rows23[0][0], rows23[1][0]])
+            rows.append(rows4[0])
+            rows.extend([rows56[0][0], rows56[1][0]])
+            rows.sort()
+            for i in range(0, len(self.samples)):
+                self.assertEqual(
+                    rows[i], self.samples[i], "incorrect data retrieved or inserted"
+                )
+        finally:
+            con.close()
+
+    def help_nextset_setUp(self, cur):
+        """Should create a procedure called deleteme
+        that returns two result sets, first the
+        number of rows in booze then "name from booze"
+        """
+        raise NotImplementedError("Helper not implemented")
+        # sql="""
+        #    create procedure deleteme as
+        #    begin
+        #        select count(*) from booze
+        #        select name from booze
+        #    end
+        # """
+        # cur.execute(sql)
+
+    def help_nextset_tearDown(self, cur):
+        "If cleaning up is needed after nextSetTest"
+        raise NotImplementedError("Helper not implemented")
+        # cur.execute("drop procedure deleteme")
+
+    def test_nextset(self):
+        raise NotImplementedError("Drivers need to override this test")
+
+    def test_arraysize(self):
+        # Not much here - rest of the tests for this are in test_fetchmany
+        con = self._connect()
+        try:
+            cur = con.cursor()
+            self.assertTrue(
+                hasattr(cur, "arraysize"), "cursor.arraysize must be defined"
+            )
+        finally:
+            con.close()
+
+    def test_setinputsizes(self):
+        con = self._connect()
+        try:
+            cur = con.cursor()
+            cur.setinputsizes((25,))
+            self._paraminsert(cur)  # Make sure cursor still works
+        finally:
+            con.close()
+
+    def test_setoutputsize_basic(self):
+        # Basic test is to make sure setoutputsize doesn't blow up
+        con = self._connect()
+        try:
+            cur = con.cursor()
+            cur.setoutputsize(1000)
+            cur.setoutputsize(2000, 0)
+            self._paraminsert(cur)  # Make sure the cursor still works
+        finally:
+            con.close()
+
+    def test_setoutputsize(self):
+        # Real test for setoutputsize is driver dependant
+        raise NotImplementedError("Driver needed to override this test")
+
+    def test_None(self):
+        con = self._connect()
+        try:
+            cur = con.cursor()
+            self.executeDDL1(cur)
+            cur.execute("insert into %sbooze values (NULL)" % self.table_prefix)
+            cur.execute("select name from %sbooze" % self.table_prefix)
+            r = cur.fetchall()
+            self.assertEqual(len(r), 1)
+            self.assertEqual(len(r[0]), 1)
+            self.assertEqual(r[0][0], None, "NULL value not returned as None")
+        finally:
+            con.close()
+
+    def test_Date(self):
+        d1 = self.driver.Date(2002, 12, 25)
+        d2 = self.driver.DateFromTicks(time.mktime((2002, 12, 25, 0, 0, 0, 0, 0, 0)))
+        # Can we assume this? API doesn't specify, but it seems implied
+        # self.assertEqual(str(d1),str(d2))
+
+    def test_Time(self):
+        t1 = self.driver.Time(13, 45, 30)
+        t2 = self.driver.TimeFromTicks(time.mktime((2001, 1, 1, 13, 45, 30, 0, 0, 0)))
+        # Can we assume this? API doesn't specify, but it seems implied
+        # self.assertEqual(str(t1),str(t2))
+
+    def test_Timestamp(self):
+        t1 = self.driver.Timestamp(2002, 12, 25, 13, 45, 30)
+        t2 = self.driver.TimestampFromTicks(
+            time.mktime((2002, 12, 25, 13, 45, 30, 0, 0, 0))
+        )
+        # Can we assume this? API doesn't specify, but it seems implied
+        # self.assertEqual(str(t1),str(t2))
+
+    def test_Binary(self):
+        b = self.driver.Binary(b"Something")
+        b = self.driver.Binary(b"")
+
+    def test_STRING(self):
+        self.assertTrue(hasattr(self.driver, "STRING"), "module.STRING must be defined")
+
+    def test_BINARY(self):
+        self.assertTrue(
+            hasattr(self.driver, "BINARY"), "module.BINARY must be defined."
+        )
+
+    def test_NUMBER(self):
+        self.assertTrue(
+            hasattr(self.driver, "NUMBER"), "module.NUMBER must be defined."
+        )
+
+    def test_DATETIME(self):
+        self.assertTrue(
+            hasattr(self.driver, "DATETIME"), "module.DATETIME must be defined."
+        )
+
+    def test_ROWID(self):
+        self.assertTrue(hasattr(self.driver, "ROWID"), "module.ROWID must be defined.")