File sqlite3-to-mysql-1.4.1.obscpio of Package python-sqlite3-to-mysql

Overview Repositories Revisions Requests Users Attributes Meta

File sqlite3-to-mysql-1.4.1.obscpio of Package python-sqlite3-to-mysql (Revision f62de21ee17fce8292c48498f08a0445)

Currently displaying revision f62de21ee17fce8292c48498f08a0445 , Show latest

07070100000000000081A4000003E8000000640000000160872D0000002011000000000000000000000000000000000000002300000000sqlite3-to-mysql-1.4.1/.bandit.yml### This config may optionally select a subset of tests to run or skip by
### filling out the 'tests' and 'skips' lists given below. If no tests are
### specified for inclusion then it is assumed all tests are desired. The skips
### set will remove specific tests from the include set. This can be controlled
### using the -t/-s CLI options. Note that the same test ID should not appear
### in both 'tests' and 'skips', this would be nonsensical and is detected by
### Bandit at runtime.

# Available tests:
# B101 : assert_used
# B102 : exec_used
# B103 : set_bad_file_permissions
# B104 : hardcoded_bind_all_interfaces
# B105 : hardcoded_password_string
# B106 : hardcoded_password_funcarg
# B107 : hardcoded_password_default
# B108 : hardcoded_tmp_directory
# B110 : try_except_pass
# B112 : try_except_continue
# B201 : flask_debug_true
# B301 : pickle
# B302 : marshal
# B303 : md5
# B304 : ciphers
# B305 : cipher_modes
# B306 : mktemp_q
# B307 : eval
# B308 : mark_safe
# B309 : httpsconnection
# B310 : urllib_urlopen
# B311 : random
# B312 : telnetlib
# B313 : xml_bad_cElementTree
# B314 : xml_bad_ElementTree
# B315 : xml_bad_expatreader
# B316 : xml_bad_expatbuilder
# B317 : xml_bad_sax
# B318 : xml_bad_minidom
# B319 : xml_bad_pulldom
# B320 : xml_bad_etree
# B321 : ftplib
# B322 : input
# B323 : unverified_context
# B324 : hashlib_new_insecure_functions
# B325 : tempnam
# B401 : import_telnetlib
# B402 : import_ftplib
# B403 : import_pickle
# B404 : import_subprocess
# B405 : import_xml_etree
# B406 : import_xml_sax
# B407 : import_xml_expat
# B408 : import_xml_minidom
# B409 : import_xml_pulldom
# B410 : import_lxml
# B411 : import_xmlrpclib
# B412 : import_httpoxy
# B413 : import_pycrypto
# B501 : request_with_no_cert_validation
# B502 : ssl_with_bad_version
# B503 : ssl_with_bad_defaults
# B504 : ssl_with_no_version
# B505 : weak_cryptographic_key
# B506 : yaml_load
# B507 : ssh_no_host_key_verification
# B601 : paramiko_calls
# B602 : subprocess_popen_with_shell_equals_true
# B603 : subprocess_without_shell_equals_true
# B604 : any_other_function_with_shell_equals_true
# B605 : start_process_with_a_shell
# B606 : start_process_with_no_shell
# B607 : start_process_with_partial_path
# B608 : hardcoded_sql_expressions
# B609 : linux_commands_wildcard_injection
# B610 : django_extra_used
# B611 : django_rawsql_used
# B701 : jinja2_autoescape_false
# B702 : use_of_mako_templates
# B703 : django_mark_safe

# (optional) list included test IDs here, eg '[B101, B406]':
tests:

# (optional) list skipped test IDs here, eg '[B101, B406]':
skips:
  - B404
  - B603
  - B607
  - B608

### (optional) plugin settings - some test plugins require configuration data
### that may be given here, per-plugin. All bandit test plugins have a built in
### set of sensible defaults and these will be used if no configuration is
### provided. It is not necessary to provide settings for every (or any) plugin
### if the defaults are acceptable.

any_other_function_with_shell_equals_true:
  no_shell:
  - os.execl
  - os.execle
  - os.execlp
  - os.execlpe
  - os.execv
  - os.execve
  - os.execvp
  - os.execvpe
  - os.spawnl
  - os.spawnle
  - os.spawnlp
  - os.spawnlpe
  - os.spawnv
  - os.spawnve
  - os.spawnvp
  - os.spawnvpe
  - os.startfile
  shell:
  - os.system
  - os.popen
  - os.popen2
  - os.popen3
  - os.popen4
  - popen2.popen2
  - popen2.popen3
  - popen2.popen4
  - popen2.Popen3
  - popen2.Popen4
  - commands.getoutput
  - commands.getstatusoutput
  subprocess:
  - subprocess.Popen
  - subprocess.call
  - subprocess.check_call
  - subprocess.check_output
  - subprocess.run
hardcoded_tmp_directory:
  tmp_dirs:
  - /tmp
  - /var/tmp
  - /dev/shm
linux_commands_wildcard_injection:
  no_shell:
  - os.execl
  - os.execle
  - os.execlp
  - os.execlpe
  - os.execv
  - os.execve
  - os.execvp
  - os.execvpe
  - os.spawnl
  - os.spawnle
  - os.spawnlp
  - os.spawnlpe
  - os.spawnv
  - os.spawnve
  - os.spawnvp
  - os.spawnvpe
  - os.startfile
  shell:
  - os.system
  - os.popen
  - os.popen2
  - os.popen3
  - os.popen4
  - popen2.popen2
  - popen2.popen3
  - popen2.popen4
  - popen2.Popen3
  - popen2.Popen4
  - commands.getoutput
  - commands.getstatusoutput
  subprocess:
  - subprocess.Popen
  - subprocess.call
  - subprocess.check_call
  - subprocess.check_output
  - subprocess.run
ssl_with_bad_defaults:
  bad_protocol_versions:
  - PROTOCOL_SSLv2
  - SSLv2_METHOD
  - SSLv23_METHOD
  - PROTOCOL_SSLv3
  - PROTOCOL_TLSv1
  - SSLv3_METHOD
  - TLSv1_METHOD
ssl_with_bad_version:
  bad_protocol_versions:
  - PROTOCOL_SSLv2
  - SSLv2_METHOD
  - SSLv23_METHOD
  - PROTOCOL_SSLv3
  - PROTOCOL_TLSv1
  - SSLv3_METHOD
  - TLSv1_METHOD
start_process_with_a_shell:
  no_shell:
  - os.execl
  - os.execle
  - os.execlp
  - os.execlpe
  - os.execv
  - os.execve
  - os.execvp
  - os.execvpe
  - os.spawnl
  - os.spawnle
  - os.spawnlp
  - os.spawnlpe
  - os.spawnv
  - os.spawnve
  - os.spawnvp
  - os.spawnvpe
  - os.startfile
  shell:
  - os.system
  - os.popen
  - os.popen2
  - os.popen3
  - os.popen4
  - popen2.popen2
  - popen2.popen3
  - popen2.popen4
  - popen2.Popen3
  - popen2.Popen4
  - commands.getoutput
  - commands.getstatusoutput
  subprocess:
  - subprocess.Popen
  - subprocess.call
  - subprocess.check_call
  - subprocess.check_output
  - subprocess.run
start_process_with_no_shell:
  no_shell:
  - os.execl
  - os.execle
  - os.execlp
  - os.execlpe
  - os.execv
  - os.execve
  - os.execvp
  - os.execvpe
  - os.spawnl
  - os.spawnle
  - os.spawnlp
  - os.spawnlpe
  - os.spawnv
  - os.spawnve
  - os.spawnvp
  - os.spawnvpe
  - os.startfile
  shell:
  - os.system
  - os.popen
  - os.popen2
  - os.popen3
  - os.popen4
  - popen2.popen2
  - popen2.popen3
  - popen2.popen4
  - popen2.Popen3
  - popen2.Popen4
  - commands.getoutput
  - commands.getstatusoutput
  subprocess:
  - subprocess.Popen
  - subprocess.call
  - subprocess.check_call
  - subprocess.check_output
  - subprocess.run
start_process_with_partial_path:
  no_shell:
  - os.execl
  - os.execle
  - os.execlp
  - os.execlpe
  - os.execv
  - os.execve
  - os.execvp
  - os.execvpe
  - os.spawnl
  - os.spawnle
  - os.spawnlp
  - os.spawnlpe
  - os.spawnv
  - os.spawnve
  - os.spawnvp
  - os.spawnvpe
  - os.startfile
  shell:
  - os.system
  - os.popen
  - os.popen2
  - os.popen3
  - os.popen4
  - popen2.popen2
  - popen2.popen3
  - popen2.popen4
  - popen2.Popen3
  - popen2.Popen4
  - commands.getoutput
  - commands.getstatusoutput
  subprocess:
  - subprocess.Popen
  - subprocess.call
  - subprocess.check_call
  - subprocess.check_output
  - subprocess.run
subprocess_popen_with_shell_equals_true:
  no_shell:
  - os.execl
  - os.execle
  - os.execlp
  - os.execlpe
  - os.execv
  - os.execve
  - os.execvp
  - os.execvpe
  - os.spawnl
  - os.spawnle
  - os.spawnlp
  - os.spawnlpe
  - os.spawnv
  - os.spawnve
  - os.spawnvp
  - os.spawnvpe
  - os.startfile
  shell:
  - os.system
  - os.popen
  - os.popen2
  - os.popen3
  - os.popen4
  - popen2.popen2
  - popen2.popen3
  - popen2.popen4
  - popen2.Popen3
  - popen2.Popen4
  - commands.getoutput
  - commands.getstatusoutput
  subprocess:
  - subprocess.Popen
  - subprocess.call
  - subprocess.check_call
  - subprocess.check_output
  - subprocess.run
subprocess_without_shell_equals_true:
  no_shell:
  - os.execl
  - os.execle
  - os.execlp
  - os.execlpe
  - os.execv
  - os.execve
  - os.execvp
  - os.execvpe
  - os.spawnl
  - os.spawnle
  - os.spawnlp
  - os.spawnlpe
  - os.spawnv
  - os.spawnve
  - os.spawnvp
  - os.spawnvpe
  - os.startfile
  shell:
  - os.system
  - os.popen
  - os.popen2
  - os.popen3
  - os.popen4
  - popen2.popen2
  - popen2.popen3
  - popen2.popen4
  - popen2.Popen3
  - popen2.Popen4
  - commands.getoutput
  - commands.getstatusoutput
  subprocess:
  - subprocess.Popen
  - subprocess.call
  - subprocess.check_call
  - subprocess.check_output
  - subprocess.run
try_except_continue:
  check_typed_exception: false
try_except_pass:
  check_typed_exception: false
weak_cryptographic_key:
  weak_key_size_dsa_high: 1024
  weak_key_size_dsa_medium: 2048
  weak_key_size_ec_high: 160
  weak_key_size_ec_medium: 224
  weak_key_size_rsa_high: 1024
  weak_key_size_rsa_medium: 2048

07070100000001000081A4000003E8000000640000000160872D000000002C000000000000000000000000000000000000002300000000sqlite3-to-mysql-1.4.1/.coveragerc[run]
omit = sqlite3_to_mysql/__version__.py07070100000002000041ED000003E8000000640000000160872D0000000000000000000000000000000000000000000000001F00000000sqlite3-to-mysql-1.4.1/.github07070100000003000041ED000003E8000000640000000160872D0000000000000000000000000000000000000000000000002E00000000sqlite3-to-mysql-1.4.1/.github/ISSUE_TEMPLATE07070100000004000081A4000003E8000000640000000160872D000000024B000000000000000000000000000000000000003C00000000sqlite3-to-mysql-1.4.1/.github/ISSUE_TEMPLATE/bug_report.md---
name: Bug report
about: Create a report to help us improve
title: ''
labels: bug
assignees: techouse

---

**Describe the bug**
A clear and concise description of what the bug is.

**Expected behaviour**
What you expected.

**Actual result**
What happened instead.

**System Information**

```bash
$ sqlite3mysql --version
```

```
<paste here>
```

This command is only available on v1.3.6 and greater. Otherwise, please provide some basic information about your system (Python version, operating system, etc.).

**Additional context**
Add any other context about the problem here.
07070100000005000081A4000003E8000000640000000160872D0000000262000000000000000000000000000000000000004100000000sqlite3-to-mysql-1.4.1/.github/ISSUE_TEMPLATE/feature_request.md---
name: Feature request
about: Suggest an idea for this project
title: ''
labels: enhancement
assignees: techouse

---

**Is your feature request related to a problem? Please describe.**
A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]

**Describe the solution you'd like**
A clear and concise description of what you want to happen.

**Describe alternatives you've considered**
A clear and concise description of any alternative solutions or features you've considered.

**Additional context**
Add any other context or screenshots about the feature request here.
07070100000006000041ED000003E8000000640000000160872D0000000000000000000000000000000000000000000000002900000000sqlite3-to-mysql-1.4.1/.github/workflows07070100000007000081A4000003E8000000640000000160872D0000000278000000000000000000000000000000000000003D00000000sqlite3-to-mysql-1.4.1/.github/workflows/codeql-analysis.ymlname: "CodeQL"

on:
  push:
    branches: [ master ]
  pull_request:
    # The branches below must be a subset of the branches above
    branches: [ master ]
  schedule:
    - cron: '0 12 * * 6'

jobs:
  analyze:
    name: Analyze
    runs-on: ubuntu-latest

strategy:
      fail-fast: false
      matrix:
        language: [ 'python' ]
        
    steps:
    - name: Checkout repository
      uses: actions/checkout@v2

- name: Initialize CodeQL
      uses: github/codeql-action/init@v1
      with:
        languages: ${{ matrix.language }}

- name: Perform CodeQL Analysis
      uses: github/codeql-action/analyze@v1
07070100000008000081A4000003E8000000640000000160872D00000026CC000000000000000000000000000000000000003200000000sqlite3-to-mysql-1.4.1/.github/workflows/test.ymlname: Test

on:
  push:
    branches: [ master ]
  pull_request:
    branches: [ master ]

jobs:
  build:

runs-on: ubuntu-18.04
    strategy:
      matrix:
        include:
          - toxenv: "py27"
            db: "mariadb:5.5"
            legacy_db: 1
            py: "2.7"

- toxenv: "py35"
            db: "mariadb:5.5"
            legacy_db: 1
            py: "3.5"

- toxenv: "py36"
            db: "mariadb:5.5"
            legacy_db: 1
            py: "3.6"

- toxenv: "py37"
            db: "mariadb:5.5"
            legacy_db: 1
            py: "3.7"

- toxenv: "py38"
            db: "mariadb:5.5"
            legacy_db: 1
            py: "3.8"

- toxenv: "py39"
            db: "mariadb:5.5"
            legacy_db: 1
            py: "3.9"

- toxenv: "py27"
            db: "mariadb:10.0"
            legacy_db: 1
            py: "2.7"

- toxenv: "py35"
            db: "mariadb:10.0"
            legacy_db: 1
            py: "3.5"

- toxenv: "py36"
            db: "mariadb:10.0"
            legacy_db: 1
            py: "3.6"

- toxenv: "py37"
            db: "mariadb:10.0"
            legacy_db: 1
            py: "3.7"

- toxenv: "py38"
            db: "mariadb:10.0"
            legacy_db: 1
            py: "3.8"

- toxenv: "py39"
            db: "mariadb:10.0"
            legacy_db: 1
            py: "3.9"

- toxenv: "py27"
            db: "mariadb:10.1"
            legacy_db: 1
            py: "2.7"

- toxenv: "py35"
            db: "mariadb:10.1"
            legacy_db: 1
            py: "3.5"

- toxenv: "py36"
            db: "mariadb:10.1"
            legacy_db: 1
            py: "3.6"
          - toxenv: "py37"
            db: "mariadb:10.1"
            legacy_db: 1
            py: "3.7"

- toxenv: "py38"
            db: "mariadb:10.1"
            legacy_db: 1
            py: "3.8"

- toxenv: "py39"
            db: "mariadb:10.1"
            legacy_db: 1
            py: "3.9"

- toxenv: "py27"
            db: "mariadb:10.2"
            legacy_db: 0
            py: "2.7"

- toxenv: "py35"
            db: "mariadb:10.2"
            legacy_db: 0
            py: "3.5"

- toxenv: "py36"
            db: "mariadb:10.2"
            legacy_db: 0
            py: "3.6"

- toxenv: "py37"
            db: "mariadb:10.2"
            legacy_db: 0
            py: "3.7"

- toxenv: "py38"
            db: "mariadb:10.2"
            legacy_db: 0
            py: "3.8"

- toxenv: "py39"
            db: "mariadb:10.2"
            legacy_db: 0
            py: "3.9"

- toxenv: "py27"
            db: "mariadb:10.3"
            legacy_db: 0
            py: "2.7"

- toxenv: "py35"
            db: "mariadb:10.3"
            legacy_db: 0
            py: "3.5"

- toxenv: "py36"
            db: "mariadb:10.3"
            legacy_db: 0
            py: "3.6"

- toxenv: "py37"
            db: "mariadb:10.3"
            legacy_db: 0
            py: "3.7"

- toxenv: "py38"
            db: "mariadb:10.3"
            legacy_db: 0
            py: "3.8"

- toxenv: "py39"
            db: "mariadb:10.3"
            legacy_db: 0
            py: "3.9"

- toxenv: "py27"
            db: "mariadb:10.4"
            legacy_db: 0
            py: "2.7"

