Metadata-Version: 2.1
Name: mysql-connector-python
Version: 9.6.0
Summary: A self-contained Python driver for communicating with MySQL servers, using an API that is compliant with the Python Database API Specification v2.0 (PEP 249).
Home-page: UNKNOWN
Author: Oracle and/or its affiliates
Author-email: 
License: GNU GPLv2 (with FOSS License Exception)
Project-URL: Homepage, https://dev.mysql.com/doc/connector-python/en/
Project-URL: Documentation, https://dev.mysql.com/doc/connector-python/en/
Project-URL: Downloads, https://dev.mysql.com/downloads/connector/python/
Project-URL: Release Notes, https://dev.mysql.com/doc/relnotes/connector-python/en/
Project-URL: Source Code, https://github.com/mysql/mysql-connector-python
Project-URL: Bug System, https://bugs.mysql.com/
Project-URL: Slack, https://mysqlcommunity.slack.com/messages/connectors
Project-URL: Forums, https://forums.mysql.com/list.php?50
Project-URL: Blog, https://blogs.oracle.com/mysql/
Description: MySQL Connector/Python
        ======================
        
        
        
        .. image::
            https://img.shields.io/pypi/v/mysql-connector-python.svg
            :target: https://pypi.org/project/mysql-connector-python/
        
        .. image::
            https://img.shields.io/pypi/pyversions/mysql-connector-python.svg
            :target: https://pypi.org/project/mysql-connector-python/
        
        .. image::
            https://img.shields.io/pypi/l/mysql-connector-python.svg
            :target: https://pypi.org/project/mysql-connector-python/
        
        
        
        
        
        MySQL Connector/Python enables Python programs to access MySQL databases, using
        an API that is compliant with the `Python Database API Specification v2.0
        (PEP 249) <https://www.python.org/dev/peps/pep-0249/>`__.
        
        
        
        
        
        
        
        
        Features
        --------
        
        * `Asynchronous Connectivity <https://dev.mysql.com/doc/connector-python/en/connector-python-asyncio.html>`__
        * `C-extension <https://dev.mysql.com/doc/connector-python/en/connector-python-cext.html>`__
        * `Telemetry <https://dev.mysql.com/doc/connector-python/en/connector-python-opentelemetry.html>`__
        
        
        
        
        Installation
        ------------
        
        Connector/Python contains the Classic and X DevAPI connector APIs, which are
        installed separately. Any of these can be installed from a binary
        or source distribution.
        
        Binaries are distributed in the following package formats:
        
        * `RPM <https://docs.redhat.com/en/documentation/red_hat_enterprise_linux/8/html/packaging_and_distributing_software/introduction-to-rpm_packaging-and-distributing-software>`__
        * `WHEEL <https://packaging.python.org/en/latest/discussions/package-formats/#what-is-a-wheel>`__
        
        On the other hand, the source code is distributed as a compressed file
        from which a wheel package can be built.
        
        The recommended way to install Connector/Python is via `pip <https://pip.pypa.io/>`__,
        which relies on WHEEL packages. For such a reason, it is the installation procedure
        that is going to be described moving forward.
        
        Please, refer to the official MySQL documentation `Connector/Python Installation
        <https://dev.mysql.com/doc/connector-python/en/connector-python-installation.html>`__ to
        know more about installing from an RPM, or building and installing a WHEEL package from
        a source distribution.
        
        Before installing a package with `pip <https://pip.pypa.io/>`__, it is strongly suggested
        to have the most recent ``pip`` version installed on your system.
        If your system already has ``pip`` installed, you might need to update it. Or you can use
        the `standalone pip installer <https://pip.pypa.io/en/latest/installation/>`__.
        
        
        
        
        
        .. code-block:: bash
        
            $ pip install mysql-connector-python
        
        
        
        
        
        Installation Options
        ++++++++++++++++++++
        
        Connector packages included in MySQL Connector/Python allow you to install
        optional dependencies to unleash certain functionalities.
        
        
        .. code-block:: bash
        
            # 3rd party packages to unleash the telemetry functionality are installed
            $ pip install mysql-connector-python[telemetry]
        
        
        
        
        
        This installation option can be seen as a shortcut to install all the
        dependencies needed by a particular feature. Mind that this is optional
        and you are free to install the required dependencies by yourself.
        
        
        
        Available options:
        
        * dns-srv
        * gssapi
        * webauthn
        * telemetry
        
        
        
        
        
        
        
        Sample Code
        -----------------------------------
        
        .. code:: python
        
            import mysql.connector
        
            # Connect to server
            cnx = mysql.connector.connect(
                host="127.0.0.1",
                port=3306,
                user="mike",
                password="s3cre3t!")
        
            # Get a cursor
            cur = cnx.cursor()
        
            # Execute a query
            cur.execute("SELECT CURDATE()")
        
            # Fetch one result
            row = cur.fetchone()
            print("Current date is: {0}".format(row[0]))
        
            # Close connection
            cnx.close()
        
        
        
        
        
        
        
        HeatWave GenAI and Machine Learning Support
        -------------------------------------------
        
        MySQL Connector/Python now includes an optional API for integrating directly with MySQL HeatWave's AI and Machine Learning capabilities. This new SDK is designed to reduce the time required to generate proofs-of-concept (POCs) by providing an intuitive Pythonic interface that automates the management of SQL tables and procedures.
        
        The new ``mysql.ai`` module offers two primary components:
        
        * **GenAI:** Provides implementations of LangChain's abstract ``LLM``, ``VectorStore``, and ``Embeddings`` classes (``MyLLM``, ``MyVectorStore``, ``MyEmbeddings``). This ensures full interoperability with existing LangChain pipelines, allowing developers to easily substitute existing components with HeatWave-backed versions.
        * **AutoML:** Provides Scikit-Learn compatible estimators (``MyClassifier``, ``MyRegressor``, ``MyAnomalyDetector``, ``MyGenericTransformer``) that inherit from standard Scikit-Learn mixins. These components accept Pandas DataFrames and can be dropped directly into existing Scikit-Learn pipelines and grid searches.
        
        **Note on Dependencies:** These features introduce dependencies on ``langchain``, ``pandas``, and ``scikit-learn``. To keep existing installations unchanged and the base connector lightweight, these dependencies are **not installed by default**. You must install them separately to use the ``mysql.ai`` features.
        
        **Example: GenAI Chatbot with Memory**
        
        This example demonstrates how to use ``MyLLM`` within a loop to create a simple chatbot that maintains conversation history.
        
        .. code:: python
        
            from collections import deque
            from mysql import connector
            from mysql.ai.genai import MyLLM
        
            def run_chatbot(db_connection, chat_history_size=5):
                # Initialize MyLLM with the database connection
                my_llm = MyLLM(db_connection)
        
                # Maintain a limited history for context
                chat_history = deque(maxlen=chat_history_size)
                system_msg = "System: You are a helpful AI assistant."
        
                while True:
                    user_input = input("\nUser: ")
                    if user_input.lower() in ["exit", "quit"]:
                        break
        
                    # Format history and invoke the LLM
                    history = [system_msg] + list(chat_history) + [f"User: {user_input}"]
                    prompt = "\n".join(history)
        
                    # Invoke HeatWave GenAI
                    response = my_llm.invoke(prompt)
                    print(f"Bot: {response}")
        
                    # Update history
                    chat_history.append(f"User: {user_input}")
                    chat_history.append(f"Bot: {response}")
        
            # Usage
            with connector.connect(user='root', database='mlcorpus') as db_connection:
                run_chatbot(db_connection)
        
        **Example: HeatWave AutoML in a Scikit-Learn Pipeline**
        
        This example shows how to use ``MyClassifier`` as a drop-in replacement within a standard Scikit-Learn pipeline.
        
        .. code:: python
        
            import pandas as pd
            from mysql import connector
            from sklearn.pipeline import Pipeline
            from sklearn.preprocessing import StandardScaler
            from mysql.ai.ml import MyClassifier
        
            # 1. Setup Data (Pandas DataFrame)
            X = pd.DataFrame([[0.5, 0.1], [1.0, 0.8], [0.1, 0.2]], columns=["feat1", "feat2"])
            y = pd.Series([0, 1, 0], name="target")
        
            # 2. Connect and Train
            with connector.connect(user='root', database='mlcorpus') as db_connection:
                # Initialize the HeatWave classifier
                clf = MyClassifier(db_connection)
        
                # Create a standard Scikit-Learn pipeline
                pipe = Pipeline([
                    ("scaler", StandardScaler()),
                    ("mysql_clf", clf)
                ])
        
                # Fit the model (automates upload and training on HeatWave)
                pipe.fit(X, y)
        
                # Predict
                preds = pipe.predict(X)
                print(f"Predictions: {preds}")
        
                # Score
                score = pipe.score(X, y)
                print(f"Accuracy: {score}")
        
        
        
        
        
        Additional Resources
        --------------------
        
        - `MySQL Connector/Python Developer Guide <https://dev.mysql.com/doc/connector-python/en/>`__
        
        - `MySQL Connector/Python Forum <http://forums.mysql.com/list.php?50>`__
        - `MySQL Public Bug Tracker <https://bugs.mysql.com>`__
        - `Slack <https://mysqlcommunity.slack.com>`__ (`Sign-up <https://lefred.be/mysql-community-on-slack/>`__ required if you do not have an Oracle account)
        - `Stack Overflow <https://stackoverflow.com/questions/tagged/mysql-connector-python>`__
        - `Oracle Blogs <https://blogs.oracle.com/search.html?q=connector-python>`__
        
        
        
        Contributing
        ------------
        
        There are a few ways to contribute to the Connector/Python code. Please refer
        to the `contributing guidelines <https://github.com/mysql/mysql-connector-python/blob/trunk/CONTRIBUTING.md>`__ for additional information.
        
        License
        -------
        
        Please refer to the `README.txt <https://github.com/mysql/mysql-connector-python/blob/trunk/README.txt>`__ and `LICENSE.txt <https://github.com/mysql/mysql-connector-python/blob/trunk/LICENSE.txt>`__
        files, available in this repository, for further details.
        
Keywords: mysql,database,db,connector,driver
Platform: UNKNOWN
Classifier: Development Status :: 5 - Production/Stable
Classifier: Intended Audience :: Developers
Classifier: Intended Audience :: Education
Classifier: License :: OSI Approved :: GNU General Public License (GPL)
Classifier: Operating System :: MacOS :: MacOS X
Classifier: Operating System :: Microsoft :: Windows
Classifier: Operating System :: POSIX :: Linux
Classifier: Operating System :: Unix
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3.10
Classifier: Programming Language :: Python :: 3.11
Classifier: Programming Language :: Python :: 3.12
Classifier: Programming Language :: Python :: 3.13
Classifier: Programming Language :: Python :: 3.14
Classifier: Topic :: Database
Classifier: Topic :: Software Development
Classifier: Topic :: Software Development :: Libraries :: Python Modules
Classifier: Typing :: Typed
Requires-Python: >=3.10
Description-Content-Type: text/x-rst
Provides-Extra: dns-srv
Provides-Extra: gssapi
Provides-Extra: telemetry
Provides-Extra: webauthn