- toxenv: "py35"
            db: "mariadb:10.4"
            legacy_db: 0
            py: "3.5"

- toxenv: "py36"
            db: "mariadb:10.4"
            legacy_db: 0
            py: "3.6"

- toxenv: "py37"
            db: "mariadb:10.4"
            legacy_db: 0
            py: "3.7"

- toxenv: "py38"
            db: "mariadb:10.4"
            legacy_db: 0
            py: "3.8"

- toxenv: "py39"
            db: "mariadb:10.4"
            legacy_db: 0
            py: "3.9"

- toxenv: "py27"
            db: "mariadb:10.5"
            legacy_db: 0
            py: "2.7"

- toxenv: "py35"
            db: "mariadb:10.5"
            legacy_db: 0
            py: "3.5"

- toxenv: "py36"
            db: "mariadb:10.5"
            legacy_db: 0
            py: "3.6"

- toxenv: "py37"
            db: "mariadb:10.5"
            legacy_db: 0
            py: "3.7"

- toxenv: "py38"
            db: "mariadb:10.5"
            legacy_db: 0
            py: "3.8"

- toxenv: "py39"
            db: "mariadb:10.5"
            legacy_db: 0
            py: "3.9"

- toxenv: "py27"
            db: "mysql:5.5"
            legacy_db: 1
            py: "2.7"

- toxenv: "py35"
            db: "mysql:5.5"
            legacy_db: 1
            py: "3.5"

- toxenv: "py36"
            db: "mysql:5.5"
            legacy_db: 1
            py: "3.6"

- toxenv: "py37"
            db: "mysql:5.5"
            legacy_db: 1
            py: "3.7"

- toxenv: "py38"
            db: "mysql:5.5"
            legacy_db: 1
            py: "3.8"

- toxenv: "py39"
            db: "mysql:5.6"
            legacy_db: 1
            py: "3.9"

- toxenv: "py27"
            db: "mysql:5.6"
            legacy_db: 1
            py: "2.7"

- toxenv: "py35"
            db: "mysql:5.6"
            legacy_db: 1
            py: "3.5"

- toxenv: "py36"
            db: "mysql:5.6"
            legacy_db: 1
            py: "3.6"

- toxenv: "py37"
            db: "mysql:5.6"
            legacy_db: 1
            py: "3.7"

- toxenv: "py38"
            db: "mysql:5.6"
            legacy_db: 1
            py: "3.8"

- toxenv: "py39"
            db: "mysql:5.6"
            legacy_db: 1
            py: "3.9"

- toxenv: "py27"
            db: "mysql:5.7"
            legacy_db: 0
            py: "2.7"

- toxenv: "py35"
            db: "mysql:5.7"
            legacy_db: 0
            py: "3.5"

- toxenv: "py36"
            db: "mysql:5.7"
            legacy_db: 0
            py: "3.6"

- toxenv: "py37"
            db: "mysql:5.7"
            legacy_db: 0
            py: "3.7"

- toxenv: "py38"
            db: "mysql:5.7"
            legacy_db: 0
            py: "3.8"

- toxenv: "py39"
            db: "mysql:5.7"
            legacy_db: 0
            py: "3.9"

- toxenv: "py27"
            db: "mysql:8.0"
            legacy_db: 0
            py: "2.7"

- toxenv: "py35"
            db: "mysql:8.0"
            legacy_db: 0
            py: "3.5"

- toxenv: "py36"
            db: "mysql:8.0"
            legacy_db: 0
            py: "3.6"

- toxenv: "py37"
            db: "mysql:8.0"
            legacy_db: 0
            py: "3.7"

- toxenv: "py38"
            db: "mysql:8.0"
            legacy_db: 0
            py: "3.8"

- toxenv: "py39"
            db: "mysql:8.0"
            legacy_db: 0
            py: "3.9"

services:
      mysql:
        image: "${{ matrix.db }}"
        ports:
          - 3306:3306
        env:
          MYSQL_ALLOW_EMPTY_PASSWORD: yes
        options: "--name=mysqld"

steps:
      - uses: actions/checkout@v2
      - name: Set up Python ${{ matrix.py }}
        uses: actions/setup-python@v2
        with:
          python-version: ${{ matrix.py }}

- uses: actions/cache@v2
        with:
          path: ~/.cache/pip
          key: ${{ runner.os }}-pip-1
          restore-keys: |
            ${{ runner.os }}-pip-

- name: Install dependencies
        run: |
          python -m pip install --upgrade pip
          python -m pip install -U codecov tox-gh-actions
          pip install -r requirements_dev.txt

- name: Set up MySQL
        env:
          DB: ${{ matrix.db }}
        run: |
          while :
          do
              sleep 1
              mysql -h127.0.0.1 -uroot -e 'select version()' && break
          done
          if [ $DB == 'mysql:8.0' ]; then
              WITH_PLUGIN='with mysql_native_password'
              mysql -h127.0.0.1 -uroot -e "SET GLOBAL local_infile=on"
              docker cp mysqld:/var/lib/mysql/public_key.pem "${HOME}"
              docker cp mysqld:/var/lib/mysql/ca.pem "${HOME}"
              docker cp mysqld:/var/lib/mysql/server-cert.pem "${HOME}"
              docker cp mysqld:/var/lib/mysql/client-key.pem "${HOME}"
              docker cp mysqld:/var/lib/mysql/client-cert.pem "${HOME}"
              mysql -uroot -h127.0.0.1 -e '
                  CREATE USER
                      user_sha256   IDENTIFIED WITH "sha256_password" BY "pass_sha256",
                      nopass_sha256 IDENTIFIED WITH "sha256_password",
                      user_caching_sha2   IDENTIFIED WITH "caching_sha2_password" BY "pass_caching_sha2",
                      nopass_caching_sha2 IDENTIFIED WITH "caching_sha2_password"
                      PASSWORD EXPIRE NEVER;'
              mysql -uroot -h127.0.0.1 -e 'GRANT RELOAD ON *.* TO user_caching_sha2;'
          else
              WITH_PLUGIN=''
          fi
          mysql -h127.0.0.1 -uroot -e 'create database test_db DEFAULT CHARACTER SET utf8mb4'
          mysql -h127.0.0.1 -uroot -e "create user tester           identified ${WITH_PLUGIN} by 'testpass'; grant all on test_db.* to tester;"
          mysql -h127.0.0.1 -uroot -e "create user tester@localhost identified ${WITH_PLUGIN} by 'testpass'; grant all on test_db.* to tester@localhost;"
          cp ci/db_credentials.json tests/db_credentials.json

- name: Test with tox
        run: tox
        env:
          LEGACY_DB: ${{ matrix.legacy_db }}

- name: Upload coverage to Codecov
        uses: codecov/codecov-action@v1
        with:
          files: ./coverage.xml
          env_vars: OS,PYTHON
          verbose: true07070100000009000081A4000003E8000000640000000160872D000000158B000000000000000000000000000000000000002A00000000sqlite3-to-mysql-1.4.1/CODE-OF-CONDUCT.md# Contributor Covenant Code of Conduct

## Our Pledge

We as members, contributors, and leaders pledge to make participation in our
community a harassment-free experience for everyone, regardless of age, body
size, visible or invisible disability, ethnicity, sex characteristics, gender
identity and expression, level of experience, education, socio-economic status,
nationality, personal appearance, race, caste, color, religion, or sexual identity
and orientation.

We pledge to act and interact in ways that contribute to an open, welcoming,
diverse, inclusive, and healthy community.

## Our Standards

Examples of behavior that contributes to a positive environment for our
community include:

* Demonstrating empathy and kindness toward other people
* Being respectful of differing opinions, viewpoints, and experiences
* Giving and gracefully accepting constructive feedback
* Accepting responsibility and apologizing to those affected by our mistakes,
  and learning from the experience
* Focusing on what is best not just for us as individuals, but for the
  overall community

Examples of unacceptable behavior include:

* The use of sexualized language or imagery, and sexual attention or
  advances of any kind
* Trolling, insulting or derogatory comments, and personal or political attacks
* Public or private harassment
* Publishing others' private information, such as a physical or email
  address, without their explicit permission
* Other conduct which could reasonably be considered inappropriate in a
  professional setting

## Enforcement Responsibilities

Community leaders are responsible for clarifying and enforcing our standards of
acceptable behavior and will take appropriate and fair corrective action in
response to any behavior that they deem inappropriate, threatening, offensive,
or harmful.

Community leaders have the right and responsibility to remove, edit, or reject
comments, commits, code, wiki edits, issues, and other contributions that are
not aligned to this Code of Conduct, and will communicate reasons for moderation
decisions when appropriate.

## Scope

This Code of Conduct applies within all community spaces, and also applies when
an individual is officially representing the community in public spaces.
Examples of representing our community include using an official e-mail address,
posting via an official social media account, or acting as an appointed
representative at an online or offline event.

## Enforcement

Instances of abusive, harassing, or otherwise unacceptable behavior may be
reported to the community leaders responsible for enforcement at
[techouse@gmail.com](mailto:techouse@gmail.com).
All complaints will be reviewed and investigated promptly and fairly.

All community leaders are obligated to respect the privacy and security of the
reporter of any incident.

## Enforcement Guidelines

Community leaders will follow these Community Impact Guidelines in determining
the consequences for any action they deem in violation of this Code of Conduct:

### 1. Correction

**Community Impact**: Use of inappropriate language or other behavior deemed
unprofessional or unwelcome in the community.

**Consequence**: A private, written warning from community leaders, providing
clarity around the nature of the violation and an explanation of why the
behavior was inappropriate. A public apology may be requested.

### 2. Warning

**Community Impact**: A violation through a single incident or series
of actions.

**Consequence**: A warning with consequences for continued behavior. No
interaction with the people involved, including unsolicited interaction with
those enforcing the Code of Conduct, for a specified period of time. This
includes avoiding interactions in community spaces as well as external channels
like social media. Violating these terms may lead to a temporary or
permanent ban.

### 3. Temporary Ban

**Community Impact**: A serious violation of community standards, including
sustained inappropriate behavior.

**Consequence**: A temporary ban from any sort of interaction or public
communication with the community for a specified period of time. No public or
private interaction with the people involved, including unsolicited interaction
with those enforcing the Code of Conduct, is allowed during this period.
Violating these terms may lead to a permanent ban.

### 4. Permanent Ban

**Community Impact**: Demonstrating a pattern of violation of community
standards, including sustained inappropriate behavior,  harassment of an
individual, or aggression toward or disparagement of classes of individuals.

**Consequence**: A permanent ban from any sort of public interaction within
the community.

## Attribution

This Code of Conduct is adapted from the [Contributor Covenant][homepage],
version 2.0, available at
[https://www.contributor-covenant.org/version/2/0/code_of_conduct.html][v2.0].

Community Impact Guidelines were inspired by 
[Mozilla's code of conduct enforcement ladder][Mozilla CoC].

For answers to common questions about this code of conduct, see the FAQ at
[https://www.contributor-covenant.org/faq][FAQ]. Translations are available 
at [https://www.contributor-covenant.org/translations][translations].

[homepage]: https://www.contributor-covenant.org
[v2.0]: https://www.contributor-covenant.org/version/2/0/code_of_conduct.html
[Mozilla CoC]: https://github.com/mozilla/diversity
[FAQ]: https://www.contributor-covenant.org/faq
[translations]: https://www.contributor-covenant.org/translations
0707010000000A000081A4000003E8000000640000000160872D0000000B56000000000000000000000000000000000000002700000000sqlite3-to-mysql-1.4.1/CONTRIBUTING.md# Contributing

I'm really glad you're reading this, because we need volunteer developers to help this project come to fruition.

When contributing to this repository, please first discuss the change you wish to make via issue, email, or any other 
method with the owners of this repository before making a change.

Please note we have a code of conduct, please follow it in all your interactions with the project.

## Python version support

Backwards compatibility is a must.

Currently the tool supports Python versions 2.7, 3.5, 3.6, 3.7, 3.8 and 3.9.

Even though Python 2.7 has reached the end of its life at the beginning of 2020, a lot of people still rely on it. 
Therefore we should continue to support it as long as the underlying tools do not completely drop support for it.

## MySQL version support

This tool supports and should continue to support MySQL versions 5.5, 5.6, 5.7 and 8.0. This includes any includes major
forks of MySQL, e.g. MariaDB.

## Testing

Since this project/tool deals with transferring data from one database type to another it is crucial that it is
thoroughly tested. Please write tests for any new code you create. All tests must be written using [pytest](https://docs.pytest.org/en/latest/).

### Running the test suite

In order to run the test suite run these commands using a Docker MySQL image.

**Requires a running Docker instance!**

- using Python 2.7
```bash
git clone https://github.com/techouse/sqlite3-to-mysql
cd sqlite3-to-mysql
virtualenv -p $(which python2) env
source env/bin/activate
pip install -e .
pip install -r requirements_dev.txt
tox
```

- using Python 3.5+
```bash
git clone https://github.com/techouse/sqlite3-to-mysql
cd sqlite3-to-mysql                   
python3 -m venv env
source env/bin/activate
pip install -e .
pip install -r requirements_dev.txt
tox
```

## Submitting changes

Send a new [pull request](https://github.com/techouse/sqlite3-to-mysql/pull/new/master) with a clear list of what
you've done (read more about [pull requests](http://help.github.com/pull-requests/)). When you send a pull request, 
we will love you forever if you include [pytest]((https://docs.pytest.org/en/latest/)) tests. We can always use more 
test coverage. Please follow our coding conventions (below) and make sure all of your commits are atomic (one feature 
per commit).

Always write a clear log message for your commits. One-line messages are fine for small changes, but bigger changes 
should look like this:

```bash
git commit -m "A brief summary of the commit
> 
> A paragraph describing what changed and its impact."
```
    
## Coding standards

Your code should be readable and concise. Always use [Black](https://github.com/psf/black) to format your code.
Additionally, once you feel you're done, run

```bash
tox -e flake8,linters
```

in order to run all various linters and checkers against it.

Thanks,

Klemen Tusar0707010000000B000081A4000003E8000000640000000160872D000000042D000000000000000000000000000000000000001F00000000sqlite3-to-mysql-1.4.1/LICENSEMIT License

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
0707010000000C000081A4000003E8000000640000000160872D00000000A6000000000000000000000000000000000000002300000000sqlite3-to-mysql-1.4.1/MANIFEST.ininclude README.md CODE-OF-CONDUCT.md LICENSE pytest.ini requirements_dev.txt
recursive-include tests *.py
recursive-exclude * __pycache__
recursive-exclude * *.py[co]0707010000000D000081A4000003E8000000640000000160872D00000010A4000000000000000000000000000000000000002100000000sqlite3-to-mysql-1.4.1/README.md[![PyPI](https://img.shields.io/pypi/v/sqlite3-to-mysql)](https://pypi.org/project/sqlite3-to-mysql/)
[![Downloads](https://pepy.tech/badge/sqlite3-to-mysql)](https://pepy.tech/project/sqlite3-to-mysql)
[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/sqlite3-to-mysql)](https://pypi.org/project/sqlite3-to-mysql/)
[![MySQL Support](https://img.shields.io/static/v1?label=MySQL&message=5.5+|+5.6+|+5.7+|+8.0&color=2b5d80)](https://img.shields.io/static/v1?label=MySQL&message=5.6+|+5.7+|+8.0&color=2b5d80)
[![MariaDB Support](https://img.shields.io/static/v1?label=MariaDB&message=5.5+|+10.0+|+10.1+|+10.2+|+10.3+|+10.4+|+10.5&color=C0765A)](https://img.shields.io/static/v1?label=MariaDB&message=10.0+|+10.1+|+10.2+|+10.3+|+10.4+|+10.5&color=C0765A)
[![GitHub license](https://img.shields.io/github/license/techouse/sqlite3-to-mysql)](https://github.com/techouse/sqlite3-to-mysql/blob/master/LICENSE)
[![Contributor Covenant](https://img.shields.io/badge/Contributor%20Covenant-2.0-4baaaa.svg)](CODE-OF-CONDUCT.md)
[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/ambv/black)
[![Codacy Badge](https://api.codacy.com/project/badge/Grade/d33b59d35b924711aae9418741a923ae)](https://www.codacy.com/manual/techouse/sqlite3-to-mysql?utm_source=github.com&amp;utm_medium=referral&amp;utm_content=techouse/sqlite3-to-mysql&amp;utm_campaign=Badge_Grade)
[![Build Status](https://github.com/techouse/sqlite3-to-mysql/workflows/Test/badge.svg)](https://github.com/techouse/sqlite3-to-mysql/actions?query=workflow%3ATest)
[![codecov](https://codecov.io/gh/techouse/sqlite3-to-mysql/branch/master/graph/badge.svg)](https://codecov.io/gh/techouse/sqlite3-to-mysql)
[![GitHub stars](https://img.shields.io/github/stars/techouse/sqlite3-to-mysql.svg?style=social&label=Star&maxAge=2592000)](https://github.com/techouse/sqlite3-to-mysql/stargazers)

# SQLite3 to MySQL

#### A simple Python tool to transfer data from SQLite 3 to MySQL.

I originally wrote this simple program as a standalone script and published it
as a [gist](https://gist.github.com/techouse/4deb94eee58a02d104c6) as an answer
to this [Stack Overflow question](https://stackoverflow.com/questions/18671/quick-easy-way-to-migrate-sqlite3-to-mysql/32243979#32243979).
Since then quite some people have taken interest in it since it's so simple and
effective. Therefore I finally moved my lazy bones and made a GitHub repository :octopus:.

### How to run

```bash
pip install sqlite3-to-mysql
sqlite3mysql --help
```

### Usage
```
Usage: sqlite3mysql [OPTIONS]

Transfer SQLite to MySQL using the provided CLI options.

Options:
  -f, --sqlite-file PATH       SQLite3 database file  [required]
  -t, --sqlite-tables TEXT     Transfer only these specific tables (space
                               separated table names). Implies --without-
                               foreign-keys which inhibits the transfer of
                               foreign keys.

-X, --without-foreign-keys   Do not transfer foreign keys.
  -d, --mysql-database TEXT    MySQL database name  [required]
  -u, --mysql-user TEXT        MySQL user  [required]
  -p, --prompt-mysql-password  Prompt for MySQL password
  --mysql-password TEXT        MySQL password
  -h, --mysql-host TEXT        MySQL host. Defaults to localhost.
  -P, --mysql-port INTEGER     MySQL port. Defaults to 3306.
  -S, --skip-ssl               Disable MySQL connection encryption.
  --mysql-integer-type TEXT    MySQL default integer field type. Defaults to
                               INT(11).

--mysql-string-type TEXT     MySQL default string field type. Defaults to
                               VARCHAR(255).

-T, --use-fulltext           Use FULLTEXT indexes on TEXT columns. Will
                               throw an error if your MySQL version does not
                               support InnoDB FULLTEXT indexes!

--with-rowid                 Transfer rowid columns.
  -c, --chunk INTEGER          Chunk reading/writing SQL records
  -l, --log-file PATH          Log file
  -q, --quiet                  Quiet. Display only errors.
  --version                    Show the version and exit.
  --help                       Show this message and exit.
```
0707010000000E000041ED000003E8000000640000000160872D0000000000000000000000000000000000000000000000001A00000000sqlite3-to-mysql-1.4.1/ci0707010000000F000081A4000003E8000000640000000160872D000000008C000000000000000000000000000000000000002E00000000sqlite3-to-mysql-1.4.1/ci/db_credentials.json{
  "mysql_user": "tester",
  "mysql_password": "testpass",
  "mysql_database": "test_db",
  "mysql_host": "0.0.0.0",
  "mysql_port": 3306
}07070100000010000081A4000003E8000000640000000160872D0000000120000000000000000000000000000000000000002200000000sqlite3-to-mysql-1.4.1/pytest.ini[pytest]
testpaths = tests
norecursedirs = .* venv env *.egg dist build
minversion = 4.6.5
addopts = -rsxX -l --tb=short --strict
timeout = 300
markers =
    init: Run the initialisation test functions
    transfer: Run the main transfer test functions
    cli: Run the cli test functions07070100000011000081A4000003E8000000640000000160872D0000000209000000000000000000000000000000000000002C00000000sqlite3-to-mysql-1.4.1/requirements_dev.txtClick>=7.0
docker>=4.0.2
factory-boy
Faker>=4.1.0 ; python_version>="3.0"
mysql-connector-python>=8.0.18,<8.0.24 ; python_version<"3.6"
mysql-connector-python>=8.0.18 ; python_version>="3.6"
PyMySQL>=0.9.3
PyMySQL[rsa]
pytest>=4.6.5
pytest-cov
pytest-faker ; python_version<"3.0"
pytest-mock
pytest-timeout
pytimeparse>=1.1.8
simplejson>=3.16.0
six>=1.12.0
sqlalchemy>=1.3.7,<1.4.0
sqlalchemy-utils==0.36.6 ; python_version<"3.0"
sqlalchemy-utils>=0.36.6 ; python_version>="3.0"
tox
tqdm>=4.35.0
packaging>=20.3
tabulate
07070100000012000081A4000003E8000000640000000160872D0000000097000000000000000000000000000000000000002100000000sqlite3-to-mysql-1.4.1/setup.cfg[flake8]
ignore = D203,D401,W503,E203,F401,F403
exclude = tests
max-line-length = 88

[metadata]
license_file = LICENSE

[bdist_wheel]
universal = true07070100000013000081A4000003E8000000640000000160872D000000089E000000000000000000000000000000000000002000000000sqlite3-to-mysql-1.4.1/setup.pyfrom codecs import open
from os.path import abspath, dirname, join

from setuptools import setup

here = abspath(dirname(__file__))

packages = ["sqlite3_to_mysql"]

requires = [
    "Click>=7.0",
    "mysql-connector-python>=8.0.18,<8.0.24 ; python_version<'3.6'",
    "mysql-connector-python>=8.0.18 ; python_version>='3.6'",
    "pytimeparse>=1.1.8",
    "six>=1.12.0",
    "simplejson>=3.16.0",
    "tqdm>=4.35.0",
    "packaging>=20.3",
    "tabulate",
]

about = {}
with open(join(here, "sqlite3_to_mysql", "__version__.py"), "r", "utf-8") as fh:
    exec(fh.read(), about)

with open(join(here, "README.md"), "r", "utf-8") as fh:
    readme = fh.read()

setup(
    name=about["__title__"],
    version=about["__version__"],
    description=about["__description__"],
    long_description=readme,
    long_description_content_type="text/markdown",
    author=about["__author__"],
    author_email=about["__author_email__"],
    url=about["__url__"],
    packages=packages,
    include_package_data=True,
    python_requires=">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*",
    install_requires=requires,
    license=about["__license__"],
    zip_safe=False,
    classifiers=[
        "Development Status :: 5 - Production/Stable",
        "Environment :: Console",
        "Intended Audience :: End Users/Desktop",
        "Intended Audience :: Developers",
        "Intended Audience :: System Administrators",
        "License :: OSI Approved :: MIT License",
        "Operating System :: OS Independent",
        "Programming Language :: Python",
        "Programming Language :: Python :: 2",
        "Programming Language :: Python :: 2.7",
        "Programming Language :: Python :: 3",
        "Programming Language :: Python :: 3.5",
        "Programming Language :: Python :: 3.6",
        "Programming Language :: Python :: 3.7",
        "Programming Language :: Python :: 3.8",
        "Programming Language :: Python :: 3.9",
        "Programming Language :: Python :: Implementation :: CPython",
        "Topic :: Database",
    ],
    project_urls={"Source": about["__url__"]},
    entry_points="""
        [console_scripts]
        sqlite3mysql=sqlite3_to_mysql.cli:cli
    """,
)
07070100000014000041ED000003E8000000640000000160872D0000000000000000000000000000000000000000000000002800000000sqlite3-to-mysql-1.4.1/sqlite3_to_mysql07070100000015000081A4000003E8000000640000000160872D0000000060000000000000000000000000000000000000003400000000sqlite3-to-mysql-1.4.1/sqlite3_to_mysql/__init__.py"""Utility to transfer data from SQLite 3 to MySQL."""

from .transporter import SQLite3toMySQL
07070100000016000081A4000003E8000000640000000160872D000000016B000000000000000000000000000000000000003700000000sqlite3-to-mysql-1.4.1/sqlite3_to_mysql/__version__.py"""Module version and author info."""
__title__ = "sqlite3-to-mysql"
__description__ = "A simple Python tool to transfer data from SQLite 3 to MySQL"
__url__ = "https://github.com/techouse/sqlite3-to-mysql"
__version__ = "1.4.1"
__author__ = "Klemen Tusar"
__author_email__ = "techouse@gmail.com"
__license__ = "MIT"
__copyright__ = "Copyright 2021 Klemen Tusar"
07070100000017000081A4000003E8000000640000000160872D0000000EBE000000000000000000000000000000000000002F00000000sqlite3-to-mysql-1.4.1/sqlite3_to_mysql/cli.py"""The command line interface of SQLite3toMySQL."""

import sys

import click
from tabulate import tabulate

from . import SQLite3toMySQL
from .click_utils import OptionEatAll, prompt_password
from .debug_info import info

@click.command()
@click.option(
    "-f",
    "--sqlite-file",
    type=click.Path(exists=True),
    default=None,
    help="SQLite3 database file",
    required=True,
)
@click.option(
    "-t",
    "--sqlite-tables",
    cls=OptionEatAll,
    help="Transfer only these specific tables (space separated table names). "
    "Implies --without-foreign-keys which inhibits the transfer of foreign keys.",
)
@click.option(
    "-X", "--without-foreign-keys", is_flag=True, help="Do not transfer foreign keys."
)
@click.option(
    "-d", "--mysql-database", default=None, help="MySQL database name", required=True
)
@click.option("-u", "--mysql-user", default=None, help="MySQL user", required=True)
@click.option(
    "-p",
    "--prompt-mysql-password",
    is_flag=True,
    default=False,
    callback=prompt_password,
    help="Prompt for MySQL password",
)
@click.option("--mysql-password", default=None, help="MySQL password")
@click.option(
    "-h", "--mysql-host", default="localhost", help="MySQL host. Defaults to localhost."
)
@click.option(
    "-P", "--mysql-port", type=int, default=3306, help="MySQL port. Defaults to 3306."
)
@click.option(
    "-S", "--skip-ssl", is_flag=True, help="Disable MySQL connection encryption."
)
@click.option(
    "--mysql-integer-type",
    default="INT(11)",
    help="MySQL default integer field type. Defaults to INT(11).",
)
@click.option(
    "--mysql-string-type",
    default="VARCHAR(255)",
    help="MySQL default string field type. Defaults to VARCHAR(255).",
)
@click.option(
    "-T",
    "--use-fulltext",
    is_flag=True,
    help="Use FULLTEXT indexes on TEXT columns. "
    "Will throw an error if your MySQL version does not support InnoDB FULLTEXT indexes!",
)
@click.option("--with-rowid", is_flag=True, help="Transfer rowid columns.")
@click.option(
    "-c", "--chunk", type=int, default=None, help="Chunk reading/writing SQL records"
)
@click.option("-l", "--log-file", type=click.Path(), help="Log file")
@click.option("-q", "--quiet", is_flag=True, help="Quiet. Display only errors.")
@click.version_option(
    message=tabulate(info(), headers=["software", "version"], tablefmt="github")
)
def cli(
    sqlite_file,
    sqlite_tables,
    without_foreign_keys,
    mysql_user,
    prompt_mysql_password,
    mysql_password,
    mysql_database,
    mysql_host,
    mysql_port,
    skip_ssl,
    mysql_integer_type,
    mysql_string_type,
    use_fulltext,
    with_rowid,
    chunk,
    log_file,
    quiet,
):
    """Transfer SQLite to MySQL using the provided CLI options."""
    try:
        converter = SQLite3toMySQL(
            sqlite_file=sqlite_file,
            sqlite_tables=sqlite_tables,
            without_foreign_keys=without_foreign_keys
            or (sqlite_tables is not None and len(sqlite_tables) > 0),
            mysql_user=mysql_user,
            mysql_password=mysql_password or prompt_mysql_password,
            mysql_database=mysql_database,
            mysql_host=mysql_host,
            mysql_port=mysql_port,
            mysql_ssl_disabled=skip_ssl,
            mysql_integer_type=mysql_integer_type,
            mysql_string_type=mysql_string_type,
            use_fulltext=use_fulltext,
            with_rowid=with_rowid,
            chunk=chunk,
            log_file=log_file,
            quiet=quiet,
        )
        converter.transfer()
    except KeyboardInterrupt:
        click.echo("\nProcess interrupted. Exiting...")
        sys.exit(1)
    except Exception as err:  # pylint: disable=W0703
        click.echo(err)
        sys.exit(1)
07070100000018000081A4000003E8000000640000000160872D0000000941000000000000000000000000000000000000003700000000sqlite3-to-mysql-1.4.1/sqlite3_to_mysql/click_utils.py"""Click utilities."""

import click

class OptionEatAll(click.Option):
    """Taken from https://stackoverflow.com/questions/48391777/nargs-equivalent-for-options-in-click#answer-48394004."""  # noqa: ignore=E501 pylint: disable=C0301

def __init__(self, *args, **kwargs):
        """Override."""
        self.save_other_options = kwargs.pop("save_other_options", True)
        nargs = kwargs.pop("nargs", -1)
        if nargs != -1:
            raise ValueError("nargs, if set, must be -1 not {}".format(nargs))
        super(OptionEatAll, self).__init__(*args, **kwargs)
        self._previous_parser_process = None
        self._eat_all_parser = None

def add_to_parser(self, parser, ctx):
        """Override."""

def parser_process(value, state):
            # method to hook to the parser.process
            done = False
            value = [value]
            if self.save_other_options:
                # grab everything up to the next option
                while state.rargs and not done:
                    for prefix in self._eat_all_parser.prefixes:
                        if state.rargs[0].startswith(prefix):
                            done = True
                    if not done:
                        value.append(state.rargs.pop(0))
            else:
                # grab everything remaining
                value += state.rargs
                state.rargs[:] = []
            value = tuple(value)

# call the actual process
            self._previous_parser_process(value, state)

retval = super(OptionEatAll, self).add_to_parser(  # pylint: disable=E1111
            parser, ctx
        )
        for name in self.opts:
            # pylint: disable=W0212
            our_parser = parser._long_opt.get(name) or parser._short_opt.get(name)
            if our_parser:
                self._eat_all_parser = our_parser
                self._previous_parser_process = our_parser.process
                our_parser.process = parser_process
                break
        return retval

def prompt_password(ctx, param, use_password):  # pylint: disable=W0613
    """Prompt for password."""
    if use_password:
        mysql_password = ctx.params.get("mysql_password")
        if not mysql_password:
            mysql_password = click.prompt("MySQL password", hide_input=True)

return mysql_password
07070100000019000081A4000003E8000000640000000160872D0000000D3B000000000000000000000000000000000000003600000000sqlite3-to-mysql-1.4.1/sqlite3_to_mysql/debug_info.py"""Module containing bug report helper(s).

Adapted from https://github.com/psf/requests/blob/master/requests/help.py
"""

from __future__ import print_function

import platform
import sqlite3
import sys
from distutils.spawn import find_executable
from subprocess import check_output

import click
import mysql.connector
import pytimeparse
import simplejson
import six
import tabulate
import tqdm

from . import __version__ as package_version

def _implementation():
    """Return a dict with the Python implementation and version.

Provide both the name and the version of the Python implementation
    currently running. For example, on CPython 2.7.5 it will return
    {'name': 'CPython', 'version': '2.7.5'}.

This function works best on CPython and PyPy: in particular, it probably
    doesn't work for Jython or IronPython. Future investigation should be done
    to work out the correct shape of the code for those platforms.
    """
    implementation = platform.python_implementation()

if implementation == "CPython":
        implementation_version = platform.python_version()
    elif implementation == "PyPy":
        implementation_version = "%s.%s.%s" % (
            sys.pypy_version_info.major,  # noqa: ignore=E1101 pylint: disable=E1101
            sys.pypy_version_info.minor,  # noqa: ignore=E1101 pylint: disable=E1101
            sys.pypy_version_info.micro,  # noqa: ignore=E1101 pylint: disable=E1101
        )
        rel = (
            sys.pypy_version_info.releaselevel  # noqa: ignore=E1101 pylint: disable=E1101
        )
        if rel != "final":
            implementation_version = "".join([implementation_version, rel])
    elif implementation == "Jython":
        implementation_version = platform.python_version()  # Complete Guess
    elif implementation == "IronPython":
        implementation_version = platform.python_version()  # Complete Guess
    else:
        implementation_version = "Unknown"

return "{implementation} {implementation_version}".format(
        implementation=implementation, implementation_version=implementation_version
    )

def _mysql_version():
    if find_executable("mysql"):
        try:
            mysql_version = check_output(["mysql", "-V"])
            try:
                return mysql_version.decode().strip()
            except (UnicodeDecodeError, AttributeError):
                return mysql_version
        except Exception:  # nosec pylint: disable=W0703
            pass
    return "MySQL client not found on the system"

def info():
    """Generate information for a bug report."""
    try:
        platform_info = "{system} {release}".format(
            system=platform.system(),
            release=platform.release(),
        )
    except IOError:
        platform_info = "Unknown"

return [
        ["sqlite3-to-mysql", package_version.__version__],
        ["", ""],
        ["Operating System", platform_info],
        ["Python", _implementation()],
        ["MySQL", _mysql_version()],
        ["SQLite", sqlite3.sqlite_version],
        ["", ""],
        ["click", click.__version__],
        ["mysql-connector-python", mysql.connector.__version__],
        ["pytimeparse", pytimeparse.__version__],
        ["simplejson", simplejson.__version__],
        ["six", six.__version__],
        ["tabulate", tabulate.__version__],
        ["tqdm", tqdm.__version__],
    ]
0707010000001A000081A4000003E8000000640000000160872D000000017A000000000000000000000000000000000000003600000000sqlite3-to-mysql-1.4.1/sqlite3_to_mysql/sixeptions.py"""Wrappers for exceptions that exist in Python 3 are missing in Python 2."""

class FileNotFoundError(IOError):
    """Substitute missing exception for Python 2."""

pass

class ConnectionError(IOError):
    """Substitute missing exception for Python 2."""

pass

class ConnectionAbortedError(IOError):
    """Substitute missing exception for Python 2."""

pass
0707010000001B000081A4000003E8000000640000000160872D00000003EA000000000000000000000000000000000000003800000000sqlite3-to-mysql-1.4.1/sqlite3_to_mysql/sqlite_utils.py"""SQLite adapters and converters for unsupported data types."""

from __future__ import division

from datetime import timedelta
from decimal import Decimal

import six
from pytimeparse.timeparse import timeparse

def adapt_decimal(value):
    """Convert decimal.Decimal to string."""
    return str(value)

def convert_decimal(value):
    """Convert string to decimalDecimal."""
    return Decimal(str(value.decode()))

def adapt_timedelta(value):
    """Convert datetime.timedelta to %H:%M:%S string."""
    hours, remainder = divmod(value.total_seconds(), 3600)
    minutes, seconds = divmod(remainder, 60)
    return "{:02}:{:02}:{:02}".format(int(hours), int(minutes), int(seconds))

def convert_timedelta(value):
    """Convert %H:%M:%S string to datetime.timedelta."""
    return timedelta(seconds=timeparse(value.decode()))

def convert_blob(value):
    """In Python 2 MySQL binary protocol can not handle 'buffer' objects so we have to convert them."""
    return six.binary_type(value)
0707010000001C000081A4000003E8000000640000000160872D0000005D53000000000000000000000000000000000000003700000000sqlite3-to-mysql-1.4.1/sqlite3_to_mysql/transporter.py"""Use to transfer an SQLite 3 database to MySQL."""

from __future__ import division

import logging
import re
import sqlite3
from datetime import timedelta
from decimal import Decimal
from math import ceil
from os.path import isfile, realpath
from sys import stdout

import mysql.connector
import six
from mysql.connector import errorcode
from packaging import version
from tqdm import tqdm, trange

from sqlite3_to_mysql.sqlite_utils import (
    adapt_decimal,
    adapt_timedelta,
    convert_blob,
    convert_decimal,
    convert_timedelta,
)

if six.PY2:
    from .sixeptions import *  # pylint: disable=W0622,W0401,W0614

class SQLite3toMySQL:
    """Use this class to transfer an SQLite 3 database to MySQL."""

# shamelessly copied from SQLAlchemy's dialects/mysql/__init__.py
    MYSQL_COLUMN_TYPES = {
        "BIGINT",
        "BINARY",
        "BIT",
        "BLOB",
        "BOOLEAN",
        "CHAR",
        "DATE",
        "DATETIME",
        "DECIMAL",
        "DOUBLE",
        "ENUM",
        "DECIMAL",
        "FLOAT",
        "INTEGER",
        "INTEGER",
        "JSON",
        "LONGBLOB",
        "LONGTEXT",
        "MEDIUMBLOB",
        "MEDIUMINT",
        "MEDIUMTEXT",
        "NCHAR",
        "NVARCHAR",
        "NUMERIC",
        "SET",
        "SMALLINT",
        "REAL",
        "TEXT",
        "TIME",
        "TIMESTAMP",
        "TINYBLOB",
        "TINYINT",
        "TINYTEXT",
        "VARBINARY",
        "VARCHAR",
        "YEAR",
    }

COLUMN_PATTERN = re.compile(r"^[^(]+")
    COLUMN_LENGTH_PATTERN = re.compile(r"$\d+$$")

def __init__(self, **kwargs):
        """Constructor."""
        if not kwargs.get("sqlite_file"):
            raise ValueError("Please provide an SQLite file")

if not isfile(kwargs.get("sqlite_file")):
            raise FileNotFoundError("SQLite file does not exist")

if not kwargs.get("mysql_user"):
            raise ValueError("Please provide a MySQL user")

self._sqlite_file = realpath(kwargs.get("sqlite_file"))

self._sqlite_tables = (
            tuple(kwargs.get("sqlite_tables"))
            if kwargs.get("sqlite_tables") is not None
            else tuple()
        )

self._without_foreign_keys = (
            True
            if len(self._sqlite_tables) > 0
            else (kwargs.get("without_foreign_keys") or False)
        )

self._mysql_user = str(kwargs.get("mysql_user"))

self._mysql_password = (
            str(kwargs.get("mysql_password")) if kwargs.get("mysql_password") else None
        )

self._mysql_host = str(kwargs.get("mysql_host") or "localhost")

self._mysql_port = int(kwargs.get("mysql_port") or 3306)

self._mysql_ssl_disabled = kwargs.get("mysql_ssl_disabled") or False

self._chunk_size = int(kwargs.get("chunk")) if kwargs.get("chunk") else None

self._quiet = kwargs.get("quiet") or False

self._logger = self._setup_logger(
            log_file=kwargs.get("log_file") or None, quiet=self._quiet
        )

self._mysql_database = str(kwargs.get("mysql_database") or "transfer")

self._mysql_integer_type = str(
            kwargs.get("mysql_integer_type") or "INT(11)"
        ).upper()

self._mysql_string_type = str(
            kwargs.get("mysql_string_type") or "VARCHAR(255)"
        ).upper()

self._use_fulltext = kwargs.get("use_fulltext") or False

self._with_rowid = kwargs.get("with_rowid") or False

sqlite3.register_adapter(Decimal, adapt_decimal)
        sqlite3.register_converter("DECIMAL", convert_decimal)
        sqlite3.register_adapter(timedelta, adapt_timedelta)
        sqlite3.register_converter("TIME", convert_timedelta)

if six.PY2:
            sqlite3.register_converter("BLOB", convert_blob)

self._sqlite = sqlite3.connect(
            realpath(self._sqlite_file), detect_types=sqlite3.PARSE_DECLTYPES
        )
        self._sqlite.row_factory = sqlite3.Row

self._sqlite_cur = self._sqlite.cursor()

try:
            self._mysql = mysql.connector.connect(
                user=self._mysql_user,
                password=self._mysql_password,
                host=self._mysql_host,
                port=self._mysql_port,
                ssl_disabled=self._mysql_ssl_disabled,
                use_pure=True,
            )
            if not self._mysql.is_connected():
                raise ConnectionError("Unable to connect to MySQL")

self._mysql_cur = self._mysql.cursor(prepared=True)

try:
                self._mysql.database = self._mysql_database
            except mysql.connector.Error as err:
                if err.errno == errorcode.ER_BAD_DB_ERROR:
                    self._create_database()
                else:
                    self._logger.error(err)
                    raise

self._mysql_version = self._get_mysql_version()
            self._mysql_json_support = self._check_mysql_json_support(
                self._mysql_version
            )
            self._mysql_fulltext_support = self._check_mysql_fulltext_support(
                self._mysql_version
            )

if self._use_fulltext and not self._mysql_fulltext_support:
                raise ValueError(
                    "Your MySQL version does not support InnoDB FULLTEXT indexes!"
                )
        except mysql.connector.Error as err:
            self._logger.error(err)
            raise

@classmethod
    def _setup_logger(cls, log_file=None, quiet=False):
        formatter = logging.Formatter(
            fmt="%(asctime)s %(levelname)-8s %(message)s", datefmt="%Y-%m-%d %H:%M:%S"
        )
        logger = logging.getLogger(cls.__name__)
        logger.setLevel(logging.DEBUG)

if not quiet:
            screen_handler = logging.StreamHandler(stream=stdout)
            screen_handler.setFormatter(formatter)
            logger.addHandler(screen_handler)

if log_file:
            file_handler = logging.FileHandler(realpath(log_file), mode="w")
            file_handler.setFormatter(formatter)
            logger.addHandler(file_handler)

return logger

def _get_mysql_version(self):
        try:
            self._mysql_cur.execute("SHOW VARIABLES LIKE 'version'")
            return self._mysql_cur.fetchone()[1]
        except (IndexError, mysql.connector.Error) as err:
            self._logger.error(
                "MySQL failed checking for InnoDB version: %s",
                err,
            )
            raise

@staticmethod
    def _check_mysql_json_support(version_string):
        mysql_version = version.parse(re.sub("-.*$", "", version_string))

if version_string.lower().endswith("-mariadb"):
            if (
                mysql_version.major >= 10
                and mysql_version.minor >= 2
                and mysql_version.micro >= 7
            ):
                return True
        else:
            if mysql_version.major >= 8:
                return True
            if mysql_version.minor >= 7 and mysql_version.micro >= 8:
                return True
        return False

@staticmethod
    def _check_mysql_fulltext_support(version_string):
        mysql_version = version.parse(re.sub("-.*$", "", version_string))

if version_string.lower().endswith("-mariadb"):
            if (
                mysql_version.major >= 10
                and mysql_version.minor >= 0
                and mysql_version.micro >= 5
            ):
                return True
        else:
            if mysql_version.major >= 8:
                return True
            if mysql_version.minor >= 6:
                return True
        return False

def _sqlite_table_has_rowid(self, table):
        try:
            self._sqlite_cur.execute("""SELECT rowid FROM "{}" LIMIT 1""".format(table))
            self._sqlite_cur.fetchall()
            return True
        except sqlite3.OperationalError:
            return False

def _create_database(self):
        try:
            self._mysql_cur.execute(
                """
                CREATE DATABASE IF NOT EXISTS `{}`
                DEFAULT CHARACTER SET utf8mb4
                DEFAULT COLLATE utf8mb4_general_ci
            """.format(
                    self._mysql_database
                )
            )
            self._mysql_cur.close()
            self._mysql.commit()
            self._mysql.database = self._mysql_database
            self._mysql_cur = self._mysql.cursor(prepared=True)
        except mysql.connector.Error as err:
            self._logger.error(
                "MySQL failed creating databse %s: %s",
                self._mysql_database,
                err,
            )
            raise

@classmethod
    def _valid_column_type(cls, column_type):
        return cls.COLUMN_PATTERN.match(column_type.strip())

def _translate_type_from_sqlite_to_mysql(self, column_type):
        """This could be optimized even further, however is seems adequate."""
        full_column_type = column_type.upper()
        match = self._valid_column_type(column_type)
        if not match:
            raise ValueError("Invalid column_type!")

data_type = match.group(0).upper()
        if data_type in {"TEXT", "CLOB", "STRING"}:
            return "TEXT"
        if data_type in {"CHARACTER", "NCHAR", "NATIVE CHARACTER"}:
            return "CHAR" + self._column_type_length(column_type)
        if data_type in {"VARYING CHARACTER", "NVARCHAR", "VARCHAR"}:
            if self._mysql_string_type == "TEXT":
                return self._mysql_string_type
            length = self._column_type_length(column_type)
            if not length:
                return self._mysql_string_type
            match = self._valid_column_type(self._mysql_string_type)
            return match.group(0).upper() + length
        if data_type == "DOUBLE PRECISION":
            return "DOUBLE"
        if data_type == "UNSIGNED BIG INT":
            return "BIGINT" + self._column_type_length(column_type) + " UNSIGNED"
        if data_type in {"INT1", "INT2"}:
            return self._mysql_integer_type
        if data_type in {"INTEGER", "INT"}:
            length = self._column_type_length(column_type)
            if not length:
                return self._mysql_integer_type
            match = self._valid_column_type(self._mysql_integer_type)
            if self._mysql_integer_type.endswith("UNSIGNED"):
                return match.group(0).upper() + length + " UNSIGNED"
            return match.group(0).upper() + length
        if data_type in {"INT64", "NUMERIC"}:
            return "BIGINT" + self._column_type_length(column_type, 19)
        if data_type not in self.MYSQL_COLUMN_TYPES:
            return self._mysql_string_type
        return full_column_type

@classmethod
    def _column_type_length(cls, column_type, default=None):
        suffix = cls.COLUMN_LENGTH_PATTERN.search(column_type)
        if suffix:
            return suffix.group(0)
        if default:
            return "({})".format(default)
        return ""

def _create_table(self, table_name, transfer_rowid=False):
        primary_keys = []

sql = "CREATE TABLE IF NOT EXISTS `{}` ( ".format(table_name)

if transfer_rowid:
            sql += " `rowid` BIGINT NOT NULL, "

self._sqlite_cur.execute('PRAGMA table_info("{}")'.format(table_name))

for row in self._sqlite_cur.fetchall():
            column = dict(row)
            sql += " `{name}` {type} {notnull} {auto_increment}, ".format(
                name=column["name"],
                type=self._translate_type_from_sqlite_to_mysql(column["type"]),
                notnull="NOT NULL" if column["notnull"] or column["pk"] else "NULL",
                auto_increment="AUTO_INCREMENT"
                if column["pk"]
                and self._translate_type_from_sqlite_to_mysql(column["type"])
                in {"INT", "BIGINT"}
                else "",
            )
            if column["pk"] > 0:
                primary_key = {"column": column["name"], "length": ""}
                # In case we have a non-numeric primary key
                column_type = self._translate_type_from_sqlite_to_mysql(column["type"])
                if column_type in {"TEXT", "BLOB"} or column_type.startswith(
                    ("CHAR", "VARCHAR")
                ):
                    primary_key["length"] = self._column_type_length(column_type, 255)
                primary_keys.append(primary_key)

sql = sql.rstrip(", ")
        if len(primary_keys) > 0:
            sql += ", PRIMARY KEY ({columns})".format(
                columns=", ".join(
                    "`{column}`{length}".format(**primary_key)
                    for primary_key in primary_keys
                )
            )
        if transfer_rowid:
            sql += ", CONSTRAINT `{}_rowid` UNIQUE (`rowid`)".format(table_name)
        sql += " ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci"

try:
            self._mysql_cur.execute(sql)
            self._mysql.commit()
        except mysql.connector.Error as err:
            self._logger.error("MySQL failed creating table %s: %s", table_name, err)
            raise

def _add_indices(self, table_name):
        self._sqlite_cur.execute('PRAGMA table_info("{}")'.format(table_name))
        table_columns = {}
        for row in self._sqlite_cur.fetchall():
            column = dict(row)
            table_columns[column["name"]] = column["type"]

self._sqlite_cur.execute('PRAGMA index_list("{}")'.format(table_name))
        indices = tuple(dict(row) for row in self._sqlite_cur.fetchall())

for index in indices:
            if index["origin"] == "pk":
                continue

self._sqlite_cur.execute('PRAGMA index_info("{}")'.format(index["name"]))
            index_infos = tuple(dict(row) for row in self._sqlite_cur.fetchall())

index_type = "UNIQUE" if int(index["unique"]) == 1 else "INDEX"

if any(
                table_columns[index_info["name"]].upper() == "TEXT"
                for index_info in index_infos
            ):

if self._use_fulltext and self._mysql_fulltext_support:
                    # Use fulltext if requested and available
                    index_type = "FULLTEXT"
                    index_columns = ",".join(
                        "`{}`".format(index_info["name"]) for index_info in index_infos
                    )
                else:
                    # Limit the max TEXT field index length to 255
                    index_columns = ", ".join(
                        "`{column}`{length}".format(
                            column=index_info["name"], length="({})".format(255)
                        )
                        for index_info in index_infos
                    )
            else:
                column_list = []
                for index_info in index_infos:
                    index_length = ""
                    # Limit the max BLOB field index length to 255
                    if table_columns[index_info["name"]].upper() == "BLOB":
                        index_length = "({})".format(255)
                    else:
                        suffix = self.COLUMN_LENGTH_PATTERN.search(
                            table_columns[index_info["name"]]
                        )
                        if suffix:
                            index_length = suffix.group(0)
                    column_list.append(
                        "`{column}`{length}".format(
                            column=index_info["name"], length=index_length
                        )
                    )
                index_columns = ", ".join(column_list)

self._add_index(
                table_name=table_name,
                index_type=index_type,
                index=index,
                index_columns=index_columns,
                index_infos=index_infos,
            )

def _add_index(
        self,
        table_name,
        index_type,
        index,
        index_columns,
        index_infos,
        index_iteration=0,
    ):
        sql = """
            ALTER TABLE `{table}`
            ADD {index_type} `{name}`({columns})
        """.format(
            table=table_name,
            index_type=index_type,
            name=index["name"][:64]
            if index_iteration == 0
            else "{name}_{index_iteration}".format(
                name=index["name"][:60], index_iteration=index_iteration
            ),
            columns=index_columns,
        )

try:
            self._logger.info(
                """Adding %s to column "%s" in table %s""",
                "unique index" if int(index["unique"]) == 1 else "index",
                ", ".join(index_info["name"] for index_info in index_infos),
                table_name,
            )
            self._mysql_cur.execute(sql)
            self._mysql.commit()
        except mysql.connector.Error as err:
            if err.errno == errorcode.ER_DUP_KEYNAME:
                # handle a duplicate key name
                self._add_index(
                    table_name=table_name,
                    index_type=index_type,
                    index=index,
                    index_columns=index_columns,
                    index_infos=index_infos,
                    index_iteration=index_iteration + 1,
                )
            else:
                self._logger.error(
                    "MySQL failed adding indices to table %s: %s",
                    table_name,
                    err,
                )
                raise

def _add_foreign_keys(self, table_name):
        self._sqlite_cur.execute('PRAGMA foreign_key_list("{}")'.format(table_name))

for row in self._sqlite_cur.fetchall():
            foreign_key = dict(row)
            sql = """
                ALTER TABLE `{table}`
                ADD CONSTRAINT `{table}_FK_{id}_{seq}`
                FOREIGN KEY (`{column}`)
                REFERENCES `{ref_table}`(`{ref_column}`)
                ON DELETE {on_delete}
                ON UPDATE {on_update}
            """.format(
                id=foreign_key["id"],
                seq=foreign_key["seq"],
                table=table_name,
                column=foreign_key["from"],
                ref_table=foreign_key["table"],
                ref_column=foreign_key["to"],
                on_delete=foreign_key["on_delete"].upper()
                if foreign_key["on_delete"].upper() != "SET DEFAULT"
                else "NO ACTION",
                on_update=foreign_key["on_update"].upper()
                if foreign_key["on_update"].upper() != "SET DEFAULT"
                else "NO ACTION",
            )

try:
                self._logger.info(
                    "Adding foreign key to %s.%s referencing %s.%s",
                    table_name,
                    foreign_key["from"],
                    foreign_key["table"],
                    foreign_key["to"],
                )
                self._mysql_cur.execute(sql)
                self._mysql.commit()
            except mysql.connector.Error as err:
                self._logger.error(
                    "MySQL failed adding foreign keys to table %s: %s",
                    table_name,
                    err,
                )
                raise

def _transfer_table_data(self, sql, total_records=0):
        if self._chunk_size is not None and self._chunk_size > 0:
            for _ in trange(
                0, int(ceil(total_records / self._chunk_size)), disable=self._quiet
            ):
                self._mysql_cur.executemany(
                    sql,
                    (
                        tuple(row)
                        for row in self._sqlite_cur.fetchmany(self._chunk_size)
                    ),
                )
        else:
            self._mysql_cur.executemany(
                sql,
                (
                    tuple(row)
                    for row in tqdm(
                        self._sqlite_cur.fetchall(),
                        total=total_records,
                        disable=self._quiet,
                    )
                ),
            )
        self._mysql.commit()

def transfer(self):
        """The primary and only method with which we transfer all the data."""
        if len(self._sqlite_tables) > 0:
            # transfer only specific tables
            self._sqlite_cur.execute(
                """
                SELECT name FROM sqlite_master
                WHERE type='table'
                AND name NOT LIKE 'sqlite_%'
                AND name IN({placeholders})
                """.format(
                    placeholders=("?, " * len(self._sqlite_tables)).rstrip(" ,")
                ),
                self._sqlite_tables,
            )
        else:
            # transfer all tables
            self._sqlite_cur.execute(
                """
                SELECT name FROM sqlite_master
                WHERE type='table'
                AND name NOT LIKE 'sqlite_%'
                """
            )
        try:
            self._mysql_cur.execute("SET FOREIGN_KEY_CHECKS=0")

for row in self._sqlite_cur.fetchall():
                table = dict(row)

# check if we're transferring rowid
                transfer_rowid = self._with_rowid and self._sqlite_table_has_rowid(
                    table["name"]
                )

# create the table
                self._create_table(table["name"], transfer_rowid=transfer_rowid)

# get the size of the data
                self._sqlite_cur.execute(
                    'SELECT COUNT(*) AS total_records FROM "{}"'.format(table["name"])
                )
                total_records = int(dict(self._sqlite_cur.fetchone())["total_records"])

# only continue if there is anything to transfer
                if total_records > 0:
                    # populate it
                    self._logger.info("Transferring table %s", table["name"])
                    self._sqlite_cur.execute(
                        """
                        SELECT {rowid} * FROM "{table_name}"
                    """.format(
                            rowid='rowid as "rowid",' if transfer_rowid else "",
                            table_name=table["name"],
                        )
                    )
                    columns = [column[0] for column in self._sqlite_cur.description]
                    sql = """
                        INSERT IGNORE
                        INTO `{table}` ({fields})
                        VALUES ({placeholders})
                    """.format(
                        table=table["name"],
                        fields=("`{}`, " * len(columns)).rstrip(" ,").format(*columns),
                        placeholders=("%s, " * len(columns)).rstrip(" ,"),
                    )
                    try:
                        self._transfer_table_data(sql=sql, total_records=total_records)
                    except mysql.connector.Error as err:
                        self._logger.error(
                            "MySQL transfer failed inserting data into table %s: %s",
                            table["name"],
                            err,
                        )
                        raise

# add indices
                self._add_indices(table["name"])

# add foreign keys
                if not self._without_foreign_keys:
                    self._add_foreign_keys(table["name"])
        except Exception:  # pylint: disable=W0706
            raise
        finally:
            self._mysql_cur.execute("SET FOREIGN_KEY_CHECKS=1")
        self._logger.info("Done!")
0707010000001D000041ED000003E8000000640000000160872D0000000000000000000000000000000000000000000000001D00000000sqlite3-to-mysql-1.4.1/tests0707010000001E000081A4000003E8000000640000000160872D0000000000000000000000000000000000000000000000002900000000sqlite3-to-mysql-1.4.1/tests/__init__.py0707010000001F000081A4000003E8000000640000000160872D000000326A000000000000000000000000000000000000002900000000sqlite3-to-mysql-1.4.1/tests/conftest.pyimport socket
from codecs import open
from collections import namedtuple
from contextlib import contextmanager, closing
from os.path import join, isfile, realpath, dirname, abspath
from time import sleep

import docker
import mysql.connector
import pytest
import six
import json
from click.testing import CliRunner
from docker.errors import NotFound
from mysql.connector import errorcode
from requests import HTTPError
from sqlalchemy import create_engine
from sqlalchemy.exc import IntegrityError
from sqlalchemy_utils import database_exists, drop_database

from .database import Database
from .factories import (
    ArticleFactory,
    AuthorFactory,
    ImageFactory,
    MiscFactory,
    TagFactory,
    MediaFactory,
)

if six.PY2:
    from sixeptions import *

def pytest_addoption(parser):
    parser.addoption(
        "--sqlite-file",
        dest="sqlite_file",
        default=None,
        help="SQLite database file. Defaults to none and generates one internally.",
    )

parser.addoption(
        "--mysql-user",
        dest="mysql_user",
        default="tester",
        help="MySQL user. Defaults to 'tester'.",
    )

parser.addoption(
        "--mysql-password",
        dest="mysql_password",
        default="testpass",
        help="MySQL password. Defaults to 'testpass'.",
    )

parser.addoption(
        "--mysql-database",
        dest="mysql_database",
        default="test_db",
        help="MySQL database name. Defaults to 'test_db'.",
    )

parser.addoption(
        "--mysql-host",
        dest="mysql_host",
        default="0.0.0.0",
        help="Test against a MySQL server running on this host. Defaults to '0.0.0.0'.",
    )

parser.addoption(
        "--mysql-port",
        dest="mysql_port",
        type=int,
        default=None,
        help="The TCP port of the MySQL server.",
    )

parser.addoption(
        "--no-docker",
        dest="use_docker",
        default=True,
        action="store_false",
        help="Do not use a Docker MySQL image to run the tests. "
        "If you decide to use this switch you will have to use a physical MySQL server.",
    )

parser.addoption(
        "--docker-mysql-image",
        dest="docker_mysql_image",
        default="mysql:latest",
        help="Run the tests against a specific MySQL Docker image. Defaults to mysql:latest. "
        "Check all supported versions here https://hub.docker.com/_/mysql",
    )

@pytest.fixture(scope="session", autouse=True)
def cleanup_hanged_docker_containers():
    try:
        client = docker.from_env()
        for container in client.containers.list():
            if container.name == "pytest_sqlite3_to_mysql":
                container.kill()
                break
    except Exception:
        pass

def pytest_keyboard_interrupt():
    try:
        client = docker.from_env()
        for container in client.containers.list():
            if container.name == "pytest_sqlite3_to_mysql":
                container.kill()
                break
    except Exception:
        pass

class Helpers:
    @staticmethod
    @contextmanager
    def not_raises(exception):
        try:
            yield
        except exception:
            raise pytest.fail("DID RAISE {0}".format(exception))

@staticmethod
    @contextmanager
    def session_scope(db):
        """Provide a transactional scope around a series of operations."""
        session = db.Session()
        try:
            yield session
            session.commit()
        except Exception:
            session.rollback()
            raise
        finally:
            session.close()

@pytest.fixture
def helpers():
    return Helpers

if six.PY2:

@pytest.fixture(scope="session")
    def sqlite_database(pytestconfig, faker, tmpdir_factory):
        db_file = pytestconfig.getoption("sqlite_file")
        if db_file:
            if not isfile(realpath(db_file)):
                pytest.fail("{} does not exist".format(db_file))
                raise FileNotFoundError("{} does not exist".format(db_file))
            return realpath(db_file)

temp_data_dir = tmpdir_factory.mktemp("data")
        temp_image_dir = tmpdir_factory.mktemp("images")
        db_file = temp_data_dir.join("db.sqlite3")
        db = Database("sqlite:///{}".format(str(db_file)))

with Helpers.session_scope(db) as session:
            for _ in range(faker.pyint(min_value=12, max_value=24)):
                article = ArticleFactory()
                article.authors.append(AuthorFactory())
                article.tags.append(TagFactory())
                article.misc.append(MiscFactory())
                article.media.append(MediaFactory())
                for _ in range(faker.pyint(min_value=1, max_value=4)):
                    article.images.append(
                        ImageFactory(
                            path=join(
                                str(temp_image_dir),
                                faker.year(),
                                faker.month(),
                                faker.day_of_month(),
                                faker.file_name(extension="jpg"),
                            )
                        )
                    )
                session.add(article)
            try:
                session.commit()
            except IntegrityError:
                session.rollback()

return str(db_file)

else:

@pytest.fixture(scope="session")
    def sqlite_database(pytestconfig, _session_faker, tmpdir_factory):
        db_file = pytestconfig.getoption("sqlite_file")
        if db_file:
            if not isfile(realpath(db_file)):
                pytest.fail("{} does not exist".format(db_file))
                raise FileNotFoundError("{} does not exist".format(db_file))
            return realpath(db_file)

with Helpers.session_scope(db) as session:
            for _ in range(_session_faker.pyint(min_value=12, max_value=24)):
                article = ArticleFactory()
                article.authors.append(AuthorFactory())
                article.tags.append(TagFactory())
                article.misc.append(MiscFactory())
                article.media.append(MediaFactory())
                for _ in range(_session_faker.pyint(min_value=1, max_value=4)):
                    article.images.append(
                        ImageFactory(
                            path=join(
                                str(temp_image_dir),
                                _session_faker.year(),
                                _session_faker.month(),
                                _session_faker.day_of_month(),
                                _session_faker.file_name(extension="jpg"),
                            )
                        )
                    )
                session.add(article)
            try:
                session.commit()
            except IntegrityError:
                session.rollback()

return str(db_file)

def is_port_in_use(port, host="0.0.0.0"):
    if six.PY2:
        with closing(socket.socket(socket.AF_INET, socket.SOCK_STREAM)) as s:
            return s.connect_ex((host, port)) == 0
    else:
        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
            return s.connect_ex((host, port)) == 0

@pytest.fixture(scope="session")
def mysql_credentials(pytestconfig):
    MySQLCredentials = namedtuple(
        "MySQLCredentials", ["user", "password", "host", "port", "database"]
    )

db_credentials_file = abspath(join(dirname(__file__), "db_credentials.json"))
    if isfile(db_credentials_file):
        with open(db_credentials_file, "r", "utf-8") as fh:
            db_credentials = json.load(fh)
            return MySQLCredentials(
                user=db_credentials["mysql_user"],
                password=db_credentials["mysql_password"],
                database=db_credentials["mysql_database"],
                host=db_credentials["mysql_host"],
                port=db_credentials["mysql_port"],
            )

port = pytestconfig.getoption("mysql_port") or 3306
    if pytestconfig.getoption("use_docker"):
        while is_port_in_use(port, pytestconfig.getoption("mysql_host")):
            if port >= 2 ** 16 - 1:
                pytest.fail(
                    "No ports appear to be available on the host {}".format(
                        pytestconfig.getoption("mysql_host")
                    )
                )
                raise ConnectionError(
                    "No ports appear to be available on the host {}".format(
                        pytestconfig.getoption("mysql_host")
                    )
                )
            port += 1

return MySQLCredentials(
        user=pytestconfig.getoption("mysql_user") or "tester",
        password=pytestconfig.getoption("mysql_password") or "testpass",
        database=pytestconfig.getoption("mysql_database") or "test_db",
        host=pytestconfig.getoption("mysql_host") or "0.0.0.0",
        port=port,
    )

@pytest.fixture(scope="session")
def mysql_instance(mysql_credentials, pytestconfig):
    container = None
    mysql_connection = None
    mysql_available = False
    mysql_connection_retries = 15  # failsafe

db_credentials_file = abspath(join(dirname(__file__), "db_credentials.json"))
    if isfile(db_credentials_file):
        use_docker = False
    else:
        use_docker = pytestconfig.getoption("use_docker")

if use_docker:
        """Connecting to a MySQL server within a Docker container is quite tricky :P
        Read more on the issue here https://hub.docker.com/_/mysql#no-connections-until-mysql-init-completes
        """
        try:
            client = docker.from_env()
        except Exception as err:
            pytest.fail(str(err))
            raise

docker_mysql_image = (
            pytestconfig.getoption("docker_mysql_image") or "mysql:latest"
        )

if not any(docker_mysql_image in image.tags for image in client.images.list()):
            print("Attempting to download Docker image {}'".format(docker_mysql_image))
            try:
                client.images.pull(docker_mysql_image)
            except (HTTPError, NotFound) as err:
                pytest.fail(str(err))
                raise

container = client.containers.run(
            image=docker_mysql_image,
            name="pytest_sqlite3_to_mysql",
            ports={
                "3306/tcp": (
                    mysql_credentials.host,
                    "{}/tcp".format(mysql_credentials.port),
                )
            },
            environment={
                "MYSQL_RANDOM_ROOT_PASSWORD": "yes",
                "MYSQL_USER": mysql_credentials.user,
                "MYSQL_PASSWORD": mysql_credentials.password,
                "MYSQL_DATABASE": mysql_credentials.database,
            },
            command=[
                "--character-set-server=utf8mb4",
                "--collation-server=utf8mb4_unicode_ci",
            ],
            detach=True,
            auto_remove=True,
        )

while not mysql_available and mysql_connection_retries > 0:
        try:
            mysql_connection = mysql.connector.connect(
                user=mysql_credentials.user,
                password=mysql_credentials.password,
                host=mysql_credentials.host,
                port=mysql_credentials.port,
            )
        except mysql.connector.Error as err:
            if err.errno == errorcode.CR_SERVER_LOST:
                # sleep for two seconds and retry the connection
                sleep(2)
            else:
                raise
        finally:
            mysql_connection_retries -= 1
            if mysql_connection and mysql_connection.is_connected():
                mysql_available = True
                mysql_connection.close()
    else:
        if not mysql_available and mysql_connection_retries <= 0:
            raise ConnectionAbortedError(
                "Maximum MySQL connection retries exhausted! Are you sure MySQL is running?"
            )

yield

if use_docker:
        container.kill()

@pytest.fixture()
def mysql_database(mysql_instance, mysql_credentials):
    yield

engine = create_engine(
        "mysql+pymysql://{user}:{password}@{host}:{port}/{database}".format(
            user=mysql_credentials.user,
            password=mysql_credentials.password,
            host=mysql_credentials.host,
            port=mysql_credentials.port,
            database=mysql_credentials.database,
        )
    )

if database_exists(engine.url):
        drop_database(engine.url)

@pytest.fixture()
def cli_runner():
    yield CliRunner()
07070100000020000081A4000003E8000000640000000160872D00000004EC000000000000000000000000000000000000002900000000sqlite3-to-mysql-1.4.1/tests/database.pyfrom datetime import datetime, timedelta
from decimal import Decimal

import simplejson as json
from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker
from sqlalchemy_utils import database_exists

from .models import Base

class Database:
    engine = None
    Session = None

def __init__(self, database_uri):
        self.Session = sessionmaker()
        self.engine = create_engine(
            database_uri, json_serializer=self.dumps, json_deserializer=json.loads
        )
        if not database_exists(database_uri):
            self._create_db_tables()
        self.Session.configure(bind=self.engine)

def _create_db_tables(self):
        Base.metadata.create_all(self.engine)

@classmethod
    def dumps(cls, data):
        return json.dumps(data, default=cls.json_serializer)

@staticmethod
    def json_serializer(data):
        if isinstance(data, datetime):
            return data.isoformat()
        if isinstance(data, Decimal):
            return str(data)
        if isinstance(data, timedelta):
            hours, remainder = divmod(data.total_seconds(), 3600)
            minutes, seconds = divmod(remainder, 60)
            return "{:02}:{:02}:{:02}".format(int(hours), int(minutes), int(seconds))
07070100000021000081A4000003E8000000640000000160872D0000000EFD000000000000000000000000000000000000002A00000000sqlite3-to-mysql-1.4.1/tests/factories.pyfrom os import environ

import factory

from . import models

class AuthorFactory(factory.Factory):
    class Meta:
        model = models.Author

name = factory.Faker("name")

class ImageFactory(factory.Factory):
    class Meta:
        model = models.Image

path = factory.Faker("file_path", depth=3, extension="jpg")
    description = factory.Faker("sentence", nb_words=12, variable_nb_words=True)

class TagFactory(factory.Factory):
    class Meta:
        model = models.Tag

name = factory.Faker("sentence", nb_words=3, variable_nb_words=True)

class MiscFactory(factory.Factory):
    class Meta:
        model = models.Misc

big_integer_field = factory.Faker("pyint", max_value=10 ** 9)
    blob_field = factory.Faker("binary", length=1024 * 10)
    boolean_field = factory.Faker("boolean")
    char_field = factory.Faker("text", max_nb_chars=255)
    date_field = factory.Faker("date_this_decade")
    date_time_field = factory.Faker("date_time_this_century")
    decimal_field = factory.Faker("pydecimal", left_digits=8, right_digits=2)
    float_field = factory.Faker("pyfloat", left_digits=8, right_digits=4)
    integer_field = factory.Faker("pyint", min_value=-(2 ** 31), max_value=2 ** 31 - 1)
    if environ.get("LEGACY_DB", "0") == "0":
        json_field = factory.Faker("pydict")
    numeric_field = factory.Faker("pyfloat", left_digits=8, right_digits=4)
    real_field = factory.Faker("pyfloat", left_digits=8, right_digits=4)
    small_integer_field = factory.Faker(
        "pyint", min_value=-(2 ** 15), max_value=2 ** 15 - 1
    )
    string_field = factory.Faker("text", max_nb_chars=255)
    text_field = factory.Faker("text", max_nb_chars=1024)
    time_field = factory.Faker("time_object")
    varchar_field = factory.Faker("text", max_nb_chars=255)
    timestamp_field = factory.Faker("date_time_this_century")
    my_type_field = factory.Faker("text", max_nb_chars=255)

class ArticleFactory(factory.Factory):
    class Meta:
        model = models.Article

hash = factory.Faker("md5")
    title = factory.Faker("sentence", nb_words=6)
    slug = factory.Faker("slug")
    content = factory.Faker("text", max_nb_chars=1024)
    status = factory.Faker("pystr", max_chars=1)
    published = factory.Faker("date_between", start_date="-1y", end_date="-1d")

@factory.post_generation
    def authors(self, create, extracted, **kwargs):
        if not create:
            # Simple build, do nothing.
            return

if extracted:
            # A list of authors were passed in, use them
            for author in extracted:
                self.authors.add(author)

@factory.post_generation
    def tags(self, create, extracted, **kwargs):
        if not create:
            # Simple build, do nothing.
            return

if extracted:
            # A list of authors were passed in, use them
            for tag in extracted:
                self.tags.add(tag)

@factory.post_generation
    def images(self, create, extracted, **kwargs):
        if not create:
            # Simple build, do nothing.
            return

if extracted:
            # A list of authors were passed in, use them
            for image in extracted:
                self.images.add(image)

@factory.post_generation
    def misc(self, create, extracted, **kwargs):
        if not create:
            # Simple build, do nothing.
            return

if extracted:
            # A list of authors were passed in, use them
            for misc in extracted:
                self.misc.add(misc)

class MediaFactory(factory.Factory):
    class Meta:
        model = models.Media

id = factory.Faker("sha256", raw_output=False)
    title = factory.Faker("sentence", nb_words=6)
    description = factory.Faker("sentence", nb_words=12, variable_nb_words=True)
07070100000022000041ED000003E8000000640000000160872D0000000000000000000000000000000000000000000000002200000000sqlite3-to-mysql-1.4.1/tests/func07070100000023000081A4000003E8000000640000000160872D0000000000000000000000000000000000000000000000002E00000000sqlite3-to-mysql-1.4.1/tests/func/__init__.py07070100000024000081A4000003E8000000640000000160872D0000004D45000000000000000000000000000000000000003B00000000sqlite3-to-mysql-1.4.1/tests/func/sqlite3_to_mysql_test.pyimport logging
import re
from collections import namedtuple
from itertools import chain
from random import choice, sample

import mysql.connector
import pytest
import simplejson as json
import six
from mysql.connector import errorcode, MySQLConnection
from sqlalchemy import create_engine, inspect, MetaData, Table, select, text

from sqlite3_to_mysql import SQLite3toMySQL

if six.PY2:
    from ..sixeptions import *

@pytest.mark.usefixtures("sqlite_database", "mysql_instance")
class TestSQLite3toMySQL:
    @pytest.mark.init
    @pytest.mark.parametrize("quiet", [False, True])
    def test_no_sqlite_file_raises_exception(self, quiet):
        with pytest.raises(ValueError) as excinfo:
            SQLite3toMySQL(quiet=quiet)
        assert "Please provide an SQLite file" in str(excinfo.value)

@pytest.mark.init
    @pytest.mark.parametrize("quiet", [False, True])
    def test_invalid_sqlite_file_raises_exception(self, faker, quiet):
        with pytest.raises((FileNotFoundError, IOError)) as excinfo:
            SQLite3toMySQL(
                sqlite_file=faker.file_path(depth=1, extension=".sqlite3"), quiet=quiet
            )
        assert "SQLite file does not exist" in str(excinfo.value)

@pytest.mark.init
    @pytest.mark.parametrize("quiet", [False, True])
    def test_missing_mysql_user_raises_exception(self, sqlite_database, quiet):
        with pytest.raises(ValueError) as excinfo:
            SQLite3toMySQL(sqlite_file=sqlite_database, quiet=quiet)
        assert "Please provide a MySQL user" in str(excinfo.value)

@pytest.mark.init
    @pytest.mark.parametrize("quiet", [False, True])
    def test_valid_sqlite_file_and_valid_mysql_credentials(
        self, sqlite_database, mysql_database, mysql_credentials, helpers, quiet
    ):
        with helpers.not_raises(FileNotFoundError):
            SQLite3toMySQL(
                sqlite_file=sqlite_database,
                mysql_user=mysql_credentials.user,
                mysql_password=mysql_credentials.password,
                mysql_host=mysql_credentials.host,
                mysql_port=mysql_credentials.port,
                mysql_database=mysql_credentials.database,
                chunk=10,
                quiet=quiet,
            )

@pytest.mark.init
    @pytest.mark.parametrize("quiet", [False, True])
    def test_valid_sqlite_file_and_invalid_mysql_credentials_raises_access_denied_exception(
        self, sqlite_database, mysql_database, mysql_credentials, faker, quiet
    ):
        with pytest.raises(mysql.connector.Error) as excinfo:
            SQLite3toMySQL(
                sqlite_file=sqlite_database,
                mysql_user=faker.first_name().lower(),
                mysql_password=faker.password(length=16),
                mysql_host=mysql_credentials.host,
                mysql_port=mysql_credentials.port,
                mysql_database=mysql_credentials.database,
                quiet=quiet,
            )
        assert "Access denied for user" in str(excinfo.value)

@pytest.mark.init
    @pytest.mark.parametrize("quiet", [False, True])
    def test_unspecified_mysql_error(
        self, sqlite_database, mysql_credentials, mocker, caplog, quiet
    ):
        mocker.patch.object(
            mysql.connector,
            "connect",
            side_effect=mysql.connector.Error(
                msg="Error Code: 2000. Unknown MySQL error",
                errno=errorcode.CR_UNKNOWN_ERROR,
            ),
        )
        caplog.set_level(logging.DEBUG)
        with pytest.raises(mysql.connector.Error) as excinfo:
            SQLite3toMySQL(
                sqlite_file=sqlite_database,
                mysql_user=mysql_credentials.user,
                mysql_password=mysql_credentials.password,
                mysql_host=mysql_credentials.host,
                mysql_port=mysql_credentials.port,
                mysql_database=mysql_credentials.database,
                chunk=10,
                quiet=quiet,
            )
        assert str(errorcode.CR_UNKNOWN_ERROR) in str(excinfo.value)
        assert any(
            str(errorcode.CR_UNKNOWN_ERROR) in message for message in caplog.messages
        )

@pytest.mark.init
    @pytest.mark.parametrize("quiet", [False, True])
    def test_bad_database_error(
        self, sqlite_database, mysql_credentials, mocker, caplog, quiet
    ):
        class FakeMySQLConnection(MySQLConnection):
            @property
            def database(self):
                return self._database

@database.setter
            def database(self, value):
                self._database = value
                # raise a fake exception
                raise mysql.connector.Error(
                    msg="This is a test", errno=errorcode.ER_UNKNOWN_ERROR
                )

def is_connected(self):
                return True

def cursor(
                self,
                buffered=None,
                raw=None,
                prepared=None,
                cursor_class=None,
                dictionary=None,
                named_tuple=None,
            ):
                return True

mocker.patch.object(
            mysql.connector, "connect", return_value=FakeMySQLConnection()
        )
        with pytest.raises(mysql.connector.Error):
            caplog.set_level(logging.DEBUG)
            SQLite3toMySQL(
                sqlite_file=sqlite_database,
                mysql_user=mysql_credentials.user,
                mysql_password=mysql_credentials.password,
                mysql_host=mysql_credentials.host,
                mysql_port=mysql_credentials.port,
                mysql_database=mysql_credentials.database,
                chunk=10,
                quiet=quiet,
            )

@pytest.mark.init
    @pytest.mark.parametrize("quiet", [False, True])
    def test_bad_mysql_connection(
        self, sqlite_database, mysql_credentials, mocker, quiet
    ):
        FakeConnector = namedtuple("FakeConnector", ["is_connected"])
        mocker.patch.object(
            mysql.connector,
            "connect",
            return_value=FakeConnector(is_connected=lambda: False),
        )
        with pytest.raises((ConnectionError, IOError)) as excinfo:
            SQLite3toMySQL(
                sqlite_file=sqlite_database,
                mysql_user=mysql_credentials.user,
                mysql_password=mysql_credentials.password,
                mysql_host=mysql_credentials.host,
                mysql_port=mysql_credentials.port,
                mysql_database=mysql_credentials.database,
                chunk=10,
                quiet=quiet,
            )
        assert "Unable to connect to MySQL" in str(excinfo.value)

@pytest.mark.xfail
    @pytest.mark.init
    @pytest.mark.parametrize("quiet", [False, True])
    def test_log_to_file(
        self,
        sqlite_database,
        mysql_database,
        mysql_credentials,
        faker,
        caplog,
        tmpdir,
        quiet,
    ):
        log_file = tmpdir.join("db.log")
        with pytest.raises(mysql.connector.Error):
            caplog.set_level(logging.DEBUG)
            SQLite3toMySQL(
                sqlite_file=sqlite_database,
                mysql_user=faker.first_name().lower(),
                mysql_password=faker.password(length=16),
                mysql_host=mysql_credentials.host,
                mysql_port=mysql_credentials.port,
                mysql_database=mysql_credentials.database,
                log_file=str(log_file),
                quiet=quiet,
            )
        assert any("Access denied for user" in message for message in caplog.messages)
        with log_file.open("r") as log_fh:
            log = log_fh.read()
            if len(caplog.messages) > 1:
                assert caplog.messages[1] in log
            else:
                assert caplog.messages[0] in log
            assert (
                re.match(r"^\d{4,}-\d{2,}-\d{2,}\s+\d{2,}:\d{2,}:\d{2,}\s+\w+\s+", log)
                is not None
            )

@pytest.mark.transfer
    @pytest.mark.parametrize(
        "chunk, with_rowid", [(None, False), (None, True), (10, False), (10, True)]
    )
    def test_transfer_transfers_all_tables_in_sqlite_file(
        self,
        sqlite_database,
        mysql_database,
        mysql_credentials,
        helpers,
        capsys,
        caplog,
        chunk,
        with_rowid,
    ):
        proc = SQLite3toMySQL(
            sqlite_file=sqlite_database,
            mysql_user=mysql_credentials.user,
            mysql_password=mysql_credentials.password,
            mysql_host=mysql_credentials.host,
            mysql_port=mysql_credentials.port,
            mysql_database=mysql_credentials.database,
            chunk=chunk,
            with_rowid=with_rowid,
        )
        caplog.set_level(logging.DEBUG)
        proc.transfer()
        assert all(record.levelname == "INFO" for record in caplog.records)
        assert not any(record.levelname == "ERROR" for record in caplog.records)
        out, err = capsys.readouterr()

sqlite_engine = create_engine(
            "sqlite:///{database}".format(database=sqlite_database),
            json_serializer=json.dumps,
            json_deserializer=json.loads,
        )
        sqlite_cnx = sqlite_engine.connect()
        sqlite_inspect = inspect(sqlite_engine)
        sqlite_tables = sqlite_inspect.get_table_names()
        mysql_engine = create_engine(
            "mysql+pymysql://{user}:{password}@{host}:{port}/{database}".format(
                user=mysql_credentials.user,
                password=mysql_credentials.password,
                host=mysql_credentials.host,
                port=mysql_credentials.port,
                database=mysql_credentials.database,
            ),
            json_serializer=json.dumps,
            json_deserializer=json.loads,
        )
        mysql_cnx = mysql_engine.connect()
        mysql_inspect = inspect(mysql_engine)
        mysql_tables = mysql_inspect.get_table_names()

mysql_connector_connection = mysql.connector.connect(
            user=mysql_credentials.user,
            password=mysql_credentials.password,
            host=mysql_credentials.host,
            port=mysql_credentials.port,
            database=mysql_credentials.database,
        )
        server_version = mysql_connector_connection.get_server_version()

""" Test if both databases have the same table names """
        assert sqlite_tables == mysql_tables

""" Test if all the tables have the same column names """
        for table_name in sqlite_tables:
            column_names = [
                column["name"] for column in sqlite_inspect.get_columns(table_name)
            ]
            if with_rowid:
                column_names.insert(0, "rowid")
            assert column_names == [
                column["name"] for column in mysql_inspect.get_columns(table_name)
            ]

""" Test if all the tables have the same indices """
        index_keys = ("name", "column_names", "unique")
        mysql_indices = tuple(
            {key: index[key] for key in index_keys}
            for index in (
                chain.from_iterable(
                    mysql_inspect.get_indexes(table_name) for table_name in mysql_tables
                )
            )
        )

for table_name in sqlite_tables:
            sqlite_indices = sqlite_inspect.get_indexes(table_name)
            if with_rowid:
                sqlite_indices.insert(
                    0,
                    {
                        "name": "{}_rowid".format(table_name),
                        "column_names": ["rowid"],
                        "unique": 1,
                    },
                )
            for sqlite_index in sqlite_indices:
                sqlite_index["unique"] = bool(sqlite_index["unique"])
                assert sqlite_index in mysql_indices

""" Test if all the tables have the same foreign keys """
        for table_name in sqlite_tables:
            mysql_fk_stmt = text(
                """
                SELECT k.REFERENCED_TABLE_NAME AS `table`, k.COLUMN_NAME AS `from`, k.REFERENCED_COLUMN_NAME AS `to`
                FROM information_schema.TABLE_CONSTRAINTS AS i
                {JOIN} information_schema.KEY_COLUMN_USAGE AS k ON i.CONSTRAINT_NAME = k.CONSTRAINT_NAME
                WHERE i.TABLE_SCHEMA = :table_schema
                AND i.TABLE_NAME = :table_name
                AND i.CONSTRAINT_TYPE = :constraint_type
            """.format(
                    # MySQL 8.0.19 still works with "LEFT JOIN" everything above requires "JOIN"
                    JOIN="JOIN"
                    if (server_version[0] == 8 and server_version[2] > 19)
                    else "LEFT JOIN"
                )
            ).bindparams(
                table_schema=mysql_credentials.database,
                table_name=table_name,
                constraint_type="FOREIGN KEY",
            )
            mysql_fk_result = mysql_cnx.execute(mysql_fk_stmt)
            mysql_foreign_keys = [dict(row) for row in mysql_fk_result]

sqlite_fk_stmt = 'PRAGMA foreign_key_list("{table}")'.format(
                table=table_name
            )
            sqlite_fk_result = sqlite_cnx.execute(sqlite_fk_stmt)
            if sqlite_fk_result.returns_rows:
                for row in sqlite_fk_result:
                    fk = dict(row)
                    assert {
                        "table": fk["table"],
                        "from": fk["from"],
                        "to": fk["to"],
                    } in mysql_foreign_keys

""" Check if all the data was transferred correctly """
        sqlite_results = []
        mysql_results = []

meta = MetaData(bind=None)
        for table_name in sqlite_tables:
            sqlite_table = Table(
                table_name, meta, autoload=True, autoload_with=sqlite_engine
            )
            sqlite_stmt = select([sqlite_table])
            sqlite_result = sqlite_cnx.execute(sqlite_stmt).fetchall()
            sqlite_result.sort()
            sqlite_result = tuple(tuple(data for data in row) for row in sqlite_result)
            sqlite_results.append(sqlite_result)

for table_name in mysql_tables:
            mysql_table = Table(
                table_name, meta, autoload=True, autoload_with=mysql_engine
            )
            mysql_stmt = select([mysql_table])
            mysql_result = mysql_cnx.execute(mysql_stmt).fetchall()
            mysql_result.sort()
            mysql_result = tuple(tuple(data for data in row) for row in mysql_result)
            mysql_results.append(mysql_result)

assert sqlite_results == mysql_results

@pytest.mark.transfer
    @pytest.mark.parametrize(
        "chunk, with_rowid", [(None, False), (None, True), (10, False), (10, True)]
    )
    def test_transfer_specific_tables_transfers_only_specified_tables_from_sqlite_file(
        self,
        sqlite_database,
        mysql_database,
        mysql_credentials,
        helpers,
        capsys,
        caplog,
        chunk,
        with_rowid,
    ):
        sqlite_engine = create_engine(
            "sqlite:///{database}".format(database=sqlite_database),
            json_serializer=json.dumps,
            json_deserializer=json.loads,
        )
        sqlite_cnx = sqlite_engine.connect()
        sqlite_inspect = inspect(sqlite_engine)
        sqlite_tables = sqlite_inspect.get_table_names()

if six.PY2:
            table_number = choice(xrange(1, len(sqlite_tables)))
        else:
            table_number = choice(range(1, len(sqlite_tables)))

random_sqlite_tables = sample(sqlite_tables, table_number)
        random_sqlite_tables.sort()

proc = SQLite3toMySQL(
            sqlite_file=sqlite_database,
            sqlite_tables=random_sqlite_tables,
            mysql_user=mysql_credentials.user,
            mysql_password=mysql_credentials.password,
            mysql_host=mysql_credentials.host,
            mysql_port=mysql_credentials.port,
            mysql_database=mysql_credentials.database,
            chunk=chunk,
            with_rowid=with_rowid,
        )
        caplog.set_level(logging.DEBUG)
        proc.transfer()
        assert all(record.levelname == "INFO" for record in caplog.records)
        assert not any(record.levelname == "ERROR" for record in caplog.records)
        out, err = capsys.readouterr()

mysql_engine = create_engine(
            "mysql+pymysql://{user}:{password}@{host}:{port}/{database}".format(
                user=mysql_credentials.user,
                password=mysql_credentials.password,
                host=mysql_credentials.host,
                port=mysql_credentials.port,
                database=mysql_credentials.database,
            ),
            json_serializer=json.dumps,
            json_deserializer=json.loads,
        )
        mysql_cnx = mysql_engine.connect()
        mysql_inspect = inspect(mysql_engine)
        mysql_tables = mysql_inspect.get_table_names()

""" Test if both databases have the same table names """
        assert random_sqlite_tables == mysql_tables

""" Test if all the tables have the same column names """
        for table_name in random_sqlite_tables:
            column_names = [
                column["name"] for column in sqlite_inspect.get_columns(table_name)
            ]
            if with_rowid:
                column_names.insert(0, "rowid")
            assert column_names == [
                column["name"] for column in mysql_inspect.get_columns(table_name)
            ]

for table_name in random_sqlite_tables:
            sqlite_indices = sqlite_inspect.get_indexes(table_name)
            if with_rowid:
                sqlite_indices.insert(
                    0,
                    {
                        "name": "{}_rowid".format(table_name),
                        "column_names": ["rowid"],
                        "unique": 1,
                    },
                )
            for sqlite_index in sqlite_indices:
                sqlite_index["unique"] = bool(sqlite_index["unique"])
                assert sqlite_index in mysql_indices

""" Check if all the data was transferred correctly """
        sqlite_results = []
        mysql_results = []

meta = MetaData(bind=None)
        for table_name in random_sqlite_tables:
            sqlite_table = Table(
                table_name, meta, autoload=True, autoload_with=sqlite_engine
            )
            sqlite_stmt = select([sqlite_table])
            sqlite_result = sqlite_cnx.execute(sqlite_stmt).fetchall()
            sqlite_result.sort()
            sqlite_result = tuple(tuple(data for data in row) for row in sqlite_result)
            sqlite_results.append(sqlite_result)

assert sqlite_results == mysql_results
07070100000025000081A4000003E8000000640000000160872D00000031AD000000000000000000000000000000000000002E00000000sqlite3-to-mysql-1.4.1/tests/func/test_cli.pyfrom random import choice, sample

import pytest
import simplejson as json
import six
from sqlalchemy import create_engine, inspect

from sqlite3_to_mysql import SQLite3toMySQL
from sqlite3_to_mysql.cli import cli as sqlite3mysql

@pytest.mark.cli
@pytest.mark.usefixtures("sqlite_database", "mysql_instance")
class TestSQLite3toMySQL:
    def test_no_arguments(self, cli_runner, mysql_database):
        result = cli_runner.invoke(sqlite3mysql)
        assert result.exit_code > 0
        assert any(
            message in result.output
            for message in {
                'Error: Missing option "-f" / "--sqlite-file"',
                "Error: Missing option '-f' / '--sqlite-file'",
            }
        )

def test_non_existing_sqlite_file(self, cli_runner, mysql_database, faker):
        result = cli_runner.invoke(
            sqlite3mysql, ["-f", faker.file_path(depth=1, extension=".sqlite3")]
        )
        assert result.exit_code > 0
        assert "Error: Invalid value" in result.output
        assert "does not exist" in result.output

def test_no_database_name(self, cli_runner, sqlite_database, mysql_database):
        result = cli_runner.invoke(sqlite3mysql, ["-f", sqlite_database])
        assert result.exit_code > 0
        assert any(
            message in result.output
            for message in {
                'Error: Missing option "-d" / "--mysql-database"',
                "Error: Missing option '-d' / '--mysql-database'",
            }
        )

def test_no_database_user(
        self, cli_runner, sqlite_database, mysql_credentials, mysql_database
    ):
        result = cli_runner.invoke(
            sqlite3mysql, ["-f", sqlite_database, "-d", mysql_credentials.database]
        )
        assert result.exit_code > 0
        assert any(
            message in result.output
            for message in {
                'Error: Missing option "-u" / "--mysql-user"',
                "Error: Missing option '-u' / '--mysql-user'",
            }
        )

def test_invalid_database_name(
        self, cli_runner, sqlite_database, mysql_credentials, mysql_database, faker
    ):
        result = cli_runner.invoke(
            sqlite3mysql,
            [
                "-f",
                sqlite_database,
                "-d",
                "_".join(faker.words(nb=3)),
                "-u",
                faker.first_name().lower(),
            ],
        )
        assert result.exit_code > 0
        assert "1045 (28000): Access denied" in result.output

def test_invalid_database_user(
        self, cli_runner, sqlite_database, mysql_credentials, mysql_database, faker
    ):
        result = cli_runner.invoke(
            sqlite3mysql,
            [
                "-f",
                sqlite_database,
                "-d",
                mysql_credentials.database,
                "-u",
                faker.first_name().lower(),
            ],
        )
        assert result.exit_code > 0
        assert "1045 (28000): Access denied" in result.output

def test_invalid_database_password(
        self, cli_runner, sqlite_database, mysql_credentials, mysql_database, faker
    ):
        result = cli_runner.invoke(
            sqlite3mysql,
            [
                "-f",
                sqlite_database,
                "-d",
                mysql_credentials.database,
                "-u",
                mysql_credentials.user,
                "--mysql-password",
                faker.password(length=16),
            ],
        )
        assert result.exit_code > 0
        assert "1045 (28000): Access denied" in result.output

def test_database_password_prompt(
        self,
        cli_runner,
        sqlite_database,
        mysql_credentials,
        mysql_database,
    ):
        result = cli_runner.invoke(
            sqlite3mysql,
            args=[
                "-f",
                sqlite_database,
                "-d",
                mysql_credentials.database,
                "-u",
                mysql_credentials.user,
                "-p",
            ],
            input=mysql_credentials.password,
        )
        assert result.exit_code == 0

def test_invalid_database_password_prompt(
        self,
        cli_runner,
        sqlite_database,
        mysql_credentials,
        mysql_database,
        faker,
    ):
        result = cli_runner.invoke(
            sqlite3mysql,
            args=[
                "-f",
                sqlite_database,
                "-d",
                mysql_credentials.database,
                "-u",
                mysql_credentials.user,
                "-p",
            ],
            input=faker.password(length=16),
        )
        assert result.exit_code > 0
        assert "1045 (28000): Access denied" in result.output

def test_invalid_database_port(
        self, cli_runner, sqlite_database, mysql_credentials, mysql_database, faker
    ):
        if six.PY2:
            port = choice(xrange(2, 2 ** 16 - 1))
        else:
            port = choice(range(2, 2 ** 16 - 1))
        if port == mysql_credentials.port:
            port -= 1
        result = cli_runner.invoke(
            sqlite3mysql,
            [
                "-f",
                sqlite_database,
                "-d",
                mysql_credentials.database,
                "-u",
                mysql_credentials.user,
                "--mysql-password",
                mysql_credentials.password,
                "-h",
                mysql_credentials.host,
                "-P",
                port,
            ],
        )
        assert result.exit_code > 0
        assert any(
            message in result.output
            for message in {
                "2003 (HY000): Can't connect to MySQL server on",
                "2003: Can't connect to MySQL server",
            }
        )

@pytest.mark.parametrize(
        "mysql_integer_type, mysql_string_type, chunk, with_rowid",
        [
            # 0000
            (None, None, None, False),
            # 0001
            (None, None, None, True),
            # 1110
            ("BIGINT(19)", "TEXT", 10, False),
            # 1111
            ("BIGINT(19)", "TEXT", 10, True),
            # 1100
            ("BIGINT(19)", "TEXT", None, False),
            # 1101
            ("BIGINT(19)", "TEXT", None, True),
            # 0110
            (None, "TEXT", 10, False),
            # 0111
            (None, "TEXT", 10, True),
            # 0100
            (None, "TEXT", None, False),
            # 0101
            (None, "TEXT", None, True),
            # 1000
            ("BIGINT(19)", None, None, False),
            # 1001
            ("BIGINT(19)", None, None, True),
            # 0010
            (None, None, 10, False),
            # 0011
            (None, None, 10, True),
            # 1010
            ("BIGINT(19)", None, 10, False),
            # 1011
            ("BIGINT(19)", None, 10, True),
        ],
    )
    def test_minimum_valid_parameters(
        self,
        cli_runner,
        sqlite_database,
        mysql_credentials,
        mysql_integer_type,
        mysql_string_type,
        mysql_database,
        chunk,
        with_rowid,
    ):
        arguments = [
            "-f",
            sqlite_database,
            "-d",
            mysql_credentials.database,
            "-u",
            mysql_credentials.user,
            "--mysql-password",
            mysql_credentials.password,
            "-h",
            mysql_credentials.host,
            "-P",
            mysql_credentials.port,
            "--mysql-integer-type",
            mysql_integer_type,
            "--mysql-string-type",
            mysql_string_type,
            "-c",
            chunk,
        ]
        if with_rowid:
            arguments.append("--with-rowid")
        result = cli_runner.invoke(
            sqlite3mysql,
            arguments,
        )
        assert result.exit_code == 0

def test_keyboard_interrupt(
        self, cli_runner, sqlite_database, mysql_credentials, mocker
    ):
        mocker.patch.object(SQLite3toMySQL, "transfer", side_effect=KeyboardInterrupt())
        result = cli_runner.invoke(
            sqlite3mysql,
            [
                "-f",
                sqlite_database,
                "-d",
                mysql_credentials.database,
                "-u",
                mysql_credentials.user,
                "--mysql-password",
                mysql_credentials.password,
                "-h",
                mysql_credentials.host,
                "-P",
                mysql_credentials.port,
            ],
        )
        assert result.exit_code > 0
        assert "Process interrupted" in result.output

def test_transfer_specific_tables_only(
        self, cli_runner, sqlite_database, mysql_credentials
    ):
        sqlite_engine = create_engine(
            "sqlite:///{database}".format(database=sqlite_database),
            json_serializer=json.dumps,
            json_deserializer=json.loads,
        )
        sqlite_inspect = inspect(sqlite_engine)
        sqlite_tables = sqlite_inspect.get_table_names()

if six.PY2:
            table_number = choice(xrange(1, len(sqlite_tables)))
        else:
            table_number = choice(range(1, len(sqlite_tables)))

result = cli_runner.invoke(
            sqlite3mysql,
            [
                "-f",
                sqlite_database,
                "-t",
                " ".join(sample(sqlite_tables, table_number)),
                "-d",
                mysql_credentials.database,
                "-u",
                mysql_credentials.user,
                "--mysql-password",
                mysql_credentials.password,
                "-h",
                mysql_credentials.host,
                "-P",
                mysql_credentials.port,
            ],
        )
        assert result.exit_code == 0

def test_version(self, cli_runner):
        result = cli_runner.invoke(sqlite3mysql, ["--version"])
        assert result.exit_code == 0
        assert all(
            message in result.output
            for message in {
                "sqlite3-to-mysql",
                "Operating",
                "System",
                "Python",
                "MySQL",
                "SQLite",
                "click",
                "mysql-connector-python",
                "pytimeparse",
                "simplejson",
                "six",
                "tabulate",
                "tqdm",
            }
        )

@pytest.mark.parametrize(
        "mysql_integer_type, mysql_string_type, chunk, with_rowid",
        [
            # 0000
            (None, None, None, False),
            # 0001
            (None, None, None, True),
            # 1110
            ("BIGINT(19)", "TEXT", 10, False),
            # 1111
            ("BIGINT(19)", "TEXT", 10, True),
            # 1100
            ("BIGINT(19)", "TEXT", None, False),
            # 1101
            ("BIGINT(19)", "TEXT", None, True),
            # 0110
            (None, "TEXT", 10, False),
            # 0111
            (None, "TEXT", 10, True),
            # 0100
            (None, "TEXT", None, False),
            # 0101
            (None, "TEXT", None, True),
            # 1000
            ("BIGINT(19)", None, None, False),
            # 1001
            ("BIGINT(19)", None, None, True),
            # 0010
            (None, None, 10, False),
            # 0011
            (None, None, 10, True),
            # 1010
            ("BIGINT(19)", None, 10, False),
            # 1011
            ("BIGINT(19)", None, 10, True),
        ],
    )
    def test_quiet(
        self,
        cli_runner,
        sqlite_database,
        mysql_credentials,
        mysql_integer_type,
        mysql_string_type,
        mysql_database,
        chunk,
        with_rowid,
    ):
        arguments = [
            "-f",
            sqlite_database,
            "-d",
            mysql_credentials.database,
            "-u",
            mysql_credentials.user,
            "--mysql-password",
            mysql_credentials.password,
            "-h",
            mysql_credentials.host,
            "-P",
            mysql_credentials.port,
            "--mysql-integer-type",
            mysql_integer_type,
            "--mysql-string-type",
            mysql_string_type,
            "-c",
            chunk,
            "-q",
        ]
        if with_rowid:
            arguments.append("--with-rowid")
        result = cli_runner.invoke(
            sqlite3mysql,
            arguments,
        )
        assert result.exit_code == 0
        assert result.output == ""
07070100000026000081A4000003E8000000640000000160872D0000001756000000000000000000000000000000000000002700000000sqlite3-to-mysql-1.4.1/tests/models.pyfrom decimal import Decimal
from os import environ

import sqlalchemy.types as types
from sqlalchemy import (
    Table,
    Column,
    ForeignKey,
    BigInteger,
    BLOB,
    Boolean,
    CHAR,
    Date,
    DateTime,
    Integer,
    JSON,
    REAL,
    SmallInteger,
    String,
    Text,
    Time,
    TIMESTAMP,
    VARCHAR,
)
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import relationship, backref
from sqlalchemy.sql.functions import current_timestamp

class SQLiteNumeric(types.TypeDecorator):
    impl = types.String

def load_dialect_impl(self, dialect):
        return dialect.type_descriptor(types.VARCHAR(100))

def process_bind_param(self, value, dialect):
        return str(value)

def process_result_value(self, value, dialect):
        return Decimal(value)

class MyCustomType(types.TypeDecorator):
    impl = types.String

def load_dialect_impl(self, dialect):
        return dialect.type_descriptor(types.VARCHAR(self.length))

def process_bind_param(self, value, dialect):
        return str(value)

def process_result_value(self, value, dialect):
        return str(value)

Base = declarative_base()

class Author(Base):
    __tablename__ = "authors"
    id = Column(Integer, primary_key=True)
    name = Column(String(128), nullable=False, index=True)

def __repr__(self):
        return "<Author(id='{id}', name='{name}')>".format(id=self.id, name=self.name)

article_authors = Table(
    "article_authors",
    Base.metadata,
    Column("article_id", Integer, ForeignKey("articles.id"), primary_key=True),
    Column("author_id", Integer, ForeignKey("authors.id"), primary_key=True),
)

class Image(Base):
    __tablename__ = "images"
    id = Column(Integer, primary_key=True)
    path = Column(String(255), index=True)
    description = Column(String(255), nullable=True)

def __repr__(self):
        return "<Image(id='{id}', path='{path}')>".format(id=self.id, path=self.path)

article_images = Table(
    "article_images",
    Base.metadata,
    Column("article_id", Integer, ForeignKey("articles.id"), primary_key=True),
    Column("image_id", Integer, ForeignKey("images.id"), primary_key=True),
)

class Tag(Base):
    __tablename__ = "tags"
    id = Column(Integer, primary_key=True)
    name = Column(String(128), nullable=False, index=True)

def __repr__(self):
        return "<Tag(id='{id}', name='{name}')>".format(id=self.id, name=self.name)

article_tags = Table(
    "article_tags",
    Base.metadata,
    Column("article_id", Integer, ForeignKey("articles.id"), primary_key=True),
    Column("tag_id", Integer, ForeignKey("tags.id"), primary_key=True),
)

class Misc(Base):
    """This model contains all possible MySQL types"""

__tablename__ = "misc"
    id = Column(Integer, primary_key=True)
    big_integer_field = Column(BigInteger, default=0)
    blob_field = Column(BLOB, nullable=True, index=True)
    boolean_field = Column(Boolean, default=False)
    char_field = Column(CHAR(255), nullable=True)
    date_field = Column(Date, nullable=True)
    date_time_field = Column(DateTime, nullable=True)
    decimal_field = Column(SQLiteNumeric(10, 2), nullable=True)
    float_field = Column(SQLiteNumeric(12, 4), default=0)
    integer_field = Column(Integer, default=0)
    if environ.get("LEGACY_DB", "0") == "0":
        json_field = Column(JSON, nullable=True)
    numeric_field = Column(SQLiteNumeric(12, 4), default=0)
    real_field = Column(REAL(12, 4), default=0)
    small_integer_field = Column(SmallInteger, default=0)
    string_field = Column(String(255), nullable=True)
    text_field = Column(Text, nullable=True)
    time_field = Column(Time, nullable=True)
    varchar_field = Column(VARCHAR(255), nullable=True)
    timestamp_field = Column(TIMESTAMP, default=current_timestamp())
    my_type_field = Column(MyCustomType(255), nullable=True)

article_misc = Table(
    "article_misc",
    Base.metadata,
    Column("article_id", Integer, ForeignKey("articles.id"), primary_key=True),
    Column("misc_id", Integer, ForeignKey("misc.id"), primary_key=True),
)

class Media(Base):
    __tablename__ = "media"
    id = Column(CHAR(64), primary_key=True)
    title = Column(String(255), index=True)
    description = Column(String(255), nullable=True)

def __repr__(self):
        return "<Media(id='{id}', title='{title}')>".format(
            id=self.id, title=self.title
        )

article_media = Table(
    "article_media",
    Base.metadata,
    Column("article_id", Integer, ForeignKey("articles.id"), primary_key=True),
    Column("media_id", CHAR(64), ForeignKey("media.id"), primary_key=True),
)

class Article(Base):
    __tablename__ = "articles"
    id = Column(Integer, primary_key=True)
    hash = Column(String(32), unique=True)
    slug = Column(String(255), index=True)
    title = Column(String(255), index=True)
    content = Column(Text, nullable=True, index=True)
    status = Column(CHAR(1), index=True)
    published = Column(DateTime, nullable=True)
    # relationships
    authors = relationship(
        "Author",
        secondary=article_authors,
        backref=backref("authors", lazy="dynamic"),
        lazy="dynamic",
    )
    tags = relationship(
        "Tag",
        secondary=article_tags,
        backref=backref("tags", lazy="dynamic"),
        lazy="dynamic",
    )
    images = relationship(
        "Image",
        secondary=article_images,
        backref=backref("images", lazy="dynamic"),
        lazy="dynamic",
    )
    media = relationship(
        "Media",
        secondary=article_media,
        backref=backref("media", lazy="dynamic"),
        lazy="dynamic",
    )
    misc = relationship(
        "Misc",
        secondary=article_misc,
        backref=backref("misc", lazy="dynamic"),
        lazy="dynamic",
    )

def __repr__(self):
        return "<Article(id='{id}', title='{title}')>".format(
            id=self.id, title=self.title
        )
07070100000027000081A4000003E8000000640000000160872D00000000F6000000000000000000000000000000000000002B00000000sqlite3-to-mysql-1.4.1/tests/sixeptions.py""" This module contains wrappers for exceptions that exist in Python 3 but are not present in Python 2
"""

class FileNotFoundError(IOError):
    pass

class ConnectionError(IOError):
    pass

class ConnectionAbortedError(IOError):
    pass
07070100000028000041ED000003E8000000640000000160872D0000000000000000000000000000000000000000000000002200000000sqlite3-to-mysql-1.4.1/tests/unit07070100000029000081A4000003E8000000640000000160872D0000000000000000000000000000000000000000000000002E00000000sqlite3-to-mysql-1.4.1/tests/unit/__init__.py0707010000002A000081A4000003E8000000640000000160872D0000003231000000000000000000000000000000000000003B00000000sqlite3-to-mysql-1.4.1/tests/unit/sqlite3_to_mysql_test.pyimport logging
import re
from random import choice

import mysql.connector
import pytest
from mysql.connector import errorcode
from sqlalchemy import create_engine, inspect
from sqlalchemy.dialects.sqlite import __all__ as sqlite_column_types

from sqlite3_to_mysql import SQLite3toMySQL

@pytest.mark.usefixtures("sqlite_database", "mysql_instance")
class TestSQLite3toMySQL:
    @pytest.mark.parametrize("quiet", [False, True])
    def test_translate_type_from_sqlite_to_mysql_invalid_column_type(
        self, sqlite_database, mysql_database, mysql_credentials, mocker, quiet
    ):
        proc = SQLite3toMySQL(
            sqlite_file=sqlite_database,
            mysql_user=mysql_credentials.user,
            mysql_password=mysql_credentials.password,
            mysql_host=mysql_credentials.host,
            mysql_port=mysql_credentials.port,
            mysql_database=mysql_credentials.database,
            quiet=quiet,
        )
        with pytest.raises(ValueError) as excinfo:
            mocker.patch.object(proc, "_valid_column_type", return_value=False)
            proc._translate_type_from_sqlite_to_mysql("text")
        assert "Invalid column_type!" in str(excinfo.value)

@pytest.mark.parametrize(
        "mysql_integer_type, mysql_string_type",
        [
            ("INT(11)", "VARCHAR(300)"),
            ("BIGINT(19)", "TEXT"),
            ("BIGINT(20) UNSIGNED", "CHAR(100)"),
        ],
    )
    def test_translate_type_from_sqlite_to_mysql_all_valid_columns(
        self,
        sqlite_database,
        mysql_database,
        mysql_credentials,
        faker,
        mysql_integer_type,
        mysql_string_type,
    ):
        proc = SQLite3toMySQL(
            sqlite_file=sqlite_database,
            mysql_user=mysql_credentials.user,
            mysql_password=mysql_credentials.password,
            mysql_host=mysql_credentials.host,
            mysql_port=mysql_credentials.port,
            mysql_database=mysql_credentials.database,
            mysql_integer_type=mysql_integer_type,
            mysql_string_type=mysql_string_type,
        )

for column in sqlite_column_types + ("INT64",):
            if column == "dialect":
                continue
            elif column == "VARCHAR":
                assert (
                    proc._translate_type_from_sqlite_to_mysql(column)
                    == proc._mysql_string_type
                )
            elif column in {"INTEGER", "INT"}:
                assert (
                    proc._translate_type_from_sqlite_to_mysql(column)
                    == proc._mysql_integer_type
                )
            elif column in {"INT64", "NUMERIC"}:
                assert proc._translate_type_from_sqlite_to_mysql(column) == "BIGINT(19)"
            else:
                assert proc._translate_type_from_sqlite_to_mysql(column) == column
        assert proc._translate_type_from_sqlite_to_mysql("TEXT") == "TEXT"
        assert proc._translate_type_from_sqlite_to_mysql("CLOB") == "TEXT"
        assert proc._translate_type_from_sqlite_to_mysql("CHARACTER") == "CHAR"
        length = faker.pyint(min_value=1, max_value=99)
        assert proc._translate_type_from_sqlite_to_mysql(
            "CHARACTER({})".format(length)
        ) == "CHAR({})".format(length)
        assert proc._translate_type_from_sqlite_to_mysql("NCHAR") == "CHAR"
        length = faker.pyint(min_value=1, max_value=99)
        assert proc._translate_type_from_sqlite_to_mysql(
            "NCHAR({})".format(length)
        ) == "CHAR({})".format(length)
        assert proc._translate_type_from_sqlite_to_mysql("NATIVE CHARACTER") == "CHAR"
        length = faker.pyint(min_value=1, max_value=99)
        assert proc._translate_type_from_sqlite_to_mysql(
            "NATIVE CHARACTER({})".format(length)
        ) == "CHAR({})".format(length)
        assert (
            proc._translate_type_from_sqlite_to_mysql("VARCHAR")
            == proc._mysql_string_type
        )
        length = faker.pyint(min_value=1, max_value=255)
        assert proc._translate_type_from_sqlite_to_mysql(
            "VARCHAR({})".format(length)
        ) == re.sub(r"\d+", str(length), proc._mysql_string_type)
        assert proc._translate_type_from_sqlite_to_mysql("DOUBLE PRECISION") == "DOUBLE"
        assert (
            proc._translate_type_from_sqlite_to_mysql("UNSIGNED BIG INT")
            == "BIGINT UNSIGNED"
        )
        length = faker.pyint(min_value=1000000000, max_value=99999999999999999999)
        assert proc._translate_type_from_sqlite_to_mysql(
            "UNSIGNED BIG INT({})".format(length)
        ) == "BIGINT({}) UNSIGNED".format(length)
        assert (
            proc._translate_type_from_sqlite_to_mysql("INT1")
            == proc._mysql_integer_type
        )
        assert (
            proc._translate_type_from_sqlite_to_mysql("INT2")
            == proc._mysql_integer_type
        )
        length = faker.pyint(min_value=1, max_value=11)
        assert proc._translate_type_from_sqlite_to_mysql(
            "INT({})".format(length)
        ) == re.sub(r"\d+", str(length), proc._mysql_integer_type)
        for column in {"META", "FOO", "BAR"}:
            assert (
                proc._translate_type_from_sqlite_to_mysql(column)
                == proc._mysql_string_type
            )

@pytest.mark.parametrize("quiet", [False, True])
    def test_create_database_connection_error(
        self,
        sqlite_database,
        mysql_database,
        mysql_credentials,
        mocker,
        faker,
        caplog,
        quiet,
    ):
        proc = SQLite3toMySQL(
            sqlite_file=sqlite_database,
            mysql_user=mysql_credentials.user,
            mysql_password=mysql_credentials.password,
            mysql_host=mysql_credentials.host,
            mysql_port=mysql_credentials.port,
            mysql_database=mysql_credentials.database,
            quiet=quiet,
        )

class FakeCursor:
            def execute(self, statement):
                raise mysql.connector.Error(
                    msg="Unknown MySQL error", errno=errorcode.CR_UNKNOWN_ERROR
                )

mocker.patch.object(proc, "_mysql_cur", FakeCursor())

with pytest.raises(mysql.connector.Error) as excinfo:
            caplog.set_level(logging.DEBUG)
            proc._create_database()
        assert str(errorcode.CR_UNKNOWN_ERROR) in str(excinfo.value)
        assert any(
            str(errorcode.CR_UNKNOWN_ERROR) in message for message in caplog.messages
        )

@pytest.mark.parametrize("quiet", [False, True])
    def test_create_table_cursor_error(
        self,
        sqlite_database,
        mysql_database,
        mysql_credentials,
        mocker,
        faker,
        caplog,
        quiet,
    ):
        proc = SQLite3toMySQL(
            sqlite_file=sqlite_database,
            mysql_user=mysql_credentials.user,
            mysql_password=mysql_credentials.password,
            mysql_host=mysql_credentials.host,
            mysql_port=mysql_credentials.port,
            mysql_database=mysql_credentials.database,
            quiet=quiet,
        )

mocker.patch.object(proc, "_mysql_cur", FakeCursor())

sqlite_engine = create_engine(
            "sqlite:///{database}".format(database=sqlite_database)
        )
        sqlite_inspect = inspect(sqlite_engine)
        sqlite_tables = sqlite_inspect.get_table_names()

with pytest.raises(mysql.connector.Error) as excinfo:
            caplog.set_level(logging.DEBUG)
            proc._create_table(choice(sqlite_tables))
        assert str(errorcode.CR_UNKNOWN_ERROR) in str(excinfo.value)
        assert any(
            str(errorcode.CR_UNKNOWN_ERROR) in message for message in caplog.messages
        )

@pytest.mark.parametrize("quiet", [False, True])
    def test_process_cursor_error(
        self,
        sqlite_database,
        mysql_database,
        mysql_credentials,
        mocker,
        faker,
        caplog,
        quiet,
    ):
        proc = SQLite3toMySQL(
            sqlite_file=sqlite_database,
            mysql_user=mysql_credentials.user,
            mysql_password=mysql_credentials.password,
            mysql_host=mysql_credentials.host,
            mysql_port=mysql_credentials.port,
            mysql_database=mysql_credentials.database,
            quiet=quiet,
        )

def fake_transfer_table_data(sql, total_records=0):
            raise mysql.connector.Error(
                msg="Unknown MySQL error", errno=errorcode.CR_UNKNOWN_ERROR
            )

mocker.patch.object(proc, "_transfer_table_data", fake_transfer_table_data)

with pytest.raises(mysql.connector.Error) as excinfo:
            caplog.set_level(logging.DEBUG)
            proc.transfer()
        assert str(errorcode.CR_UNKNOWN_ERROR) in str(excinfo.value)
        assert any(
            str(errorcode.CR_UNKNOWN_ERROR) in message for message in caplog.messages
        )

@pytest.mark.parametrize("quiet", [False, True])
    def test_add_indices_error(
        self,
        sqlite_database,
        mysql_database,
        mysql_credentials,
        mocker,
        faker,
        caplog,
        quiet,
    ):
        proc = SQLite3toMySQL(
            sqlite_file=sqlite_database,
            mysql_user=mysql_credentials.user,
            mysql_password=mysql_credentials.password,
            mysql_host=mysql_credentials.host,
            mysql_port=mysql_credentials.port,
            mysql_database=mysql_credentials.database,
            quiet=quiet,
        )

tables_with_indices = []
        for table in sqlite_tables:
            if sqlite_inspect.get_indexes(table):
                tables_with_indices.append(table)

table_name = choice(tables_with_indices)
        proc._create_table(table_name)

mocker.patch.object(proc, "_mysql_cur", FakeCursor())

with pytest.raises(mysql.connector.Error) as excinfo:
            caplog.set_level(logging.DEBUG)
            proc._add_indices(table_name)
        assert str(errorcode.CR_UNKNOWN_ERROR) in str(excinfo.value)
        assert any(
            str(errorcode.CR_UNKNOWN_ERROR) in message for message in caplog.messages
        )

@pytest.mark.parametrize("quiet", [False, True])
    def test_add_foreign_keys_error(
        self,
        sqlite_database,
        mysql_database,
        mysql_credentials,
        mocker,
        faker,
        caplog,
        quiet,
    ):
        proc = SQLite3toMySQL(
            sqlite_file=sqlite_database,
            mysql_user=mysql_credentials.user,
            mysql_password=mysql_credentials.password,
            mysql_host=mysql_credentials.host,
            mysql_port=mysql_credentials.port,
            mysql_database=mysql_credentials.database,
            quiet=quiet,
        )

tables_with_foreign_keys = []

for table in sqlite_tables:
            sqlite_fk_stmt = 'PRAGMA foreign_key_list("{table}")'.format(table=table)
            sqlite_fk_result = sqlite_engine.execute(sqlite_fk_stmt)
            if sqlite_fk_result.returns_rows:
                for _ in sqlite_fk_result:
                    tables_with_foreign_keys.append(table)
                    break

table_name = choice(tables_with_foreign_keys)

proc._create_table(table_name)

mocker.patch.object(proc, "_mysql_cur", FakeCursor())

with pytest.raises(mysql.connector.Error) as excinfo:
            caplog.set_level(logging.DEBUG)
            proc._add_foreign_keys(table_name)
        assert str(errorcode.CR_UNKNOWN_ERROR) in str(excinfo.value)
        assert any(
            str(errorcode.CR_UNKNOWN_ERROR) in message for message in caplog.messages
        )
0707010000002B000081A4000003E8000000640000000160872D00000006E6000000000000000000000000000000000000001F00000000sqlite3-to-mysql-1.4.1/tox.ini[tox]
envlist =
    py27,
    py35,
    py36,
    py37,
    py38,
    py39,
    black,
    flake8,
    linters,
    setuppy
skip_missing_interpreters = true

[gh-actions]
python =
    2.7: py27
    3.5: py35
    3.6: py36
    3.7: py37
    3.8: py38
    3.9: py39

[testenv]
passenv =
    LANG
    LEGACY_DB
deps =
    -rrequirements_dev.txt
commands =
    pytest -v --cov=sqlite3_to_mysql --cov-report=xml

[testenv:black]
basepython = python3
skip_install = true
deps =
    black>=19.3b0
commands =
    black sqlite3_to_mysql tests/

[testenv:flake8]
basepython = python3
skip_install = true
deps =
    flake8
    flake8-colors
    flake8-docstrings>=1.3.1
    flake8-import-order>=0.9
    flake8-typing-imports>=1.1
    pep8-naming
commands = flake8 sqlite3_to_mysql

[testenv:pylint]
basepython = python3
skip_install = true
deps =
    pylint
    -rrequirements_dev.txt
disable = C0301,C0411,R,W0107,W0622
commands =
    pylint --rcfile=tox.ini sqlite3_to_mysql

[testenv:bandit]
basepython = python3
skip_install = true
deps =
    bandit
commands =
    bandit -r sqlite3_to_mysql -c .bandit.yml

[testenv:linters]
basepython = python3
skip_install = true
deps =
    {[testenv:black]deps}
    {[testenv:flake8]deps}
    {[testenv:pylint]deps}
    {[testenv:bandit]deps}
commands =
    {[testenv:black]commands}
    {[testenv:flake8]commands}
    {[testenv:pylint]commands}
    {[testenv:bandit]commands}

[testenv:setuppy]
basepython = python3
deps =
    docutils
    Pygments
commands =
    python setup.py check --metadata --strict

[flake8]
ignore = I100,I202,D203,D401,W503,E203,F401,F403,C901,E501
exclude =
    *__init__.py
    *__version__.py
    .tox
max-complexity = 10
max-line-length = 88
import-order-style = pycharm
application-import-names = flake807070100000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000B00000000TRAILER!!!295 blocks

Places

File sqlite3-to-mysql-1.4.1.obscpio of Package python-sqlite3-to-mysql (Revision f62de21ee17fce8292c48498f08a0445)

Places