v2.0.1

sensor start/stop/join eventtypes
formatting fixes
2026-08-24 11:44:12 -05:00 · 2024-09-30 00:50:07 -04:00 · 2024-09-30 00:49:59 -04:00 · 2024-09-30 00:32:07 -04:00 · 2024-09-30 00:14:16 -04:00 · 2024-09-30 00:09:38 -04:00
98 changed files with 18007 additions and 525 deletions
@@ -0,0 +1,16 @@
+coverage:
+  status:
+    patch: no
+    changes: no
+    project:
+      default: false
+      tconnectsync:
+        paths: 
+        - "tconnectsync/"
+        target: '75%'
+        threshold: '5%'
+      tests:
+        paths:
+        - "tests/"
+        target: '95%'
+        threshold: '5%'
@@ -0,0 +1,53 @@
+---
+name: 'Setup help: tconnectsync-heroku'
+about: When experiencing an issue setting up tconnectsync-heroku
+title: ''
+labels: heroku, setup help
+assignees: ''
+
+---
+
+**Describe the problem**
+A clear and concise description of the issue you're experiencing.
+
+
+
+**To Reproduce**
+Steps to reproduce the behavior:
+1. ...
+2. ...
+
+
+
+**Expected behavior**
+A clear and concise description of what you expected to happen.
+
+
+
+**Have you followed the [Troubleshooting steps in the README?](https://github.com/jwoglom/tconnectsync-heroku#troubleshooting)** (Yes or No)
+
+
+
+**Setup details**
+
+* **On what platform are you using the t:connect mobile app?** (Android or iOS)
+* **What version are you using of the t:connect mobile app?**
+
+
+
+**Heroku log output**
+If applicable, add the full output from the heroku logs in More > View Logs. ([See the instructions in the README.](https://github.com/jwoglom/tconnectsync-heroku#testing))
+
+
+
+**Check Login output**
+If applicable, [please follow the instructions to visit the `check_login` page](https://github.com/jwoglom/tconnectsync-heroku#testing), and copy and paste the output here.
+
+This file may contain sensitive details like your Nightscout URL and pump serial number. Copy the output into a text editor like Textedit or Notepad first and find-and-replace sensitive strings, like your Nightscout URL and pump serial number, if they appear.
+
+The output will also contain pump and CGM related information such as delivery events and blood sugars. If you would prefer to keep the contents private, send an email to tconnectsync<at>wogloms.net with the log output so @jwoglom can investigate.
+
+
+
+**Additional context**
+Add any other context about the problem here.
@@ -0,0 +1,49 @@
+---
+name: 'Setup help: tconnectsync'
+about: When experiencing an issue setting up tconnectsync on Windows, Linux, or MacOS.
+title: ''
+labels: setup help
+assignees: ''
+
+---
+
+**Describe the problem**
+A clear and concise description of the issue you're experiencing.
+
+
+
+**To Reproduce**
+Steps to reproduce the behavior:
+1. ...
+2. ...
+
+
+
+**Expected behavior**
+A clear and concise description of what you expected to happen.
+
+
+
+**Setup details**
+
+* **Operating system:** 
+* **tconnectsync version** (from `--version`): 
+* **On what platform are you using the t:connect mobile app?** (Android or iOS)
+* **What version are you using of the t:connect mobile app?**
+
+
+
+**Terminal output**
+If applicable, add the full output from your terminal from running tconnectsync. Copy the output into a text editor like Textedit or Notepad first and find-and-replace sensitive strings, like your Nightscout URL and pump serial number, if they appear.
+
+
+
+**Check Login output**
+If applicable, please run `--check-login` and upload the tconnectsync-check-output.log file as an attachment on the issue. This file should have sensitive details like your Nightscout URL and pump serial number automatically removed, but double-check before uploading.
+
+This log will contain pump and CGM related information such as delivery events and blood sugars. If you would prefer to keep the contents private, send an email to tconnectsync<at>wogloms.net with the log output so @jwoglom can investigate.
+
+
+
+**Additional context**
+Add any other context about the problem here.
@@ -1,9 +1,9 @@
 name: Publish Docker image
 on:
  push:
-    branches: [ master ]
-  pull_request:
-    branches: [ master ]
+    tags:
+      - 'v*'
+  workflow_dispatch:

 jobs:
  push_to_registry:
@@ -21,3 +21,45 @@ jobs:
          registry: docker.pkg.github.com
          repository: jwoglom/tconnectsync/tconnectsync
          tag_with_ref: true
+
+      - name: Push latest tag to GitHub Packages
+        uses: docker/build-push-action@v1
+        with:
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+          registry: docker.pkg.github.com
+          repository: jwoglom/tconnectsync/tconnectsync
+          tags: latest
+          push: ${{ startsWith(github.ref, 'refs/tags/') }}
+
+  push_to_dockerhub:
+    name: Push Docker image to Docker Hub
+    runs-on: ubuntu-latest
+    steps:
+      - name: Check out the repo
+        uses: actions/checkout@v2
+      
+      - name: Log in to Docker Hub
+        uses: docker/login-action@f054a8b539a109f9f41c372932f1ae047eff08c9
+        with:
+          username: ${{ secrets.DOCKER_USERNAME }}
+          password: ${{ secrets.DOCKER_PASSWORD }}
+      
+      - name: Extract metadata (tags, labels) for Docker
+        id: meta
+        uses: docker/metadata-action@98669ae865ea3cffbcbaa878cf57c20bbf1c6c38
+        with:
+          images: jwoglom/tconnectsync
+          tags: |
+            type=ref,event=branch
+            type=ref,event=pr
+            type=semver,pattern={{version}}
+            type=semver,pattern={{major}}.{{minor}}
+      
+      - name: Build and push Docker image
+        uses: docker/build-push-action@ad44023a93711e3deb337508980b4b5e9bcdc5dc
+        with:
+          context: .
+          push: true
+          tags: ${{ steps.meta.outputs.tags }}
+          labels: ${{ steps.meta.outputs.labels }}
@@ -0,0 +1,33 @@
+name: Publish to PyPI
+on: workflow_dispatch
+
+jobs:
+  build-binary:
+    name: Build Binary and Publish to PyPI
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@master
+    - name: Set up Python 3.9
+      uses: actions/setup-python@v1
+      with:
+        python-version: 3.9
+
+    - name: Install pypa/build
+      run: >-
+        python -m
+        pip install
+        build
+        --user
+    - name: Build a binary wheel and a source tarball
+      run: >-
+        python -m
+        build
+        --sdist
+        --wheel
+        --outdir dist/
+        .
+    - name: Publish to PyPI
+      uses: pypa/gh-action-pypi-publish@master
+      with:
+        password: ${{ secrets.PYPI_API_TOKEN }}
@@ -15,7 +15,7 @@ jobs:
    runs-on: ubuntu-latest
    strategy:
      matrix:
-        python-version: [3.6, 3.7, 3.8, 3.9]
+        python-version: ['3.7', '3.8', '3.9', '3.10']

    steps:
    - uses: actions/checkout@v2
@@ -30,7 +30,23 @@ jobs:
        pipenv install --system
    - name: Run pipenv check
      run: |
-        pipenv check
+       # DDoS attacks in wheel and setuptools packages, not relevant
+       # root certificate store, not relevant
+        pipenv check \
+          --ignore 51499 \
+          --ignore 52495 \
+          --ignore 52365 \
+          --ignore 59956 \
+          --ignore 58755 \
+          --ignore 67895 \
+          --ignore 61893 \
+          --ignore 61601 \
+          --ignore 62044 \
+          --ignore 67599 \
+          --ignore 72083 \
+          --ignore 71064 \
+          --ignore 71608 \
+          --ignore 72236
    - name: Lint with flake8
      run: |
        # stop the build if there are Python syntax errors or undefined names
@@ -40,3 +56,19 @@ jobs:
    - name: Test with pytest
      run: |
        pytest
+    - name: Check codecov configuration
+      run: |
+        curl -X POST --data-binary @.codecov.yml https://codecov.io/validate
+
+        if [[ "$(curl -s -o /dev/null -w "%{http_code}" -X POST --data-binary @.codecov.yml https://codecov.io/validate)" != "200" ]]; then
+          echo Error parsing codecov file
+          exit 1
+        fi
+    - name: Generate Coverage Report
+      run: |
+        pip install coverage
+        coverage run -m unittest
+    - name: Upload Coverage to Codecov
+      uses: codecov/codecov-action@v1
+      with:
+        fail_ci_if_error: false
@@ -1,6 +1,11 @@
 __pycache__
+dist
+build
 *.pyc
 *.pyo
 *.swp
 *.swa
+*.egg-info
 .env
+tconnectsync-check-output.log
+ignore_*
@@ -15,16 +15,22 @@ FROM base AS python-deps
 RUN pip install pipenv
 RUN apt-get update && apt-get install -y --no-install-recommends gcc

+RUN mkdir -p /base
+WORKDIR /base
+
 # Install python dependencies in /.venv
 COPY Pipfile .
 COPY Pipfile.lock .
+COPY setup.cfg .
+COPY setup.py .
+COPY pyproject.toml .
 RUN PIPENV_VENV_IN_PROJECT=1 pipenv install --deploy

 FROM base AS runtime

 # Copy virtualenv from python-deps stage
-COPY --from=python-deps /.venv /.venv
-ENV PATH="/.venv/bin:$PATH"
+COPY --from=python-deps /base/.venv /base/.venv
+ENV PATH="/base/.venv/bin:$PATH"

 # Create and switch to a new user
 RUN useradd --create-home appuser
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 James Woglom 
+
+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.
@@ -4,14 +4,24 @@ url = "https://pypi.org/simple"
 verify_ssl = true

 [dev-packages]
+ptpython = "*"

 [packages]
-requests = "*"
+tconnectsync = {path = "."}
 bs4 = "*"
 arrow = "*"
 lxml = "*"
 python-dotenv = "*"
+requests-mock = "*"
+pysocks = "*"
+urllib3 = "==1.26.6"
+requests = {extras = ["socks"], version = "*"}
+requests-oidc = "*"
+pyjwt = "*"
+cryptography = "*"
+dataclasses-json = "*"

 [scripts]
 tconnectsync = "python3 main.py"
-test = "python3 -m unittest discover -vv"
+test = "python3 -m unittest discover -vv"
+build_events = "bash -c 'cd tconnectsync/eventparser && python3 build_events.py > events.py'"
@@ -1,7 +1,7 @@
 {
    "_meta": {
        "hash": {
-            "sha256": "071afba23de7f532f99a0611caed63951c6f7ba968ba877ad5c76c244e78577e"
+            "sha256": "586b477d4c73da1d1034f852a536bf3c20a1a358406bfb5dfc1b1164f606441b"
        },
        "pipfile-spec": 6,
        "requires": {},
@@ -16,140 +16,662 @@
    "default": {
        "arrow": {
            "hashes": [
-                "sha256:3515630f11a15c61dcb4cdd245883270dd334c83f3e639824e65a4b79cc48543",
-                "sha256:399c9c8ae732270e1aa58ead835a79a40d7be8aa109c579898eb41029b5a231d"
+                "sha256:c728b120ebc00eb84e01882a6f5e7927a53960aa990ce7dd2b10f39005a67f80",
+                "sha256:d4540617648cb5f895730f1ad8c82a65f2dad0166f57b75f3ca54759c4d67a85"
            ],
            "index": "pypi",
-            "version": "==1.0.3"
+            "markers": "python_version >= '3.8'",
+            "version": "==1.3.0"
        },
        "beautifulsoup4": {
            "hashes": [
-                "sha256:4c98143716ef1cb40bf7f39a8e3eec8f8b009509e74904ba3a7b315431577e35",
-                "sha256:84729e322ad1d5b4d25f805bfa05b902dd96450f43842c4e99067d5e1369eb25",
-                "sha256:fff47e031e34ec82bf17e00da8f592fe7de69aeea38be00523c04623c04fb666"
+                "sha256:74e3d1928edc070d21748185c46e3fb33490f22f52a3addee9aee0f4f7781051",
+                "sha256:b80878c9f40111313e55da8ba20bdba06d8fa3969fc68304167741bbf9e082ed"
            ],
-            "version": "==4.9.3"
+            "markers": "python_full_version >= '3.6.0'",
+            "version": "==4.12.3"
        },
        "bs4": {
            "hashes": [
-                "sha256:36ecea1fd7cc5c0c6e4a1ff075df26d50da647b75376626cc186e2212886dd3a"
+                "sha256:a48685c58f50fe127722417bae83fe6badf500d54b55f7e39ffe43b798653925",
+                "sha256:abf8742c0805ef7f662dce4b51cca104cffe52b835238afc169142ab9b3fbccc"
            ],
            "index": "pypi",
-            "version": "==0.0.1"
+            "version": "==0.0.2"
        },
        "certifi": {
            "hashes": [
-                "sha256:1a4995114262bffbc2413b159f2a1a480c969de6e6eb13ee966d470af86af59c",
-                "sha256:719a74fb9e33b9bd44cc7f3a8d94bc35e4049deebe19ba7d8e108280cfd59830"
+                "sha256:922820b53db7a7257ffbda3f597266d435245903d80737e34f8a45ff3e3230d8",
+                "sha256:bec941d2aa8195e248a60b31ff9f0558284cf01a52591ceda73ea9afffd69fd9"
            ],
-            "version": "==2020.12.5"
+            "markers": "python_version >= '3.6'",
+            "version": "==2024.8.30"
        },
-        "chardet": {
+        "cffi": {
            "hashes": [
-                "sha256:0d6f53a15db4120f2b08c94f11e7d93d2c911ee118b6b30a04ec3ee8310179fa",
-                "sha256:f864054d66fd9118f2e67044ac8981a54775ec5b67aed0441892edb553d21da5"
+                "sha256:045d61c734659cc045141be4bae381a41d89b741f795af1dd018bfb532fd0df8",
+                "sha256:0984a4925a435b1da406122d4d7968dd861c1385afe3b45ba82b750f229811e2",
+                "sha256:0e2b1fac190ae3ebfe37b979cc1ce69c81f4e4fe5746bb401dca63a9062cdaf1",
+                "sha256:0f048dcf80db46f0098ccac01132761580d28e28bc0f78ae0d58048063317e15",
+                "sha256:1257bdabf294dceb59f5e70c64a3e2f462c30c7ad68092d01bbbfb1c16b1ba36",
+                "sha256:1c39c6016c32bc48dd54561950ebd6836e1670f2ae46128f67cf49e789c52824",
+                "sha256:1d599671f396c4723d016dbddb72fe8e0397082b0a77a4fab8028923bec050e8",
+                "sha256:28b16024becceed8c6dfbc75629e27788d8a3f9030691a1dbf9821a128b22c36",
+                "sha256:2bb1a08b8008b281856e5971307cc386a8e9c5b625ac297e853d36da6efe9c17",
+                "sha256:30c5e0cb5ae493c04c8b42916e52ca38079f1b235c2f8ae5f4527b963c401caf",
+                "sha256:31000ec67d4221a71bd3f67df918b1f88f676f1c3b535a7eb473255fdc0b83fc",
+                "sha256:386c8bf53c502fff58903061338ce4f4950cbdcb23e2902d86c0f722b786bbe3",
+                "sha256:3edc8d958eb099c634dace3c7e16560ae474aa3803a5df240542b305d14e14ed",
+                "sha256:45398b671ac6d70e67da8e4224a065cec6a93541bb7aebe1b198a61b58c7b702",
+                "sha256:46bf43160c1a35f7ec506d254e5c890f3c03648a4dbac12d624e4490a7046cd1",
+                "sha256:4ceb10419a9adf4460ea14cfd6bc43d08701f0835e979bf821052f1805850fe8",
+                "sha256:51392eae71afec0d0c8fb1a53b204dbb3bcabcb3c9b807eedf3e1e6ccf2de903",
+                "sha256:5da5719280082ac6bd9aa7becb3938dc9f9cbd57fac7d2871717b1feb0902ab6",
+                "sha256:610faea79c43e44c71e1ec53a554553fa22321b65fae24889706c0a84d4ad86d",
+                "sha256:636062ea65bd0195bc012fea9321aca499c0504409f413dc88af450b57ffd03b",
+                "sha256:6883e737d7d9e4899a8a695e00ec36bd4e5e4f18fabe0aca0efe0a4b44cdb13e",
+                "sha256:6b8b4a92e1c65048ff98cfe1f735ef8f1ceb72e3d5f0c25fdb12087a23da22be",
+                "sha256:6f17be4345073b0a7b8ea599688f692ac3ef23ce28e5df79c04de519dbc4912c",
+                "sha256:706510fe141c86a69c8ddc029c7910003a17353970cff3b904ff0686a5927683",
+                "sha256:72e72408cad3d5419375fc87d289076ee319835bdfa2caad331e377589aebba9",
+                "sha256:733e99bc2df47476e3848417c5a4540522f234dfd4ef3ab7fafdf555b082ec0c",
+                "sha256:7596d6620d3fa590f677e9ee430df2958d2d6d6de2feeae5b20e82c00b76fbf8",
+                "sha256:78122be759c3f8a014ce010908ae03364d00a1f81ab5c7f4a7a5120607ea56e1",
+                "sha256:805b4371bf7197c329fcb3ead37e710d1bca9da5d583f5073b799d5c5bd1eee4",
+                "sha256:85a950a4ac9c359340d5963966e3e0a94a676bd6245a4b55bc43949eee26a655",
+                "sha256:8f2cdc858323644ab277e9bb925ad72ae0e67f69e804f4898c070998d50b1a67",
+                "sha256:9755e4345d1ec879e3849e62222a18c7174d65a6a92d5b346b1863912168b595",
+                "sha256:98e3969bcff97cae1b2def8ba499ea3d6f31ddfdb7635374834cf89a1a08ecf0",
+                "sha256:a08d7e755f8ed21095a310a693525137cfe756ce62d066e53f502a83dc550f65",
+                "sha256:a1ed2dd2972641495a3ec98445e09766f077aee98a1c896dcb4ad0d303628e41",
+                "sha256:a24ed04c8ffd54b0729c07cee15a81d964e6fee0e3d4d342a27b020d22959dc6",
+                "sha256:a45e3c6913c5b87b3ff120dcdc03f6131fa0065027d0ed7ee6190736a74cd401",
+                "sha256:a9b15d491f3ad5d692e11f6b71f7857e7835eb677955c00cc0aefcd0669adaf6",
+                "sha256:ad9413ccdeda48c5afdae7e4fa2192157e991ff761e7ab8fdd8926f40b160cc3",
+                "sha256:b2ab587605f4ba0bf81dc0cb08a41bd1c0a5906bd59243d56bad7668a6fc6c16",
+                "sha256:b62ce867176a75d03a665bad002af8e6d54644fad99a3c70905c543130e39d93",
+                "sha256:c03e868a0b3bc35839ba98e74211ed2b05d2119be4e8a0f224fba9384f1fe02e",
+                "sha256:c59d6e989d07460165cc5ad3c61f9fd8f1b4796eacbd81cee78957842b834af4",
+                "sha256:c7eac2ef9b63c79431bc4b25f1cd649d7f061a28808cbc6c47b534bd789ef964",
+                "sha256:c9c3d058ebabb74db66e431095118094d06abf53284d9c81f27300d0e0d8bc7c",
+                "sha256:ca74b8dbe6e8e8263c0ffd60277de77dcee6c837a3d0881d8c1ead7268c9e576",
+                "sha256:caaf0640ef5f5517f49bc275eca1406b0ffa6aa184892812030f04c2abf589a0",
+                "sha256:cdf5ce3acdfd1661132f2a9c19cac174758dc2352bfe37d98aa7512c6b7178b3",
+                "sha256:d016c76bdd850f3c626af19b0542c9677ba156e4ee4fccfdd7848803533ef662",
+                "sha256:d01b12eeeb4427d3110de311e1774046ad344f5b1a7403101878976ecd7a10f3",
+                "sha256:d63afe322132c194cf832bfec0dc69a99fb9bb6bbd550f161a49e9e855cc78ff",
+                "sha256:da95af8214998d77a98cc14e3a3bd00aa191526343078b530ceb0bd710fb48a5",
+                "sha256:dd398dbc6773384a17fe0d3e7eeb8d1a21c2200473ee6806bb5e6a8e62bb73dd",
+                "sha256:de2ea4b5833625383e464549fec1bc395c1bdeeb5f25c4a3a82b5a8c756ec22f",
+                "sha256:de55b766c7aa2e2a3092c51e0483d700341182f08e67c63630d5b6f200bb28e5",
+                "sha256:df8b1c11f177bc2313ec4b2d46baec87a5f3e71fc8b45dab2ee7cae86d9aba14",
+                "sha256:e03eab0a8677fa80d646b5ddece1cbeaf556c313dcfac435ba11f107ba117b5d",
+                "sha256:e221cf152cff04059d011ee126477f0d9588303eb57e88923578ace7baad17f9",
+                "sha256:e31ae45bc2e29f6b2abd0de1cc3b9d5205aa847cafaecb8af1476a609a2f6eb7",
+                "sha256:edae79245293e15384b51f88b00613ba9f7198016a5948b5dddf4917d4d26382",
+                "sha256:f1e22e8c4419538cb197e4dd60acc919d7696e5ef98ee4da4e01d3f8cfa4cc5a",
+                "sha256:f3a2b4222ce6b60e2e8b337bb9596923045681d71e5a082783484d845390938e",
+                "sha256:f6a16c31041f09ead72d69f583767292f750d24913dadacf5756b966aacb3f1a",
+                "sha256:f75c7ab1f9e4aca5414ed4d8e5c0e303a34f4421f8a0d47a4d019ceff0ab6af4",
+                "sha256:f79fc4fc25f1c8698ff97788206bb3c2598949bfe0fef03d299eb1b5356ada99",
+                "sha256:f7f5baafcc48261359e14bcd6d9bff6d4b28d9103847c9e136694cb0501aef87",
+                "sha256:fc48c783f9c87e60831201f2cce7f3b2e4846bf4d8728eabe54d60700b318a0b"
            ],
-            "markers": "python_version >= '2.7' and python_version not in '3.0, 3.1, 3.2, 3.3, 3.4'",
-            "version": "==4.0.0"
+            "markers": "platform_python_implementation != 'PyPy'",
+            "version": "==1.17.1"
+        },
+        "charset-normalizer": {
+            "hashes": [
+                "sha256:06435b539f889b1f6f4ac1758871aae42dc3a8c0e24ac9e60c2384973ad73027",
+                "sha256:06a81e93cd441c56a9b65d8e1d043daeb97a3d0856d177d5c90ba85acb3db087",
+                "sha256:0a55554a2fa0d408816b3b5cedf0045f4b8e1a6065aec45849de2d6f3f8e9786",
+                "sha256:0b2b64d2bb6d3fb9112bafa732def486049e63de9618b5843bcdd081d8144cd8",
+                "sha256:10955842570876604d404661fbccbc9c7e684caf432c09c715ec38fbae45ae09",
+                "sha256:122c7fa62b130ed55f8f285bfd56d5f4b4a5b503609d181f9ad85e55c89f4185",
+                "sha256:1ceae2f17a9c33cb48e3263960dc5fc8005351ee19db217e9b1bb15d28c02574",
+                "sha256:1d3193f4a680c64b4b6a9115943538edb896edc190f0b222e73761716519268e",
+                "sha256:1f79682fbe303db92bc2b1136016a38a42e835d932bab5b3b1bfcfbf0640e519",
+                "sha256:2127566c664442652f024c837091890cb1942c30937add288223dc895793f898",
+                "sha256:22afcb9f253dac0696b5a4be4a1c0f8762f8239e21b99680099abd9b2b1b2269",
+                "sha256:25baf083bf6f6b341f4121c2f3c548875ee6f5339300e08be3f2b2ba1721cdd3",
+                "sha256:2e81c7b9c8979ce92ed306c249d46894776a909505d8f5a4ba55b14206e3222f",
+                "sha256:3287761bc4ee9e33561a7e058c72ac0938c4f57fe49a09eae428fd88aafe7bb6",
+                "sha256:34d1c8da1e78d2e001f363791c98a272bb734000fcef47a491c1e3b0505657a8",
+                "sha256:37e55c8e51c236f95b033f6fb391d7d7970ba5fe7ff453dad675e88cf303377a",
+                "sha256:3d47fa203a7bd9c5b6cee4736ee84ca03b8ef23193c0d1ca99b5089f72645c73",
+                "sha256:3e4d1f6587322d2788836a99c69062fbb091331ec940e02d12d179c1d53e25fc",
+                "sha256:42cb296636fcc8b0644486d15c12376cb9fa75443e00fb25de0b8602e64c1714",
+                "sha256:45485e01ff4d3630ec0d9617310448a8702f70e9c01906b0d0118bdf9d124cf2",
+                "sha256:4a78b2b446bd7c934f5dcedc588903fb2f5eec172f3d29e52a9096a43722adfc",
+                "sha256:4ab2fe47fae9e0f9dee8c04187ce5d09f48eabe611be8259444906793ab7cbce",
+                "sha256:4d0d1650369165a14e14e1e47b372cfcb31d6ab44e6e33cb2d4e57265290044d",
+                "sha256:549a3a73da901d5bc3ce8d24e0600d1fa85524c10287f6004fbab87672bf3e1e",
+                "sha256:55086ee1064215781fff39a1af09518bc9255b50d6333f2e4c74ca09fac6a8f6",
+                "sha256:572c3763a264ba47b3cf708a44ce965d98555f618ca42c926a9c1616d8f34269",
+                "sha256:573f6eac48f4769d667c4442081b1794f52919e7edada77495aaed9236d13a96",
+                "sha256:5b4c145409bef602a690e7cfad0a15a55c13320ff7a3ad7ca59c13bb8ba4d45d",
+                "sha256:6463effa3186ea09411d50efc7d85360b38d5f09b870c48e4600f63af490e56a",
+                "sha256:65f6f63034100ead094b8744b3b97965785388f308a64cf8d7c34f2f2e5be0c4",
+                "sha256:663946639d296df6a2bb2aa51b60a2454ca1cb29835324c640dafb5ff2131a77",
+                "sha256:6897af51655e3691ff853668779c7bad41579facacf5fd7253b0133308cf000d",
+                "sha256:68d1f8a9e9e37c1223b656399be5d6b448dea850bed7d0f87a8311f1ff3dabb0",
+                "sha256:6ac7ffc7ad6d040517be39eb591cac5ff87416c2537df6ba3cba3bae290c0fed",
+                "sha256:6b3251890fff30ee142c44144871185dbe13b11bab478a88887a639655be1068",
+                "sha256:6c4caeef8fa63d06bd437cd4bdcf3ffefe6738fb1b25951440d80dc7df8c03ac",
+                "sha256:6ef1d82a3af9d3eecdba2321dc1b3c238245d890843e040e41e470ffa64c3e25",
+                "sha256:753f10e867343b4511128c6ed8c82f7bec3bd026875576dfd88483c5c73b2fd8",
+                "sha256:7cd13a2e3ddeed6913a65e66e94b51d80a041145a026c27e6bb76c31a853c6ab",
+                "sha256:7ed9e526742851e8d5cc9e6cf41427dfc6068d4f5a3bb03659444b4cabf6bc26",
+                "sha256:7f04c839ed0b6b98b1a7501a002144b76c18fb1c1850c8b98d458ac269e26ed2",
+                "sha256:802fe99cca7457642125a8a88a084cef28ff0cf9407060f7b93dca5aa25480db",
+                "sha256:80402cd6ee291dcb72644d6eac93785fe2c8b9cb30893c1af5b8fdd753b9d40f",
+                "sha256:8465322196c8b4d7ab6d1e049e4c5cb460d0394da4a27d23cc242fbf0034b6b5",
+                "sha256:86216b5cee4b06df986d214f664305142d9c76df9b6512be2738aa72a2048f99",
+                "sha256:87d1351268731db79e0f8e745d92493ee2841c974128ef629dc518b937d9194c",
+                "sha256:8bdb58ff7ba23002a4c5808d608e4e6c687175724f54a5dade5fa8c67b604e4d",
+                "sha256:8c622a5fe39a48f78944a87d4fb8a53ee07344641b0562c540d840748571b811",
+                "sha256:8d756e44e94489e49571086ef83b2bb8ce311e730092d2c34ca8f7d925cb20aa",
+                "sha256:8f4a014bc36d3c57402e2977dada34f9c12300af536839dc38c0beab8878f38a",
+                "sha256:9063e24fdb1e498ab71cb7419e24622516c4a04476b17a2dab57e8baa30d6e03",
+                "sha256:90d558489962fd4918143277a773316e56c72da56ec7aa3dc3dbbe20fdfed15b",
+                "sha256:923c0c831b7cfcb071580d3f46c4baf50f174be571576556269530f4bbd79d04",
+                "sha256:95f2a5796329323b8f0512e09dbb7a1860c46a39da62ecb2324f116fa8fdc85c",
+                "sha256:96b02a3dc4381e5494fad39be677abcb5e6634bf7b4fa83a6dd3112607547001",
+                "sha256:9f96df6923e21816da7e0ad3fd47dd8f94b2a5ce594e00677c0013018b813458",
+                "sha256:a10af20b82360ab00827f916a6058451b723b4e65030c5a18577c8b2de5b3389",
+                "sha256:a50aebfa173e157099939b17f18600f72f84eed3049e743b68ad15bd69b6bf99",
+                "sha256:a981a536974bbc7a512cf44ed14938cf01030a99e9b3a06dd59578882f06f985",
+                "sha256:a9a8e9031d613fd2009c182b69c7b2c1ef8239a0efb1df3f7c8da66d5dd3d537",
+                "sha256:ae5f4161f18c61806f411a13b0310bea87f987c7d2ecdbdaad0e94eb2e404238",
+                "sha256:aed38f6e4fb3f5d6bf81bfa990a07806be9d83cf7bacef998ab1a9bd660a581f",
+                "sha256:b01b88d45a6fcb69667cd6d2f7a9aeb4bf53760d7fc536bf679ec94fe9f3ff3d",
+                "sha256:b261ccdec7821281dade748d088bb6e9b69e6d15b30652b74cbbac25e280b796",
+                "sha256:b2b0a0c0517616b6869869f8c581d4eb2dd83a4d79e0ebcb7d373ef9956aeb0a",
+                "sha256:b4a23f61ce87adf89be746c8a8974fe1c823c891d8f86eb218bb957c924bb143",
+                "sha256:bd8f7df7d12c2db9fab40bdd87a7c09b1530128315d047a086fa3ae3435cb3a8",
+                "sha256:beb58fe5cdb101e3a055192ac291b7a21e3b7ef4f67fa1d74e331a7f2124341c",
+                "sha256:c002b4ffc0be611f0d9da932eb0f704fe2602a9a949d1f738e4c34c75b0863d5",
+                "sha256:c083af607d2515612056a31f0a8d9e0fcb5876b7bfc0abad3ecd275bc4ebc2d5",
+                "sha256:c180f51afb394e165eafe4ac2936a14bee3eb10debc9d9e4db8958fe36afe711",
+                "sha256:c235ebd9baae02f1b77bcea61bce332cb4331dc3617d254df3323aa01ab47bd4",
+                "sha256:cd70574b12bb8a4d2aaa0094515df2463cb429d8536cfb6c7ce983246983e5a6",
+                "sha256:d0eccceffcb53201b5bfebb52600a5fb483a20b61da9dbc885f8b103cbe7598c",
+                "sha256:d965bba47ddeec8cd560687584e88cf699fd28f192ceb452d1d7ee807c5597b7",
+                "sha256:db364eca23f876da6f9e16c9da0df51aa4f104a972735574842618b8c6d999d4",
+                "sha256:ddbb2551d7e0102e7252db79ba445cdab71b26640817ab1e3e3648dad515003b",
+                "sha256:deb6be0ac38ece9ba87dea880e438f25ca3eddfac8b002a2ec3d9183a454e8ae",
+                "sha256:e06ed3eb3218bc64786f7db41917d4e686cc4856944f53d5bdf83a6884432e12",
+                "sha256:e27ad930a842b4c5eb8ac0016b0a54f5aebbe679340c26101df33424142c143c",
+                "sha256:e537484df0d8f426ce2afb2d0f8e1c3d0b114b83f8850e5f2fbea0e797bd82ae",
+                "sha256:eb00ed941194665c332bf8e078baf037d6c35d7c4f3102ea2d4f16ca94a26dc8",
+                "sha256:eb6904c354526e758fda7167b33005998fb68c46fbc10e013ca97f21ca5c8887",
+                "sha256:eb8821e09e916165e160797a6c17edda0679379a4be5c716c260e836e122f54b",
+                "sha256:efcb3f6676480691518c177e3b465bcddf57cea040302f9f4e6e191af91174d4",
+                "sha256:f27273b60488abe721a075bcca6d7f3964f9f6f067c8c4c605743023d7d3944f",
+                "sha256:f30c3cb33b24454a82faecaf01b19c18562b1e89558fb6c56de4d9118a032fd5",
+                "sha256:fb69256e180cb6c8a894fee62b3afebae785babc1ee98b81cdf68bbca1987f33",
+                "sha256:fd1abc0d89e30cc4e02e4064dc67fcc51bd941eb395c502aac3ec19fab46b519",
+                "sha256:ff8fa367d09b717b2a17a052544193ad76cd49979c805768879cb63d9ca50561"
+            ],
+            "markers": "python_full_version >= '3.7.0'",
+            "version": "==3.3.2"
+        },
+        "click": {
+            "hashes": [
+                "sha256:ae74fb96c20a0277a1d615f1e4d73c8414f5a98db8b799a7931d1582f3390c28",
+                "sha256:ca9853ad459e787e2192211578cc907e7594e294c7ccc834310722b41b9ca6de"
+            ],
+            "markers": "python_version >= '3.7'",
+            "version": "==8.1.7"
+        },
+        "cryptography": {
+            "hashes": [
+                "sha256:014f58110f53237ace6a408b5beb6c427b64e084eb451ef25a28308270086494",
+                "sha256:1bbcce1a551e262dfbafb6e6252f1ae36a248e615ca44ba302df077a846a8806",
+                "sha256:203e92a75716d8cfb491dc47c79e17d0d9207ccffcbcb35f598fbe463ae3444d",
+                "sha256:27e613d7077ac613e399270253259d9d53872aaf657471473ebfc9a52935c062",
+                "sha256:2bd51274dcd59f09dd952afb696bf9c61a7a49dfc764c04dd33ef7a6b502a1e2",
+                "sha256:38926c50cff6f533f8a2dae3d7f19541432610d114a70808f0926d5aaa7121e4",
+                "sha256:511f4273808ab590912a93ddb4e3914dfd8a388fed883361b02dea3791f292e1",
+                "sha256:58d4e9129985185a06d849aa6df265bdd5a74ca6e1b736a77959b498e0505b85",
+                "sha256:5b43d1ea6b378b54a1dc99dd8a2b5be47658fe9a7ce0a58ff0b55f4b43ef2b84",
+                "sha256:61ec41068b7b74268fa86e3e9e12b9f0c21fcf65434571dbb13d954bceb08042",
+                "sha256:666ae11966643886c2987b3b721899d250855718d6d9ce41b521252a17985f4d",
+                "sha256:68aaecc4178e90719e95298515979814bda0cbada1256a4485414860bd7ab962",
+                "sha256:7c05650fe8023c5ed0d46793d4b7d7e6cd9c04e68eabe5b0aeea836e37bdcec2",
+                "sha256:80eda8b3e173f0f247f711eef62be51b599b5d425c429b5d4ca6a05e9e856baa",
+                "sha256:8385d98f6a3bf8bb2d65a73e17ed87a3ba84f6991c155691c51112075f9ffc5d",
+                "sha256:88cce104c36870d70c49c7c8fd22885875d950d9ee6ab54df2745f83ba0dc365",
+                "sha256:9d3cdb25fa98afdd3d0892d132b8d7139e2c087da1712041f6b762e4f807cc96",
+                "sha256:a575913fb06e05e6b4b814d7f7468c2c660e8bb16d8d5a1faf9b33ccc569dd47",
+                "sha256:ac119bb76b9faa00f48128b7f5679e1d8d437365c5d26f1c2c3f0da4ce1b553d",
+                "sha256:c1332724be35d23a854994ff0b66530119500b6053d0bd3363265f7e5e77288d",
+                "sha256:d03a475165f3134f773d1388aeb19c2d25ba88b6a9733c5c590b9ff7bbfa2e0c",
+                "sha256:d75601ad10b059ec832e78823b348bfa1a59f6b8d545db3a24fd44362a1564cb",
+                "sha256:de41fd81a41e53267cb020bb3a7212861da53a7d39f863585d13ea11049cf277",
+                "sha256:e710bf40870f4db63c3d7d929aa9e09e4e7ee219e703f949ec4073b4294f6172",
+                "sha256:ea25acb556320250756e53f9e20a4177515f012c9eaea17eb7587a8c4d8ae034",
+                "sha256:f98bf604c82c416bc829e490c700ca1553eafdf2912a91e23a79d97d9801372a",
+                "sha256:fba1007b3ef89946dbbb515aeeb41e30203b004f0b4b00e5e16078b518563289"
+            ],
+            "index": "pypi",
+            "markers": "python_version >= '3.7'",
+            "version": "==43.0.1"
+        },
+        "dataclasses-json": {
+            "hashes": [
+                "sha256:0dbf33f26c8d5305befd61b39d2b3414e8a407bedc2834dea9b8d642666fb40a",
+                "sha256:b6b3e528266ea45b9535223bc53ca645f5208833c29229e847b3f26a1cc55fc0"
+            ],
+            "index": "pypi",
+            "markers": "python_version >= '3.7' and python_version < '4.0'",
+            "version": "==0.6.7"
        },
        "idna": {
            "hashes": [
-                "sha256:b307872f855b18632ce0c21c5e45be78c0ea7ae4c15c828c20788b26921eb3f6",
-                "sha256:b97d804b1e9b523befed77c48dacec60e6dcb0b5391d57af6a65a312a90648c0"
+                "sha256:12f65c9b470abda6dc35cf8e63cc574b1c52b11df2c86030af0ac09b01b13ea9",
+                "sha256:946d195a0d259cbba61165e88e65941f16e9b36ea6ddb97f00452bae8b1287d3"
            ],
-            "markers": "python_version >= '2.7' and python_version not in '3.0, 3.1, 3.2, 3.3'",
-            "version": "==2.10"
+            "markers": "python_version >= '3.6'",
+            "version": "==3.10"
        },
        "lxml": {
            "hashes": [
-                "sha256:079f3ae844f38982d156efce585bc540c16a926d4436712cf4baee0cce487a3d",
-                "sha256:0fbcf5565ac01dff87cbfc0ff323515c823081c5777a9fc7703ff58388c258c3",
-                "sha256:122fba10466c7bd4178b07dba427aa516286b846b2cbd6f6169141917283aae2",
-                "sha256:1b7584d421d254ab86d4f0b13ec662a9014397678a7c4265a02a6d7c2b18a75f",
-                "sha256:26e761ab5b07adf5f555ee82fb4bfc35bf93750499c6c7614bd64d12aaa67927",
-                "sha256:289e9ca1a9287f08daaf796d96e06cb2bc2958891d7911ac7cae1c5f9e1e0ee3",
-                "sha256:2a9d50e69aac3ebee695424f7dbd7b8c6d6eb7de2a2eb6b0f6c7db6aa41e02b7",
-                "sha256:33bb934a044cf32157c12bfcfbb6649807da20aa92c062ef51903415c704704f",
-                "sha256:3439c71103ef0e904ea0a1901611863e51f50b5cd5e8654a151740fde5e1cade",
-                "sha256:39b78571b3b30645ac77b95f7c69d1bffc4cf8c3b157c435a34da72e78c82468",
-                "sha256:4289728b5e2000a4ad4ab8da6e1db2e093c63c08bdc0414799ee776a3f78da4b",
-                "sha256:4bff24dfeea62f2e56f5bab929b4428ae6caba2d1eea0c2d6eb618e30a71e6d4",
-                "sha256:542d454665a3e277f76954418124d67516c5f88e51a900365ed54a9806122b83",
-                "sha256:5a0a14e264069c03e46f926be0d8919f4105c1623d620e7ec0e612a2e9bf1c04",
-                "sha256:66e575c62792c3f9ca47cb8b6fab9e35bab91360c783d1606f758761810c9791",
-                "sha256:74f7d8d439b18fa4c385f3f5dfd11144bb87c1da034a466c5b5577d23a1d9b51",
-                "sha256:7610b8c31688f0b1be0ef882889817939490a36d0ee880ea562a4e1399c447a1",
-                "sha256:76fa7b1362d19f8fbd3e75fe2fb7c79359b0af8747e6f7141c338f0bee2f871a",
-                "sha256:7728e05c35412ba36d3e9795ae8995e3c86958179c9770e65558ec3fdfd3724f",
-                "sha256:8157dadbb09a34a6bd95a50690595e1fa0af1a99445e2744110e3dca7831c4ee",
-                "sha256:820628b7b3135403540202e60551e741f9b6d3304371712521be939470b454ec",
-                "sha256:884ab9b29feaca361f7f88d811b1eea9bfca36cf3da27768d28ad45c3ee6f969",
-                "sha256:89b8b22a5ff72d89d48d0e62abb14340d9e99fd637d046c27b8b257a01ffbe28",
-                "sha256:92e821e43ad382332eade6812e298dc9701c75fe289f2a2d39c7960b43d1e92a",
-                "sha256:b007cbb845b28db4fb8b6a5cdcbf65bacb16a8bd328b53cbc0698688a68e1caa",
-                "sha256:bc4313cbeb0e7a416a488d72f9680fffffc645f8a838bd2193809881c67dd106",
-                "sha256:bccbfc27563652de7dc9bdc595cb25e90b59c5f8e23e806ed0fd623755b6565d",
-                "sha256:c4f05c5a7c49d2fb70223d0d5bcfbe474cf928310ac9fa6a7c6dddc831d0b1d4",
-                "sha256:ce256aaa50f6cc9a649c51be3cd4ff142d67295bfc4f490c9134d0f9f6d58ef0",
-                "sha256:d2e35d7bf1c1ac8c538f88d26b396e73dd81440d59c1ef8522e1ea77b345ede4",
-                "sha256:df7c53783a46febb0e70f6b05df2ba104610f2fb0d27023409734a3ecbb78fb2",
-                "sha256:efac139c3f0bf4f0939f9375af4b02c5ad83a622de52d6dfa8e438e8e01d0eb0",
-                "sha256:efd7a09678fd8b53117f6bae4fa3825e0a22b03ef0a932e070c0bdbb3a35e654",
-                "sha256:f2380a6376dfa090227b663f9678150ef27543483055cc327555fb592c5967e2",
-                "sha256:f8380c03e45cf09f8557bdaa41e1fa7c81f3ae22828e1db470ab2a6c96d8bc23",
-                "sha256:f90ba11136bfdd25cae3951af8da2e95121c9b9b93727b1b896e3fa105b2f586"
+                "sha256:01220dca0d066d1349bd6a1726856a78f7929f3878f7e2ee83c296c69495309e",
+                "sha256:02ced472497b8362c8e902ade23e3300479f4f43e45f4105c85ef43b8db85229",
+                "sha256:052d99051e77a4f3e8482c65014cf6372e61b0a6f4fe9edb98503bb5364cfee3",
+                "sha256:07da23d7ee08577760f0a71d67a861019103e4812c87e2fab26b039054594cc5",
+                "sha256:094cb601ba9f55296774c2d57ad68730daa0b13dc260e1f941b4d13678239e70",
+                "sha256:0a7056921edbdd7560746f4221dca89bb7a3fe457d3d74267995253f46343f15",
+                "sha256:0c120f43553ec759f8de1fee2f4794452b0946773299d44c36bfe18e83caf002",
+                "sha256:0d7b36afa46c97875303a94e8f3ad932bf78bace9e18e603f2085b652422edcd",
+                "sha256:0fdf3a3059611f7585a78ee10399a15566356116a4288380921a4b598d807a22",
+                "sha256:109fa6fede314cc50eed29e6e56c540075e63d922455346f11e4d7a036d2b8cf",
+                "sha256:146173654d79eb1fc97498b4280c1d3e1e5d58c398fa530905c9ea50ea849b22",
+                "sha256:1473427aff3d66a3fa2199004c3e601e6c4500ab86696edffdbc84954c72d832",
+                "sha256:1483fd3358963cc5c1c9b122c80606a3a79ee0875bcac0204149fa09d6ff2727",
+                "sha256:168f2dfcfdedf611eb285efac1516c8454c8c99caf271dccda8943576b67552e",
+                "sha256:17e8d968d04a37c50ad9c456a286b525d78c4a1c15dd53aa46c1d8e06bf6fa30",
+                "sha256:18feb4b93302091b1541221196a2155aa296c363fd233814fa11e181adebc52f",
+                "sha256:1afe0a8c353746e610bd9031a630a95bcfb1a720684c3f2b36c4710a0a96528f",
+                "sha256:1d04f064bebdfef9240478f7a779e8c5dc32b8b7b0b2fc6a62e39b928d428e51",
+                "sha256:1fdc9fae8dd4c763e8a31e7630afef517eab9f5d5d31a278df087f307bf601f4",
+                "sha256:1ffc23010330c2ab67fac02781df60998ca8fe759e8efde6f8b756a20599c5de",
+                "sha256:20094fc3f21ea0a8669dc4c61ed7fa8263bd37d97d93b90f28fc613371e7a875",
+                "sha256:213261f168c5e1d9b7535a67e68b1f59f92398dd17a56d934550837143f79c42",
+                "sha256:218c1b2e17a710e363855594230f44060e2025b05c80d1f0661258142b2add2e",
+                "sha256:23e0553b8055600b3bf4a00b255ec5c92e1e4aebf8c2c09334f8368e8bd174d6",
+                "sha256:25f1b69d41656b05885aa185f5fdf822cb01a586d1b32739633679699f220391",
+                "sha256:2b3778cb38212f52fac9fe913017deea2fdf4eb1a4f8e4cfc6b009a13a6d3fcc",
+                "sha256:2bc9fd5ca4729af796f9f59cd8ff160fe06a474da40aca03fcc79655ddee1a8b",
+                "sha256:2c226a06ecb8cdef28845ae976da407917542c5e6e75dcac7cc33eb04aaeb237",
+                "sha256:2c3406b63232fc7e9b8783ab0b765d7c59e7c59ff96759d8ef9632fca27c7ee4",
+                "sha256:2c86bf781b12ba417f64f3422cfc302523ac9cd1d8ae8c0f92a1c66e56ef2e86",
+                "sha256:2d9b8d9177afaef80c53c0a9e30fa252ff3036fb1c6494d427c066a4ce6a282f",
+                "sha256:2dec2d1130a9cda5b904696cec33b2cfb451304ba9081eeda7f90f724097300a",
+                "sha256:2dfab5fa6a28a0b60a20638dc48e6343c02ea9933e3279ccb132f555a62323d8",
+                "sha256:2ecdd78ab768f844c7a1d4a03595038c166b609f6395e25af9b0f3f26ae1230f",
+                "sha256:315f9542011b2c4e1d280e4a20ddcca1761993dda3afc7a73b01235f8641e903",
+                "sha256:36aef61a1678cb778097b4a6eeae96a69875d51d1e8f4d4b491ab3cfb54b5a03",
+                "sha256:384aacddf2e5813a36495233b64cb96b1949da72bef933918ba5c84e06af8f0e",
+                "sha256:3879cc6ce938ff4eb4900d901ed63555c778731a96365e53fadb36437a131a99",
+                "sha256:3c174dc350d3ec52deb77f2faf05c439331d6ed5e702fc247ccb4e6b62d884b7",
+                "sha256:3eb44520c4724c2e1a57c0af33a379eee41792595023f367ba3952a2d96c2aab",
+                "sha256:406246b96d552e0503e17a1006fd27edac678b3fcc9f1be71a2f94b4ff61528d",
+                "sha256:41ce1f1e2c7755abfc7e759dc34d7d05fd221723ff822947132dc934d122fe22",
+                "sha256:423b121f7e6fa514ba0c7918e56955a1d4470ed35faa03e3d9f0e3baa4c7e492",
+                "sha256:44264ecae91b30e5633013fb66f6ddd05c006d3e0e884f75ce0b4755b3e3847b",
+                "sha256:482c2f67761868f0108b1743098640fbb2a28a8e15bf3f47ada9fa59d9fe08c3",
+                "sha256:4b0c7a688944891086ba192e21c5229dea54382f4836a209ff8d0a660fac06be",
+                "sha256:4c1fefd7e3d00921c44dc9ca80a775af49698bbfd92ea84498e56acffd4c5469",
+                "sha256:4e109ca30d1edec1ac60cdbe341905dc3b8f55b16855e03a54aaf59e51ec8c6f",
+                "sha256:501d0d7e26b4d261fca8132854d845e4988097611ba2531408ec91cf3fd9d20a",
+                "sha256:516f491c834eb320d6c843156440fe7fc0d50b33e44387fcec5b02f0bc118a4c",
+                "sha256:51806cfe0279e06ed8500ce19479d757db42a30fd509940b1701be9c86a5ff9a",
+                "sha256:562e7494778a69086f0312ec9689f6b6ac1c6b65670ed7d0267e49f57ffa08c4",
+                "sha256:56b9861a71575f5795bde89256e7467ece3d339c9b43141dbdd54544566b3b94",
+                "sha256:5b8f5db71b28b8c404956ddf79575ea77aa8b1538e8b2ef9ec877945b3f46442",
+                "sha256:5c2fb570d7823c2bbaf8b419ba6e5662137f8166e364a8b2b91051a1fb40ab8b",
+                "sha256:5c54afdcbb0182d06836cc3d1be921e540be3ebdf8b8a51ee3ef987537455f84",
+                "sha256:5d6a6972b93c426ace71e0be9a6f4b2cfae9b1baed2eed2006076a746692288c",
+                "sha256:609251a0ca4770e5a8768ff902aa02bf636339c5a93f9349b48eb1f606f7f3e9",
+                "sha256:62d172f358f33a26d6b41b28c170c63886742f5b6772a42b59b4f0fa10526cb1",
+                "sha256:62f7fdb0d1ed2065451f086519865b4c90aa19aed51081979ecd05a21eb4d1be",
+                "sha256:658f2aa69d31e09699705949b5fc4719cbecbd4a97f9656a232e7d6c7be1a367",
+                "sha256:65ab5685d56914b9a2a34d67dd5488b83213d680b0c5d10b47f81da5a16b0b0e",
+                "sha256:68934b242c51eb02907c5b81d138cb977b2129a0a75a8f8b60b01cb8586c7b21",
+                "sha256:68b87753c784d6acb8a25b05cb526c3406913c9d988d51f80adecc2b0775d6aa",
+                "sha256:69959bd3167b993e6e710b99051265654133a98f20cec1d9b493b931942e9c16",
+                "sha256:6a7095eeec6f89111d03dabfe5883a1fd54da319c94e0fb104ee8f23616b572d",
+                "sha256:6b038cc86b285e4f9fea2ba5ee76e89f21ed1ea898e287dc277a25884f3a7dfe",
+                "sha256:6ba0d3dcac281aad8a0e5b14c7ed6f9fa89c8612b47939fc94f80b16e2e9bc83",
+                "sha256:6e91cf736959057f7aac7adfc83481e03615a8e8dd5758aa1d95ea69e8931dba",
+                "sha256:6ee8c39582d2652dcd516d1b879451500f8db3fe3607ce45d7c5957ab2596040",
+                "sha256:6f651ebd0b21ec65dfca93aa629610a0dbc13dbc13554f19b0113da2e61a4763",
+                "sha256:71a8dd38fbd2f2319136d4ae855a7078c69c9a38ae06e0c17c73fd70fc6caad8",
+                "sha256:74068c601baff6ff021c70f0935b0c7bc528baa8ea210c202e03757c68c5a4ff",
+                "sha256:7437237c6a66b7ca341e868cda48be24b8701862757426852c9b3186de1da8a2",
+                "sha256:747a3d3e98e24597981ca0be0fd922aebd471fa99d0043a3842d00cdcad7ad6a",
+                "sha256:74bcb423462233bc5d6066e4e98b0264e7c1bed7541fff2f4e34fe6b21563c8b",
+                "sha256:78d9b952e07aed35fe2e1a7ad26e929595412db48535921c5013edc8aa4a35ce",
+                "sha256:7b1cd427cb0d5f7393c31b7496419da594fe600e6fdc4b105a54f82405e6626c",
+                "sha256:7d3d1ca42870cdb6d0d29939630dbe48fa511c203724820fc0fd507b2fb46577",
+                "sha256:7e2f58095acc211eb9d8b5771bf04df9ff37d6b87618d1cbf85f92399c98dae8",
+                "sha256:7f41026c1d64043a36fda21d64c5026762d53a77043e73e94b71f0521939cc71",
+                "sha256:81b4e48da4c69313192d8c8d4311e5d818b8be1afe68ee20f6385d0e96fc9512",
+                "sha256:86a6b24b19eaebc448dc56b87c4865527855145d851f9fc3891673ff97950540",
+                "sha256:874a216bf6afaf97c263b56371434e47e2c652d215788396f60477540298218f",
+                "sha256:89e043f1d9d341c52bf2af6d02e6adde62e0a46e6755d5eb60dc6e4f0b8aeca2",
+                "sha256:8c72e9563347c7395910de6a3100a4840a75a6f60e05af5e58566868d5eb2d6a",
+                "sha256:8dc2c0395bea8254d8daebc76dcf8eb3a95ec2a46fa6fae5eaccee366bfe02ce",
+                "sha256:8f0de2d390af441fe8b2c12626d103540b5d850d585b18fcada58d972b74a74e",
+                "sha256:92e67a0be1639c251d21e35fe74df6bcc40cba445c2cda7c4a967656733249e2",
+                "sha256:94d6c3782907b5e40e21cadf94b13b0842ac421192f26b84c45f13f3c9d5dc27",
+                "sha256:97acf1e1fd66ab53dacd2c35b319d7e548380c2e9e8c54525c6e76d21b1ae3b1",
+                "sha256:9ada35dd21dc6c039259596b358caab6b13f4db4d4a7f8665764d616daf9cc1d",
+                "sha256:9c52100e2c2dbb0649b90467935c4b0de5528833c76a35ea1a2691ec9f1ee7a1",
+                "sha256:9e41506fec7a7f9405b14aa2d5c8abbb4dbbd09d88f9496958b6d00cb4d45330",
+                "sha256:9e4b47ac0f5e749cfc618efdf4726269441014ae1d5583e047b452a32e221920",
+                "sha256:9fb81d2824dff4f2e297a276297e9031f46d2682cafc484f49de182aa5e5df99",
+                "sha256:a0eabd0a81625049c5df745209dc7fcef6e2aea7793e5f003ba363610aa0a3ff",
+                "sha256:a3d819eb6f9b8677f57f9664265d0a10dd6551d227afb4af2b9cd7bdc2ccbf18",
+                "sha256:a87de7dd873bf9a792bf1e58b1c3887b9264036629a5bf2d2e6579fe8e73edff",
+                "sha256:aa617107a410245b8660028a7483b68e7914304a6d4882b5ff3d2d3eb5948d8c",
+                "sha256:aac0bbd3e8dd2d9c45ceb82249e8bdd3ac99131a32b4d35c8af3cc9db1657179",
+                "sha256:ab6dd83b970dc97c2d10bc71aa925b84788c7c05de30241b9e96f9b6d9ea3080",
+                "sha256:ace2c2326a319a0bb8a8b0e5b570c764962e95818de9f259ce814ee666603f19",
+                "sha256:ae5fe5c4b525aa82b8076c1a59d642c17b6e8739ecf852522c6321852178119d",
+                "sha256:b11a5d918a6216e521c715b02749240fb07ae5a1fefd4b7bf12f833bc8b4fe70",
+                "sha256:b1c8c20847b9f34e98080da785bb2336ea982e7f913eed5809e5a3c872900f32",
+                "sha256:b369d3db3c22ed14c75ccd5af429086f166a19627e84a8fdade3f8f31426e52a",
+                "sha256:b710bc2b8292966b23a6a0121f7a6c51d45d2347edcc75f016ac123b8054d3f2",
+                "sha256:bd96517ef76c8654446fc3db9242d019a1bb5fe8b751ba414765d59f99210b79",
+                "sha256:c00f323cc00576df6165cc9d21a4c21285fa6b9989c5c39830c3903dc4303ef3",
+                "sha256:c162b216070f280fa7da844531169be0baf9ccb17263cf5a8bf876fcd3117fa5",
+                "sha256:c1a69e58a6bb2de65902051d57fde951febad631a20a64572677a1052690482f",
+                "sha256:c1f794c02903c2824fccce5b20c339a1a14b114e83b306ff11b597c5f71a1c8d",
+                "sha256:c24037349665434f375645fa9d1f5304800cec574d0310f618490c871fd902b3",
+                "sha256:c300306673aa0f3ed5ed9372b21867690a17dba38c68c44b287437c362ce486b",
+                "sha256:c56a1d43b2f9ee4786e4658c7903f05da35b923fb53c11025712562d5cc02753",
+                "sha256:c6379f35350b655fd817cd0d6cbeef7f265f3ae5fedb1caae2eb442bbeae9ab9",
+                "sha256:c802e1c2ed9f0c06a65bc4ed0189d000ada8049312cfeab6ca635e39c9608957",
+                "sha256:cb83f8a875b3d9b458cada4f880fa498646874ba4011dc974e071a0a84a1b033",
+                "sha256:cf120cce539453ae086eacc0130a324e7026113510efa83ab42ef3fcfccac7fb",
+                "sha256:dd36439be765e2dde7660212b5275641edbc813e7b24668831a5c8ac91180656",
+                "sha256:dd5350b55f9fecddc51385463a4f67a5da829bc741e38cf689f38ec9023f54ab",
+                "sha256:df5c7333167b9674aa8ae1d4008fa4bc17a313cc490b2cca27838bbdcc6bb15b",
+                "sha256:e63601ad5cd8f860aa99d109889b5ac34de571c7ee902d6812d5d9ddcc77fa7d",
+                "sha256:e92ce66cd919d18d14b3856906a61d3f6b6a8500e0794142338da644260595cd",
+                "sha256:e99f5507401436fdcc85036a2e7dc2e28d962550afe1cbfc07c40e454256a859",
+                "sha256:ea2e2f6f801696ad7de8aec061044d6c8c0dd4037608c7cab38a9a4d316bfb11",
+                "sha256:eafa2c8658f4e560b098fe9fc54539f86528651f61849b22111a9b107d18910c",
+                "sha256:ecd4ad8453ac17bc7ba3868371bffb46f628161ad0eefbd0a855d2c8c32dd81a",
+                "sha256:ee70d08fd60c9565ba8190f41a46a54096afa0eeb8f76bd66f2c25d3b1b83005",
+                "sha256:eec1bb8cdbba2925bedc887bc0609a80e599c75b12d87ae42ac23fd199445654",
+                "sha256:ef0c1fe22171dd7c7c27147f2e9c3e86f8bdf473fed75f16b0c2e84a5030ce80",
+                "sha256:f2901429da1e645ce548bf9171784c0f74f0718c3f6150ce166be39e4dd66c3e",
+                "sha256:f422a209d2455c56849442ae42f25dbaaba1c6c3f501d58761c619c7836642ec",
+                "sha256:f65e5120863c2b266dbcc927b306c5b78e502c71edf3295dfcb9501ec96e5fc7",
+                "sha256:f7d4a670107d75dfe5ad080bed6c341d18c4442f9378c9f58e5851e86eb79965",
+                "sha256:f914c03e6a31deb632e2daa881fe198461f4d06e57ac3d0e05bbcab8eae01945",
+                "sha256:fb66442c2546446944437df74379e9cf9e9db353e61301d1a0e26482f43f0dd8"
            ],
            "index": "pypi",
-            "version": "==4.6.3"
+            "markers": "python_version >= '3.6'",
+            "version": "==5.3.0"
+        },
+        "marshmallow": {
+            "hashes": [
+                "sha256:4972f529104a220bb8637d595aa4c9762afbe7f7a77d82dc58c1615d70c5823e",
+                "sha256:71a2dce49ef901c3f97ed296ae5051135fd3febd2bf43afe0ae9a82143a494d9"
+            ],
+            "markers": "python_version >= '3.8'",
+            "version": "==3.22.0"
+        },
+        "mypy-extensions": {
+            "hashes": [
+                "sha256:4392f6c0eb8a5668a69e23d168ffa70f0be9ccfd32b5cc2d26a34ae5b844552d",
+                "sha256:75dbf8955dc00442a438fc4d0666508a9a97b6bd41aa2f0ffe9d2f2725af0782"
+            ],
+            "markers": "python_version >= '3.5'",
+            "version": "==1.0.0"
+        },
+        "oauthlib": {
+            "hashes": [
+                "sha256:8139f29aac13e25d502680e9e19963e83f16838d48a0d71c287fe40e7067fbca",
+                "sha256:9859c40929662bec5d64f34d01c99e093149682a3f38915dc0655d5a633dd918"
+            ],
+            "markers": "python_version >= '3.6'",
+            "version": "==3.2.2"
+        },
+        "packaging": {
+            "hashes": [
+                "sha256:026ed72c8ed3fcce5bf8950572258698927fd1dbda10a5e981cdf0ac37f4f002",
+                "sha256:5b8f2217dbdbd2f7f384c41c628544e6d52f2d0f53c6d0c3ea61aa5d1d7ff124"
+            ],
+            "markers": "python_version >= '3.8'",
+            "version": "==24.1"
+        },
+        "platformdirs": {
+            "hashes": [
+                "sha256:cf8ee52a3afdb965072dcc652433e0c7e3e40cf5ea1477cd4b3b1d2eb75495b3",
+                "sha256:e9d171d00af68be50e9202731309c4e658fd8bc76f55c11c7dd760d023bda68e"
+            ],
+            "markers": "python_version >= '3.7'",
+            "version": "==3.11.0"
+        },
+        "pycparser": {
+            "hashes": [
+                "sha256:491c8be9c040f5390f5bf44a5b07752bd07f56edf992381b05c701439eec10f6",
+                "sha256:c3702b6d3dd8c7abc1afa565d7e63d53a1d0bd86cdc24edd75470f4de499cfcc"
+            ],
+            "markers": "python_version >= '3.8'",
+            "version": "==2.22"
+        },
+        "pyjwt": {
+            "hashes": [
+                "sha256:3b02fb0f44517787776cf48f2ae25d8e14f300e6d7545a4315cee571a415e850",
+                "sha256:7e1e5b56cc735432a7369cbfa0efe50fa113ebecdc04ae6922deba8b84582d0c"
+            ],
+            "index": "pypi",
+            "markers": "python_version >= '3.8'",
+            "version": "==2.9.0"
+        },
+        "pypng": {
+            "hashes": [
+                "sha256:4a43e969b8f5aaafb2a415536c1a8ec7e341cd6a3f957fd5b5f32a4cfeed902c",
+                "sha256:739c433ba96f078315de54c0db975aee537cbc3e1d0ae4ed9aab0ca1e427e2c1"
+            ],
+            "version": "==0.20220715.0"
+        },
+        "pysocks": {
+            "hashes": [
+                "sha256:08e69f092cc6dbe92a0fdd16eeb9b9ffbc13cadfe5ca4c7bd92ffb078b293299",
+                "sha256:2725bd0a9925919b9b51739eea5f9e2bae91e83288108a9ad338b2e3a4435ee5",
+                "sha256:3f8804571ebe159c380ac6de37643bb4685970655d3bba243530d6558b799aa0"
+            ],
+            "index": "pypi",
+            "markers": "python_version >= '2.7' and python_version not in '3.0, 3.1, 3.2, 3.3'",
+            "version": "==1.7.1"
        },
        "python-dateutil": {
            "hashes": [
-                "sha256:73ebfe9dbf22e832286dafa60473e4cd239f8592f699aa5adaf10050e6e1823c",
-                "sha256:75bb3f31ea686f1197762692a9ee6a7550b59fc6ca3a1f4b5d7e32fb98e2da2a"
+                "sha256:37dd54208da7e1cd875388217d5e00ebd4179249f90fb72437e91a35459a0ad3",
+                "sha256:a8b2bc7bffae282281c8140a97d3aa9c14da0b136dfe83f850eea9a5f7470427"
            ],
            "markers": "python_version >= '2.7' and python_version not in '3.0, 3.1, 3.2, 3.3'",
-            "version": "==2.8.1"
+            "version": "==2.9.0.post0"
        },
        "python-dotenv": {
            "hashes": [
-                "sha256:471b782da0af10da1a80341e8438fca5fadeba2881c54360d5fd8d03d03a4f4a",
-                "sha256:49782a97c9d641e8a09ae1d9af0856cc587c8d2474919342d5104d85be9890b2"
+                "sha256:e324ee90a023d808f1959c46bcbc04446a10ced277783dc6ee09987c37ec10ca",
+                "sha256:f7b63ef50f1b690dddf550d03497b66d609393b40b564ed0d674909a68ebf16a"
            ],
            "index": "pypi",
-            "version": "==0.17.0"
+            "markers": "python_version >= '3.8'",
+            "version": "==1.0.1"
+        },
+        "qrcode": {
+            "hashes": [
+                "sha256:581dca7a029bcb2deef5d01068e39093e80ef00b4a61098a2182eac59d01643a",
+                "sha256:9dd969454827e127dbd93696b20747239e6d540e082937c90f14ac95b30f5845"
+            ],
+            "markers": "python_version >= '3.7'",
+            "version": "==7.4.2"
        },
        "requests": {
+            "extras": [
+                "socks"
+            ],
            "hashes": [
-                "sha256:27973dd4a904a4f13b263a19c866c13b92a39ed1c964655f025f3f8d3d75b804",
-                "sha256:c210084e36a42ae6b9219e00e48287def368a26d03a048ddad7bfee44f75871e"
+                "sha256:55365417734eb18255590a9ff9eb97e9e1da868d4ccd6402399eaf68af20a760",
+                "sha256:70761cfe03c773ceb22aa2f671b4757976145175cdfca038c02654d061d6dcc6"
+            ],
+            "markers": "python_version >= '3.8'",
+            "version": "==2.32.3"
+        },
+        "requests-mock": {
+            "hashes": [
+                "sha256:b1e37054004cdd5e56c84454cc7df12b25f90f382159087f4b6915aaeef39563",
+                "sha256:e9e12e333b525156e82a3c852f22016b9158220d2f47454de9cae8a77d371401"
            ],
            "index": "pypi",
-            "version": "==2.25.1"
+            "markers": "python_version >= '3.5'",
+            "version": "==1.12.1"
+        },
+        "requests-oauthlib": {
+            "hashes": [
+                "sha256:2577c501a2fb8d05a304c09d090d6e47c306fef15809d102b327cf8364bddab5",
+                "sha256:75beac4a47881eeb94d5ea5d6ad31ef88856affe2332b9aafb52c6452ccf0d7a"
+            ],
+            "markers": "python_version >= '2.7' and python_version not in '3.0, 3.1, 3.2, 3.3'",
+            "version": "==1.3.1"
+        },
+        "requests-oidc": {
+            "hashes": [
+                "sha256:227fbcc561d0acb54469d62a7d4bde055a8eeee7968cdb98fa732e0d2313d814",
+                "sha256:84ea777457067f8f67fe25534b9c153f3f9a45336c83e073a93ce735a86406ca"
+            ],
+            "index": "pypi",
+            "markers": "python_version >= '3.7' and python_version < '4'",
+            "version": "==0.6.2"
        },
        "six": {
            "hashes": [
-                "sha256:30639c035cdb23534cd4aa2dd52c3bf48f06e5f4a941509c8bafd8ce11080259",
-                "sha256:8b74bedcbbbaca38ff6d7491d76f2b06b3592611af620f8426e82dddb04a5ced"
+                "sha256:1e61c37477a1626458e36f7b1d82aa5c9b094fa4802892072e49de9c60c4c926",
+                "sha256:8abb2f1d86890a2dfb989f9a77cfcfd3e47c2a354b01111771326f8aa26e0254"
            ],
            "markers": "python_version >= '2.7' and python_version not in '3.0, 3.1, 3.2, 3.3'",
-            "version": "==1.15.0"
+            "version": "==1.16.0"
        },
        "soupsieve": {
            "hashes": [
-                "sha256:052774848f448cf19c7e959adf5566904d525f33a3f8b6ba6f6f8f26ec7de0cc",
-                "sha256:c2c1c2d44f158cdbddab7824a9af8c4f83c76b1e23e049479aa432feb6c4c23b"
+                "sha256:e2e68417777af359ec65daac1057404a3c8a5455bb8abc36f1a9866ab1a51abb",
+                "sha256:e72c4ff06e4fb6e4b5a9f0f55fe6e81514581fca1515028625d0f299c602ccc9"
            ],
-            "markers": "python_version >= '3.0'",
-            "version": "==2.2.1"
+            "markers": "python_version >= '3.8'",
+            "version": "==2.6"
+        },
+        "tconnectsync": {
+            "markers": "python_version >= '3.7'",
+            "path": "."
+        },
+        "typer": {
+            "hashes": [
+                "sha256:aa6c4a4e2329d868b80ecbaf16f807f2b54e192209d7ac9dd42691d63f7a54eb",
+                "sha256:f714c2d90afae3a7929fcd72a3abb08df305e1ff61719381384211c4070af57f"
+            ],
+            "markers": "python_version >= '3.6'",
+            "version": "==0.9.4"
+        },
+        "types-python-dateutil": {
+            "hashes": [
+                "sha256:27c8cc2d058ccb14946eebcaaa503088f4f6dbc4fb6093d3d456a49aef2753f6",
+                "sha256:9706c3b68284c25adffc47319ecc7947e5bb86b3773f843c73906fd598bc176e"
+            ],
+            "markers": "python_version >= '3.8'",
+            "version": "==2.9.0.20240906"
+        },
+        "typing-extensions": {
+            "hashes": [
+                "sha256:04e5ca0351e0f3f85c6853954072df659d0d13fac324d0072316b67d7794700d",
+                "sha256:1a7ead55c7e559dd4dee8856e3a88b41225abfe1ce8df57b7c13915fe121ffb8"
+            ],
+            "markers": "python_version >= '3.8'",
+            "version": "==4.12.2"
+        },
+        "typing-inspect": {
+            "hashes": [
+                "sha256:9ee6fc59062311ef8547596ab6b955e1b8aa46242d854bfc78f4f6b0eff35f9f",
+                "sha256:b23fc42ff6f6ef6954e4852c1fb512cdd18dbea03134f91f856a95ccc9461f78"
+            ],
+            "version": "==0.9.0"
        },
        "urllib3": {
            "hashes": [
-                "sha256:2f4da4594db7e1e110a944bb1b551fdf4e6c136ad42e4234131391e21eb5b0df",
-                "sha256:e7b021f7241115872f92f43c6508082facffbd1c048e3c6e2bb9c2a157e28937"
+                "sha256:39fb8672126159acb139a7718dd10806104dec1e2f0f6c88aab05d17df10c8d4",
+                "sha256:f57b4c16c62fa2760b7e3d97c35b255512fb6b59a259730f36ba32ce9f8e342f"
            ],
+            "index": "pypi",
            "markers": "python_version >= '2.7' and python_version not in '3.0, 3.1, 3.2, 3.3, 3.4' and python_version < '4'",
-            "version": "==1.26.4"
+            "version": "==1.26.6"
        }
    },
-    "develop": {}
+    "develop": {
+        "appdirs": {
+            "hashes": [
+                "sha256:7d5d0167b2b1ba821647616af46a749d1c653740dd0d2415100fe26e27afdf41",
+                "sha256:a841dacd6b99318a741b166adb07e19ee71a274450e68237b4650ca1055ab128"
+            ],
+            "version": "==1.4.4"
+        },
+        "jedi": {
+            "hashes": [
+                "sha256:cf0496f3651bc65d7174ac1b7d043eff454892c708a87d1b683e57b569927ffd",
+                "sha256:e983c654fe5c02867aef4cdfce5a2fbb4a50adc0af145f70504238f18ef5e7e0"
+            ],
+            "markers": "python_version >= '3.6'",
+            "version": "==0.19.1"
+        },
+        "parso": {
+            "hashes": [
+                "sha256:a418670a20291dacd2dddc80c377c5c3791378ee1e8d12bffc35420643d43f18",
+                "sha256:eb3a7b58240fb99099a345571deecc0f9540ea5f4dd2fe14c2a99d6b281ab92d"
+            ],
+            "markers": "python_version >= '3.6'",
+            "version": "==0.8.4"
+        },
+        "prompt-toolkit": {
+            "hashes": [
+                "sha256:d6623ab0477a80df74e646bdbc93621143f5caf104206aa29294d53de1a03d90",
+                "sha256:f49a827f90062e411f1ce1f854f2aedb3c23353244f8108b89283587397ac10e"
+            ],
+            "markers": "python_full_version >= '3.7.0'",
+            "version": "==3.0.48"
+        },
+        "ptpython": {
+            "hashes": [
+                "sha256:65d75c4871859e4305a020c9b9e204366dceb4d08e0e2bd7b7511bd5e917a402",
+                "sha256:b9d625183aef93a673fc32cbe1c1fcaf51412e7a4f19590521cdaccadf25186e"
+            ],
+            "index": "pypi",
+            "markers": "python_version >= '3.7'",
+            "version": "==3.0.29"
+        },
+        "pygments": {
+            "hashes": [
+                "sha256:786ff802f32e91311bff3889f6e9a86e81505fe99f2735bb6d60ae0c5004f199",
+                "sha256:b8e6aca0523f3ab76fee51799c488e38782ac06eafcf95e7ba832985c8e7b13a"
+            ],
+            "markers": "python_version >= '3.8'",
+            "version": "==2.18.0"
+        },
+        "wcwidth": {
+            "hashes": [
+                "sha256:3da69048e4540d84af32131829ff948f1e022c1c6bdb8d6102117aac784f6859",
+                "sha256:72ea0c06399eb286d978fdedb6923a9eb47e1c486ce63e9b4e64fc18303972b5"
+            ],
+            "version": "==0.2.13"
+        }
+    }
 }
@@ -1,116 +1,283 @@
 # tconnectsync

 ![Python Package workflow](https://github.com/jwoglom/tconnectsync/actions/workflows/python-package.yml/badge.svg)
+[![codecov](https://codecov.io/gh/jwoglom/tconnectsync/branch/master/graph/badge.svg)](https://codecov.io/gh/jwoglom/tconnectsync)

-Tconnectsync synchronizes data one-way from the Tandem Diabetes t:connect web/mobile application to Nightscout.
+Tconnectsync synchronizes data one-way from Tandem Source to Nightscout.

-If you have a t:slim X2 pump with the companion t:connect mobile Android or iOS app, this will allow your pump bolus and basal data to be uploaded to [Nightscout](https://github.com/nightscout/cgm-remote-monitor) automatically. The t:connect Android app, by default, uploads pump data to Tandem's servers every hour, [but using this tool you can update the frequency to as low as every five minutes](https://github.com/jwoglom/tconnectpatcher)! This allows for nearly real-time (but not instantaneous) pump data updates, almost like your pump uploads data directly to Nightscout!
+> [!IMPORTANT]
+> Tandem has announced that t:connect will be shut down in favor of Tandem Source in the US beginning September 30, 2024.
+> tconnectsync has undergone major changes to support Tandem Source. **For Tandem Source support, you MUST upgrade to tconnectsync version 2.0 or above.**

-At a high level, tconnectsync works by querying Tandem's undocumented APIs to receive basal and bolus data from t:connect, and then uploads that data as treatment objects to Nightscout. It contains features for checking for new Tandem pump data continuously, and updating that data along with the pump's reported IOB value to Nightscout whenever there is new data.
+If you have a t:slim X2 pump with the companion t:connect mobile Android or iOS app, this will allow your pump bolus and basal data to be uploaded to [Nightscout](https://github.com/nightscout/cgm-remote-monitor) automatically.
+Together with a CGM uploader, such as [xDrip+](https://github.com/NightscoutFoundation/xDrip) or the official Dexcom mobile app plus Dexcom Share, this allows your CGM _and_ pump data to be automatically uploaded to Nightscout!

-**To get started,** read the setup instructions below and choose whether to run the application via **Pipenv** or **Docker**.

-## Tandem APIs
+## How It Works

-This application utilizes three separate Tandem APIs for obtaining t:connect data, referenced here by the identifying part of their URLs:
+At a high level, tconnectsync works by querying Tandem's undocumented APIs to receive basal and bolus data from Tandem Source, and then uploads that data as treatment objects to Nightscout. It contains features for checking for new Tandem pump data continuously, and updating that data to Nightscout whenever there is new data.

-* [**controliq**](https://github.com/jwoglom/tconnectsync/blob/master/tconnectsync/api/controliq.py) - Contains Control:IQ related data, namely a timeline of all Basal events uploaded by the pump, separated by type (temp basals, algorithmically-updated basals, or profile-updated basals).
-* [**android**](https://github.com/jwoglom/tconnectsync/blob/master/tconnectsync/api/android.py) - Used internally by the t:connect Android app, these API endpoints were discovered by reverse-engineering the Android app. Most of the API endpoints are used for uploading pump data, and tconnectsync uses one endpoint which returns the most recent event ID uploaded by the pump, so we know when more data has been uploaded.
-* [**tconnectws2**](https://github.com/jwoglom/tconnectsync/blob/master/tconnectsync/api/ws2.py) - More legacy than the others, this seems to power the bulk of the main t:connect website. It is used to retrieve a CSV export of non-ControlIQ basal data, as well as bolus and IOB data. (I haven't found any mentions of bolus or IOB data in the Control:IQ-specific API.)
+When you run the program with no arguments, it performs a single cycle of the following, and exits after completion:
+
+* Logs in to Tandem Source
+* Fetches your list of pumps, and unless overridden by an environment variable, fetches the event data for the pump which was most recently used
+* Processes the internal pump event metadata to extract basal, bolus, CGM, and other pump event data
+* Queries Nightscout to find the most recent data which was uploaded to it for each event category
+* Uploads any missing data to Nightscout
+
+If run with the `--auto-update` flag, then the application periodically looks for new data and synchronizes it to Nightscout in a loop every few minutes.
+
+## What Gets Synced
+
+Tconnectsync is composed of individual so-called _synchronization features_, which are elements of data that can be
+synchronized between t:connect data from the pump and Nightscout.
+When setting up tconnectsync, you can choose to configure which synchronization features are enabled and disabled.
+
+Here are a few examples of reasons why you might want to adjust the enabled synchronization features:
+
+* If you currently input boluses into Nightscout manually with comments, then you may wish to _disable the `BOLUS` synchronization feature_ so that there are no duplicated boluses in Nightscout.
+* If you want to see Sleep and Exercise Mode data appear in Nightscout, then you may wish to _enable the `PUMP_EVENTS` synchronization feature_.
+* If you want to automatically update your Nightscout insulin profile settings from your pump, then you may wish to _enable the `PROFILES` synchronization feature_.
+
+These synchronization features are enabled by default:
+
+* `BASAL`: Basal data
+* `BOLUS`: Bolus data
+* `PUMP_EVENTS`: Events reported by the pump. Includes support for the following:
+  * Alarms, like cartridge out-of-insulin or pump malfunction
+  * Basal suspension (user or pump-initiated) and resume
+  * Cartridge, cannula, and tubing filled
+  * Sleep and exercise modes
+* `PROFILES`: Insulin profile information, including segments, basal rates, correction factors, carb ratios, and the profile which is active.
+
+The following synchronization features can be optionally enabled:
+* `CGM`: Adds Dexcom CGM readings from the pump to Nightscout as SGV (sensor glucose value) entries. This should only be used in a situation where xDrip/Dexcom Share/etc. is not used and the pump connection to the CGM will be the only source of CGM data to Nightscout. **THIS WILL DELIVER CGM DATA WITH A SIGNIFICANT (>30 MINUTE) LAG AND SHOULD NOT BE USED AS A REPLACEMENT FOR DEXCOM SHARE OR OTHER REAL TIME MONITORING.**
+
+
+To specify custom synchronization features, pass the names of the desired features to the `--features` flag, e.g.:
+
+```bash
+$ tconnectsync --features BASAL BOLUS PUMP_EVENTS PROFILES
+```
+
+If you're using tconnectsync-heroku, see [this section in its README](https://github.com/jwoglom/tconnectsync-heroku#Updating-synchronization-features).

 ## Setup

-Create a file named `.env` containing configuration values inside the checked-out tconnectsync folder (the same folder as `main.py`). You should specify the following parameters:
+The following setup instructions assume that you have a Linux, MacOS, or Windows (with WSL) machine that will run the application continuously.
+
+If you've configured Nightscout before, you may be familiar with Heroku. [You can opt to run tconnectsync with Heroku by following these instructions.](https://github.com/jwoglom/tconnectsync-heroku)
+
+**To get started,** you need to choose whether to install the application on your computer via
+**Pip**, **Pipenv**, or **Docker**.
+
+After that, you can choose to run the program continuously via **Supervisord**
+or on a regular interval with **Cron**.
+
+**NOTE:** If you fork the tconnectsync repository on GitHub, **do not commit your .env file**.
+If pushed to GitHub, this will make your tconnect and Nightscout passwords publicly visible and put your data at risk.
+
+## Installation
+
+First, you need to create a file containing configuration values.
+The name of this file will be `.env`, and its location will be dependent on which
+method of installation you choose.
+You should specify the following parameters:

 ```bash
 # Your credentials for t:connect
 TCONNECT_EMAIL='email@email.com'
 TCONNECT_PASSWORD='password'

-# Your pump's serial number (numeric)
-PUMP_SERIAL_NUMBER=11111111
-
-# URL and API secret for Nightscout
+# URL of your Nightscout site
 NS_URL='https://yournightscouturl/'
+# Your Nightscout API_SECRET value
 NS_SECRET='apisecret'

 # Current timezone of the pump
 TIMEZONE_NAME='America/New_York'
+
+# OPTIONAL: Your pump's serial number (numeric)
+PUMP_SERIAL_NUMBER=11111111
 ```

-These values can alternatively be specified via environment variables.
+This file contains your t:connect username and password, Tandem pump serial number (which is utilized in API calls to t:connect), your Nightscout URL and secret token (for uploading data to Nightscout), and local timezone (the timezone used in t:connect). When specifying the timezone, enter a [TZ database name value](https://en.wikipedia.org/wiki/List_of_tz_database_time_zones).

-The .env file contains your t:connect username and password, Tandem pump serial number (which is utilized in API calls to t:connect), your Nightscout URL and secret token (for uploading data to Nightscout), and local timezone (the timezone used in t:connect).
+(Alternatively, these values can be specified via environment variables.)

-I have only tested tconnectsync with a Tandem pump set in the US Eastern timezone. Tandem's (to us, undocumented) APIs are [a bit loose with timezones](https://github.com/jwoglom/tconnectsync/blob/master/tconnectsync/parser.py#L15), so please let me know if you notice any timezone-related bugs.
+### Installation via Pip

-When you run the program with no arguments, it performs a single cycle of the following, and exits after completion:
+This is the easiest method to install.

-* Queries for basal information via the t:connect ControlIQ API.
-* Queries for bolus, basal, and IOB data via the t:connect non-ControlIQ API.
-* Merges the basal information received from the two APIs. (If using ControlIQ, then basal information appears only on the ControlIQ API. If not using ControlIQ, it appears only on the legacy API.)
-* Queries Nightscout for the most recently created Temp Basal object by tconnectsync, and uploads all data newer than that.
-* Queries Nightscout for the most recently created Bolus object by tconnectsync, and uploads all data newer than that.
-* Uploads a single Nightscout Activity object representing the current IOB as reported by the pump.
+First, ensure that you have **Python 3** with **Pip** installed:

-If run with the `--auto-update` flag, then the application performs the following steps:
+* **On MacOS:** Open Terminal. Install [Homebrew](https://brew.sh/), and then run `brew install python3`
+* **On Linux:** Follow your distribution's specific instructions.
+  - For Debian/Ubuntu based distros, `sudo apt install python3 python3-pip`
+  - For CentOS/Rocky Linux 8:
+    - `sudo dnf install python39-pip`
+    - `sudo alternatives --set python /usr/bin/python3.9`
+* **On Windows:**
+  - **With WSL:** Install Ubuntu under the [Windows Subsystem for Linux](https://ubuntu.com/wsl).
+    Open the Ubuntu Terminal, then run `sudo apt install python3 python3-pip`.
+    Perform the remainder of the steps under the Ubuntu environment.
+  - **Native:** Alternatively, you can run tconnectsync in native Windows with no modifications. However, this is less well-tested (open a GitHub issue if you experience any problems).

-* Queries an API endpoint used only by the t:connect mobile app which returns an internal event ID, corresponding to the most recent event published by the mobile app.
-* Whenever the internal event ID changes (denoting that the mobile app uploaded new data to synchronize), perform all of the above mentioned steps to synchronize data.
+Now install the `tconnectsync` package with pip:

-### Running with Pipenv
+```
+$ pip3 install tconnectsync
+```
+To install into a user environment instead of system-wide for a more contained install:
+````
+$ pip3 install --user tconnectsync
+````
+  - This will place the tconnectsync binary file at ``/home/<username>/.local/bin/tconnectsync``
+  - For non-WSL Windows, it will be in ``<PYTHON DIRECTORY>\Lib\site-packages\tconnectsync``

-You can run the application using Pipenv. Assuming you have only Python 3 and pip installed, install pipenv with `pip3 install pipenv`. Then install tconnectsync's dependencies with `pipenv install`, and you can launch the program with `pipenv run tconnectsync` (which, through an alias defined in `Pipfile`, runs ``pipenv run python3 main.py`).
+If the pip3 command is not found, run `python3 -m pip install tconnectsync` instead.
+
+After this, you should be able to view tconnectsync's help with:
+```
+$ tconnectsync --help
+usage: tconnectsync [-h] [--version] [--pretend] [-v] [--start-date START_DATE] [--end-date END_DATE] [--days DAYS] [--auto-update] [--check-login]
+               [--features {BASAL,BOLUS,IOB,PUMP_EVENTS} [{BASAL,BOLUS,IOB,PUMP_EVENTS} ...]]
+
+Syncs bolus, basal, and IOB data from Tandem Diabetes t:connect to Nightscout.
+
+optional arguments:
+  -h, --help            show this help message and exit
+  --version             show program's version number and exit
+  --pretend             Pretend mode: do not upload any data to Nightscout.
+  -v, --verbose         Verbose mode: show extra logging details
+  --start-date START_DATE
+                        The oldest date to process data from. Must be specified with --end-date.
+  --end-date END_DATE   The newest date to process data until (inclusive). Must be specified with --start-date.
+  --days DAYS           The number of days of t:connect data to read in. Cannot be used with --from-date and --until-date.
+  --auto-update         If set, continuously checks for updates from t:connect and syncs with Nightscout.
+  --check-login         If set, checks that the provided t:connect credentials can be used to log in.
+  --features {BASAL,BOLUS,IOB,PUMP_EVENTS} [{BASAL,BOLUS,IOB,PUMP_EVENTS} ...]
+                        Specifies what data should be synchronized between tconnect and Nightscout.
+```
+
+Move the `.env` file you created to the following folder:
+
+* **MacOS:** `/Users/<username>/.config/tconnectsync/.env`
+* **Linux:** `$HOME/.config/tconnectsync/.env`
+* **Windows:** `$HOME/.config/tconnectsync/.env` (inside WSL) OR `C:\Users\<username>\.config\tconnectsync` (native Windows)
+
+```
+$ tconnectsync --check-login
+```
+
+If you receive no errors, then you can move on to the **Running Tconnectsync Continuously** section.
+
+### Installing with Pipenv
+
+You can run the application using Pipenv.
+
+First, ensure you have Python 3 and pip installed, then install pipenv with `pip3 install pipenv`.
+
+Clone the Git repository for tconnectsync and cd into it with:
+```
+$ git clone https://github.com/jwoglom/tconnectsync
+$ cd tconnectsync
+```
+
+Then install tconnectsync's dependencies with `pipenv install`.
+Afterwards, you can launch the program with `pipenv run tconnectsync` so long as
+you are inside the checked-out tconnectsync folder.

 ```bash
 $ git clone https://github.com/jwoglom/tconnectsync && cd tconnectsync
 $ pip3 install pipenv
 $ pipenv install
 $ pipenv run tconnectsync --help
-usage: main.py [-h] [--pretend] [--start-date START_DATE] [--end-date END_DATE]
-               [--days DAYS] [--auto-update]
+usage: main.py [-h] [--version] [--pretend] [-v] [--start-date START_DATE] [--end-date END_DATE] [--days DAYS] [--auto-update] [--check-login]
+               [--features {BASAL,BOLUS,IOB,PUMP_EVENTS} [{BASAL,BOLUS,IOB,PUMP_EVENTS} ...]]

 Syncs bolus, basal, and IOB data from Tandem Diabetes t:connect to Nightscout.

 optional arguments:
  -h, --help            show this help message and exit
+  --version             show program's version number and exit
  --pretend             Pretend mode: do not upload any data to Nightscout.
+  -v, --verbose         Verbose mode: show extra logging details
  --start-date START_DATE
-                        The oldest date to process data from. Must be specified with
-                        --end-date.
-  --end-date END_DATE   The newest date to process data until (inclusive). Must be
-                        specified with --start-date.
-  --days DAYS           The number of days of t:connect data to read in. Cannot be
-                        used with --from-date and --until-date.
-  --auto-update         If set, continuously checks for updates from t:connect and
-                        syncs with Nightscout.
+                        The oldest date to process data from. Must be specified with --end-date.
+  --end-date END_DATE   The newest date to process data until (inclusive). Must be specified with --start-date.
+  --days DAYS           The number of days of t:connect data to read in. Cannot be used with --from-date and --until-date.
+  --auto-update         If set, continuously checks for updates from t:connect and syncs with Nightscout.
+  --check-login         If set, checks that the provided t:connect credentials can be used to log in.
+  --features {BASAL,BOLUS,IOB,PUMP_EVENTS} [{BASAL,BOLUS,IOB,PUMP_EVENTS} ...]
+                        Specifies what data should be synchronized between tconnect and Nightscout.
 ```

-You can now continue to either the **Running with Cron** or **Running with Supervisord** sections.

-### Running with Docker
+Move the `.env` file you created earlier into the `tconnectsync` folder, and run:
+
+```
+$ pipenv run tconnectsync --check-login
+```
+
+If you receive no errors, then you can move on to the **Running Tconnectsync Continuously** section.
+
+### Installing with Docker

 First, [ensure that you have Docker running and installed](https://docs.docker.com/get-started/#download-and-install-docker).

-To download and run the `jwoglom/tconnectsync` prebuilt Docker image from [Docker Hub](https://hub.docker.com/r/jwoglom/tconnectsync):
+To download and run the prebuilt Docker image from GitHub Packages:

 ```bash
-$ docker pull jwoglom/tconnectsync:latest
-$ docker run jwoglom/tconnectsync --help
+$ docker pull ghcr.io/jwoglom/tconnectsync/tconnectsync:latest
+$ docker run ghcr.io/jwoglom/tconnectsync/tconnectsync --help
 ```

+Move the `.env` file you created earlier into the current folder, and run:
+
+```
+$ docker run tconnectsync --check-login
+```
+
+If you receive no errors, then you can move on to the **Running Tconnectsync Continuously** section.
+
+
+#### Building Locally
+
 To instead build the image locally and launch the project:

 ```bash
 $ git clone https://github.com/jwoglom/tconnectsync
+$ cd tconnectsync
 $ docker build -t tconnectsync .
 $ docker run tconnectsync --help
 ```

-You can now continue to either the **Running with Cron** or **Running with Supervisord** sections.
+Move the `.env` file you created earlier into this folder, and run:
+```
+$ docker run --env-file=.env tconnectsync --check-login
+```
+
+**NOTE:** If using the `--env-file` option to `docker run`, you may need to remove all quotation marks (`'` and `"`s) around values in the `.env` file for Docker to propagate the variables correctly.
+
+If you receive no errors, then you can move on to the **Running Tconnectsync Continuously** section.
+
+## Running Tconnectsync Continuously
+
+You most likely want tconnectsync to run either continuously (via the auto-update
+feature) or on a regular interval (via cron).
+
+The supervisord approach is recommended for simplicity.

 ### Running with Supervisord (recommended)
-To instead configure tconnectsync to run continuously in the background using its `--auto-update` feature, you can use a tool such as Supervisord. Here is an example `tconnectsync.conf` which you can place inside `/etc/supervisor/conf.d`:
+To configure tconnectsync to run continuously in the background using its `--auto-update` feature, you can use a tool such as Supervisord.
+
+First, install supervisord via your Linux system's package manager.
+(For example, for Ubuntu/Debian-based systems, run `sudo apt install supervisor`)
+
+Supervisord is configured by creating a configuration file in `/etc/supervisor/conf.d`.
+
+Here is an example `tconnectsync.conf` which you can place in that folder:

 ```
 [program:tconnectsync]
@@ -118,12 +285,63 @@ command=/path/to/tconnectsync/run.sh
 directory=/path/to/tconnectsync/
 stderr_logfile=/path/to/tconnectsync/stderr.log
 stdout_logfile=/path/to/tconnectsync/stdout.log
-user=tconnectsync
+user=<your username>
 numprocs=1
 autostart=true
 autorestart=true
 ```

+In order to create a `run.sh` file, see the section below which aligns with your
+choice of installation method.
+
+After the configuration file has been created, ensure that Supervisor is running
+and configured to start on boot:
+
+```bash
+$ sudo systemctl daemon-reload
+$ sudo systemctl start supervisord
+$ sudo systemctl enable supervisord
+```
+
+Then use the `supervisorctl` command to manage the status of the tconnectsync program:
+
+```bash
+$ sudo supervisorctl status
+tconnectsync                     STOPPED
+$ sudo supervisorctl start tconnectsync
+$ sudo supervisorctl status
+tconnectsync                     RUNNING   pid 18810, uptime 00:00:05
+```
+
+You can look at the `stderr.log` and `stdout.log` files to check that tconnectsync
+is running and has started up properly:
+```bash
+$ tail -f /path/to/tconnectsync/stdout.log
+Starting auto-update between 2021-09-30 00:06:39.942273 and 2021-10-01 00:06:39.942273
+2021-10-01 00:06:39 DEBUG    Instantiating new AndroidApi
+2021-10-01 00:06:39 DEBUG    Starting new HTTPS connection (1): tdcservices.tandemdiabetes.com:443
+2021-10-01 00:06:40 DEBUG    https://tdcservices.tandemdiabetes.com:443 "POST /cloud/oauth2/token HTTP/1.1" 200 404
+2021-10-01 00:06:40 INFO     Logged in to AndroidApi successfully (expiration: 2021-10-01T08:06:40.362Z, in 7 hours, 59 minutes)
+```
+
+#### With Pip Installation
+
+In the `tconnectsync.conf`, you should set `/path/to/tconnectsync` to the folder
+containing your `.env` file.
+
+Create a `run.sh` file containing:
+
+```bash
+#!/bin/bash
+
+tconnectsync --auto-update
+```
+
+#### With Pipenv Installation
+
+In the `tconnectsync.conf`, you should set `/path/to/tconnectsync` to the folder
+where you checked-out the GitHub repository.
+
 An example `run.sh` which launches tconnectsync within its pipenv-configured virtual environment:

 ```bash
@@ -138,29 +356,72 @@ cd /path/to/tconnectsync
 exec python3 -u main.py --auto-update
 ```

-An example `run.sh` which uses Docker:
+#### With Docker Installation
+
+In the `tconnectsync.conf`, you should set `/path/to/tconnectsync` to the folder
+where you checked-out the GitHub repository.
+
+An example `run.sh` if you installed tconnectsync via the GitHub Docker Registry:
+
+```bash
+#!/bin/bash
+
+docker run ghcr.io/jwoglom/tconnectsync/tconnectsync --auto-update
+```
+
+An example `run.sh` if you built tconnectsync locally:

 ```bash
 #!/bin/bash

-docker build -t tconnectsync
 docker run tconnectsync --auto-update
 ```

 ### Running with Cron
-To configure tconnectsync to run at a periodic interval (i.e. every 15 minutes), you can just invoke main.py with no arguments via cron.
+
+If you choose not to run tconnectsync with `--auto-update` continuously,
+you can instead run it at a periodic interval (i.e. every 15 minutes) by just
+invoking tconnectsync with no arguments via cron.

 If using Pipenv or a virtualenv, make sure that you either prefix the call to main.py with `pipenv run` or source the `bin/activate` file within the virtualenv, so that the proper dependencies are loaded. If not using any kind of virtualenv, you can instead just install the necessary dependencies as specified inside Pipfile globally.

-An example configuration in `/etc/crontab` which runs every 15 minutes:
+An system-wide example configuration in `/etc/crontab` which runs every 15 minutes, on the 15 minute mark:

 ```bash
 # m         h  dom mon dow user   command
 0,15,30,45  *  *   *   *   root   /path/to/tconnectsync/run.sh
 ```

-You can use one of the same `run.sh` files mentioned above in the Supervisord example, but remove the `--auto-update` flag since you are handling the functionality for running the script periodically yourself.
+An example of a user crontab `crontab -e` if not running system-wide, which runs every 15 minutes:
+```
+*/15 * * * * /path/to/tconnectsync/run.sh
+```

+You can use one of the same `run.sh` files referenced above, but remove the `--auto-update` flag since you are handling the functionality for running the script periodically yourself.
+
+### For Native Windows
+
+Create a batch file 'tconnectsync.bat' file containing:
+
+```
+python "C:\Users\<USERNAME>\AppData\Local\Programs\Python\<PYTHONVERSIONDIRECTORY>\Lib\site-packages\tconnectsync\main.py" --auto-update
+```
+
+If `python` does not exist in your path, specify the full path to `python.exe`.
+
+If main.py doesn't exist in `C:\Users\<USERNAME>\AppData\Local\Programs\Python\<PYTHONVERSIONDIRECTORY>\Lib\site-packages\tconnectsync\`, create it to match the copy in this repository.
+
+[Use Windows Task Scheduler](https://www.windowscentral.com/how-create-automated-task-using-task-scheduler-windows-10) to run this batch file on a scheduled basis.
+
+## Tandem APIs
+
+This application utilizes three separate Tandem APIs for obtaining t:connect data, referenced here by the identifying part of their URLs:
+
+* [**controliq**](https://github.com/jwoglom/tconnectsync/blob/master/tconnectsync/api/controliq.py) - Contains Control:IQ related data, namely a timeline of all Basal events uploaded by the pump, separated by type (temp basals, algorithmically-updated basals, or profile-updated basals). Additionally includes CGM and Bolus data.
+* [**android**](https://github.com/jwoglom/tconnectsync/blob/master/tconnectsync/api/android.py) - Used internally by the t:connect Android app, these API endpoints were discovered by reverse-engineering the Android app. Most of the API endpoints are used for uploading pump data, and tconnectsync uses one endpoint which returns the most recent event ID uploaded by the pump, so we know when more data has been uploaded.
+* [**tconnectws2**](https://github.com/jwoglom/tconnectsync/blob/master/tconnectsync/api/ws2.py) - More legacy than the others, this seems to power the bulk of the main t:connect website. It is used as a last resort due to severe performance issues with this API (see https://github.com/jwoglom/tconnectsync/issues/43). We can use it to retrieve a CSV export of non-ControlIQ basal data, as well as bolus and IOB data. It is only used for bolus data as a fallback, and for pump-reported IOB data if requested. Full tracking of pump events also uses a limited version of this API.
+
+I have only tested tconnectsync with a Tandem pump set in the US Eastern timezone. Tandem's (to us, undocumented) APIs are [a bit loose with timezones](https://github.com/jwoglom/tconnectsync/blob/master/tconnectsync/parser.py#L15), so please let me know if you notice any timezone-related bugs.
 ## Backfilling t:connect Data

 To backfill existing t:connect data in to Nightscout, you can use the `--start-date` and `--end-date` options. For example, the following will upload all t:connect data between January 1st and March 1st, 2020 to Nightscout:
@@ -172,3 +433,15 @@ python3 main.py --start-date 2020-01-01 --end-date 2020-03-01
 In order to bulk-import a lot of data, you may need to use shorter intervals, and invoke tconnectsync multiple times. Tandem's API endpoints occasionally return invalid data if you request too large of a data window which causes tconnectsync to error out mid-way through.

 One oddity when backfilling data is that the Control:IQ specific API endpoints return errors if they are queried before you updated your pump to utilize Control:IQ. This is [partially worked around in tconnectsync's code](https://github.com/jwoglom/tconnectsync/blob/d841c3811aeff3671d941a7d3ff4b80cce6a219e/main.py#L238), but you might need to update the logic if you did not switch to a Control:IQ enabled pump immediately after launch.
+
+## t:connect API Testing
+
+To test t:connect API endpoints in a Python shell, you can do something like the following:
+
+```python
+import tconnectsync
+tconnectsync.util.cli.enable_logging()
+api = tconnectsync.util.cli.get_api()
+# Make API calls, e.g.
+therapy_timeline = api.controliq.therapy_timeline('2022-08-01', '2022-08-10')
+```
@@ -0,0 +1,6 @@
+coverage:
+  status:
+    project:
+      default:
+        target: 50%
+        threshold: null
@@ -1,69 +1,5 @@
 #!/usr/bin/env python3
-
-import sys
-import datetime
-import arrow
-import argparse
-
-from tconnectsync.api import TConnectApi
-from tconnectsync.process import process_time_range
-from tconnectsync.autoupdate import process_auto_update
-from tconnectsync.check import check_login
-from tconnectsync.nightscout import NightscoutApi
-
-try:
-    from tconnectsync.secret import (
-        TCONNECT_EMAIL,
-        TCONNECT_PASSWORD,
-        NS_URL,
-        NS_SECRET
-    )
-except Exception:
-    print('Unable to read secret.py')
-    sys.exit(1)
-
-
-def parse_args():
-    parser = argparse.ArgumentParser(description="Syncs bolus, basal, and IOB data from Tandem Diabetes t:connect to Nightscout.")
-    parser.add_argument('--pretend', dest='pretend', action='store_const', const=True, default=False, help='Pretend mode: do not upload any data to Nightscout.')
-    parser.add_argument('--start-date', dest='start_date', type=str, default=None, help='The oldest date to process data from. Must be specified with --end-date.')
-    parser.add_argument('--end-date', dest='end_date', type=str, default=None, help='The newest date to process data until (inclusive). Must be specified with --start-date.')
-    parser.add_argument('--days', dest='days', type=int, default=1, help='The number of days of t:connect data to read in. Cannot be used with --from-date and --until-date.')
-    parser.add_argument('--auto-update', dest='auto_update', action='store_const', const=True, default=False, help='If set, continuously checks for updates from t:connect and syncs with Nightscout.')
-    parser.add_argument('--check-login', dest='check_login', action='store_const', const=True, default=False, help='If set, checks that the provided t:connect credentials can be used to log in.')
-
-    return parser.parse_args()
-
-def main():
-    args = parse_args()
-
-    if args.auto_update and (args.start_date or args.end_date):
-        raise Exception('Auto-update cannot be used with start/end date')
-
-    if args.start_date and args.end_date:
-        time_start = arrow.get(args.start_date)
-        time_end = arrow.get(args.end_date)
-    else:
-        time_end = datetime.datetime.now()
-        time_start = time_end - datetime.timedelta(days=args.days)
-
-    if time_end < time_start:
-        raise Exception('time_start must be before time_end')
-
-    tconnect = TConnectApi(TCONNECT_EMAIL, TCONNECT_PASSWORD)
-
-    nightscout = NightscoutApi(NS_URL, NS_SECRET)
-
-    if args.check_login:
-        return check_login(tconnect, time_start, time_end)
-
-    if args.auto_update:
-        print("Starting auto-update between", time_start, "and", time_end, "(PRETEND)" if args.pretend else "")
-        process_auto_update(tconnect, nightscout, time_start, time_end, args.pretend)
-    else:
-        print("Processing data between", time_start, "and", time_end, "(PRETEND)" if args.pretend else "")
-        added = process_time_range(tconnect, nightscout, time_start, time_end, args.pretend)
-        print("Added", added, "items")
+from tconnectsync import main

 if __name__ == '__main__':
    main()
@@ -0,0 +1,6 @@
+[build-system]
+requires = [
+    "setuptools>=42",
+    "wheel"
+]
+build-backend = "setuptools.build_meta"
@@ -0,0 +1,37 @@
+[metadata]
+name = tconnectsync
+version = 2.0.1
+author = James Woglom
+author_email = j@wogloms.net
+description = Syncs Tandem t:connect pump data to Nightscout for the t:slim X2
+long_description = file: README.md
+long_description_content_type = text/markdown
+url = https://github.com/jwoglom/tconnectsync
+project_urls =
+    Bug Tracker = https://github.com/jwoglom/tconnectsync/issues
+classifiers =
+    Programming Language :: Python :: 3
+    License :: OSI Approved :: MIT License
+    Operating System :: OS Independent
+
+[options]
+package_dir =
+    = .
+packages = find:
+python_requires = >=3.7
+install_requires =
+    requests
+    bs4
+    arrow
+    lxml
+    python-dotenv
+
+[options.packages.find]
+where = .
+exclude =
+    tests*
+    scripts*
+
+[options.entry_points]
+console_scripts =
+    tconnectsync = tconnectsync:main
@@ -0,0 +1,3 @@
+from setuptools import setup
+
+setup()
@@ -0,0 +1,119 @@
+import sys
+import datetime
+import arrow
+import argparse
+import logging
+import pkg_resources
+
+from .api import TConnectApi
+from .process import process_time_range
+from .autoupdate import Autoupdate
+from .sync.tandemsource.autoupdate import TandemSourceAutoupdate
+from .sync.tandemsource.choose_device import ChooseDevice as TandemSourceChooseDevice
+from .sync.tandemsource.process import ProcessTimeRange as TandemSourceProcessTimeRange
+from .check import check_login
+from .nightscout import NightscoutApi
+from .features import DEFAULT_FEATURES, ALL_FEATURES
+
+try:
+    from .secret import (
+        TCONNECT_EMAIL,
+        TCONNECT_PASSWORD,
+        NS_URL,
+        NS_SECRET,
+        NS_SKIP_TLS_VERIFY,
+        PUMP_SERIAL_NUMBER,
+        NS_IGNORE_CONN_ERRORS
+    )
+    from . import secret
+except Exception as e:
+    print('Unable to read secrets from secret.py', e)
+    sys.exit(1)
+
+
+try:
+    __version__ = pkg_resources.require("tconnectsync")[0].version
+except Exception:
+    __version__ = "UNKNOWN"
+
+def parse_args(*args, **kwargs):
+    parser = argparse.ArgumentParser(description="Syncs bolus, basal, and IOB data from Tandem Diabetes t:connect to Nightscout.", epilog="Version %s" % __version__)
+    parser.add_argument('--version', action='version', version='tconnectsync %s' % __version__)
+    parser.add_argument('--pretend', dest='pretend', action='store_const', const=True, default=False, help='Pretend mode: do not upload any data to Nightscout.')
+    parser.add_argument('-v', '--verbose', dest='verbose', action='store_const', const=True, default=False, help='Verbose mode: show extra logging details')
+    parser.add_argument('--start-date', dest='start_date', type=str, default=None, help='The oldest date to process data from. Must be specified with --end-date.')
+    parser.add_argument('--end-date', dest='end_date', type=str, default=None, help='The newest date to process data until (inclusive). Must be specified with --start-date.')
+    parser.add_argument('--days', dest='days', type=int, default=1, help='The number of days of t:connect data to read in. Cannot be used with --from-date and --until-date.')
+    parser.add_argument('--auto-update', dest='auto_update', action='store_const', const=True, default=False, help='If set, continuously checks for updates from t:connect and syncs with Nightscout.')
+    parser.add_argument('--check-login', dest='check_login', action='store_const', const=True, default=False, help='If set, checks that the provided t:connect credentials can be used to log in.')
+    parser.add_argument('--features', dest='features', nargs='+', default=DEFAULT_FEATURES, choices=ALL_FEATURES, help='Specifies what data should be synchronized between tconnect and Nightscout.')
+    parser.add_argument('--tandem-source', dest='tandem_source', action='store_const', const=True, default=False, help='FOR TESTING: Use Tandem Source')
+
+    return parser.parse_args(*args, **kwargs)
+
+def main(*args, **kwargs):
+    args = parse_args(*args, **kwargs)
+
+    if args.verbose:
+        logging.basicConfig(
+            level=logging.DEBUG,
+            format='%(asctime)s %(levelname)-8s %(message)s',
+            datefmt='%Y-%m-%d %H:%M:%S')
+        logging.root.debug("Set logging level to DEBUG")
+    else:
+        logging.basicConfig(
+            level=logging.INFO,
+            format='%(asctime)s %(levelname)-8s %(message)s',
+            datefmt='%Y-%m-%d %H:%M:%S')
+
+    if args.auto_update and (args.start_date or args.end_date):
+        raise Exception('Auto-update cannot be used with start/end date')
+
+    if args.start_date and args.end_date:
+        time_start = arrow.get(args.start_date)
+        time_end = arrow.get(args.end_date)
+    else:
+        time_end = datetime.datetime.now()
+        time_start = time_end - datetime.timedelta(days=args.days)
+
+    if time_end < time_start:
+        raise Exception('time_start must be before time_end')
+
+
+    if TCONNECT_EMAIL == 'email@email.com':
+        logging.warn('NO USERNAME WAS PROVIDED. Ensure you have set TCONNECT_EMAIL appropriately.')
+    if TCONNECT_PASSWORD == 'password':
+        logging.warn('NO PASSWORD WAS PROVIDED. Ensure you have set TCONNECT_PASSWORD appropriately.')
+    if NS_URL == 'https://yournightscouturl/':
+        logging.warn('NO NIGHTSCOUT URL WAS PROVIDED. Ensure your have set NS_URL appropriately.')
+    if PUMP_SERIAL_NUMBER == '11111111':
+        if args.tandem_source:
+            secret.PUMP_SERIAL_NUMBER = None
+        else:
+            logging.warn('NO PUMP SERIAL NUMBER WAS PROVIDED. Ensure you have set PUMP_SERIAL_NUMBER appropriately.')
+
+    tconnect = TConnectApi(TCONNECT_EMAIL, TCONNECT_PASSWORD)
+
+    nightscout = NightscoutApi(NS_URL, NS_SECRET, skip_verify=NS_SKIP_TLS_VERIFY, ignore_conn_errors=NS_IGNORE_CONN_ERRORS)
+
+    # NOT YET MIGRATED
+    # if args.check_login:
+    #     return check_login(tconnect, time_start, time_end)
+
+    logging.warning("THIS VERSION OF TCONNECTSYNC READS DATA FROM TANDEM SOURCE, AND MAY CONTAIN BUGS!")
+    logging.info("You may notice different behavior compared to older versions which utilized t:connect data sources.")
+    logging.info("To report a bug or to get help, see https://github.com/jwoglom/tconnectsync/issues")
+
+    logging.info("Enabled features: " + ", ".join(args.features))
+
+    if args.check_login:
+        args.pretend = True
+
+    if args.auto_update:
+        u = TandemSourceAutoupdate(secret)
+        sys.exit(u.process(tconnect, nightscout, time_start, time_end, args.pretend, features=args.features))
+    else:
+        tconnectDevice = TandemSourceChooseDevice(secret, tconnect).choose()
+        added = TandemSourceProcessTimeRange(tconnect, nightscout, tconnectDevice, pretend=args.pretend, features=args.features).process(time_start, time_end)
+        sys.exit(added)
+
@@ -1,19 +1,36 @@
+import logging
+
 from .android import AndroidApi
 from .controliq import ControlIQApi
 from .ws2 import WS2Api
+from .webui import WebUIScraper
+from .tandemsource import TandemSourceApi
+
+logger = logging.getLogger(__name__)

 """A wrapper for the three different t:connect API types."""
 class TConnectApi:
    email = None
    password = None

-    _ciq = None
-    _ws2 = None
-    _android = None
-
    def __init__(self, email, password):
        self.email = email
        self.password = password
+        self._ciq = None
+        self._ws2 = None
+        self._android = None
+        self._webui = None
+        self._tandemsource = None
+
+    @property
+    def tandemsource(self):
+        if self._tandemsource and not self._tandemsource.needs_relogin():
+            return self._tandemsource
+
+        logger.debug("Instantiating new TandemSourceApi")
+
+        self._tandemsource = TandemSourceApi(self.email, self.password)
+        return self._tandemsource


    @property
@@ -21,6 +38,8 @@ class TConnectApi:
        if self._ciq and not self._ciq.needs_relogin():
            return self._ciq

+        logger.debug("Instantiating new ControlIQApi")
+
        self._ciq = ControlIQApi(self.email, self.password)
        return self._ciq

@@ -29,6 +48,12 @@ class TConnectApi:
        if self._ws2:
            return self._ws2

+        logger.debug("Instantiating new WS2Api")
+
+        # Trigger login or re-login via controliq api if necessary
+        # so userGuid can be accessed from it
+        self.controliq
+
        self._ws2 = WS2Api(self._ciq.userGuid)
        return self._ws2

@@ -37,6 +62,18 @@ class TConnectApi:
        if self._android and not self._android.needs_relogin():
            return self._android

+        logger.debug("Instantiating new AndroidApi")
+
        self._android = AndroidApi(self.email, self.password)
        return self._android
+    
+    @property
+    def webui(self):
+        if self._webui and not self._webui.needs_relogin():
+            return self._webui
+        
+        logger.debug("Instantiating new WebUIScraper")
+
+        self._webui = WebUIScraper(self.controliq)
+        return self._webui

@@ -5,10 +5,15 @@ import datetime
 import csv
 import base64
 import arrow
+import time
+import logging

 from bs4 import BeautifulSoup

-from .common import ApiException, ApiLoginException
+from ..util import timeago
+from .common import ApiException, ApiLoginException, parse_date, base_session
+
+logger = logging.getLogger(__name__)

 """
 The AndroidApi class contains methods which are queried in the t:connect
@@ -24,6 +29,12 @@ class AndroidApi:
    ANDROID_API_USERNAME = base64.b64decode('QzIzMzFDRDYtRDQ1MC00OTVFLTlDMTktNjcyMTUyMzBDODVD').decode()
    ANDROID_API_PASSWORD = base64.b64decode('dHo0MzNLVzVRREM5VjdmIXo2QF4ybyZZNlNHR1lo').decode()

+    # These credentials are used by tconnect web
+    TCONNECT_WEB_USERNAME = base64.b64decode('M0U2MzU3QkEtRjYyNS00REQyLUI2NUYtNEI1RTgxNDRBQTZG').decode()
+    TCONNECT_WEB_PASSWORD = base64.b64decode('cUMyaXFIc2w3OFFoR0RYdCpMenFwb1pxZTl3eHN6').decode()
+
+    ANDROID_USER_AGENT = 'Dalvik/2.1.0 (Linux; U; Android 12; Pixel 4a Build/SP2A.220305.012)'
+
    # These tokens are separate from the "standard" tdcservices API
    accessToken = None
    accessTokenExpiresAt = None
@@ -33,10 +44,13 @@ class AndroidApi:
    patientObjectId = None

    def __init__(self, email, password):
+        self.session = base_session()
        self.login(email, password)
+        self._email = email
+        self._password = password

    def login(self, email, password):
-        r = requests.post(
+        r = self.session.post(
            self.BASE_URL + self.OAUTH_TOKEN_PATH,
            {
                'username': email,
@@ -44,7 +58,10 @@ class AndroidApi:
                'grant_type': 'password',
                'scope': self.OAUTH_SCOPES
            },
-            headers={'Content-Type': 'application/x-www-form-urlencoded'},
+            headers={
+                'Content-Type': 'application/x-www-form-urlencoded; charset=UTF-8',
+                'User-Agent': self.ANDROID_USER_AGENT
+            },
            auth=requests.auth.HTTPBasicAuth(self.ANDROID_API_USERNAME, self.ANDROID_API_PASSWORD)
        )

@@ -52,17 +69,20 @@ class AndroidApi:
            raise ApiLoginException(r.status_code, 'Received HTTP %s during login: %s' % (r.status_code, r.text))

        j = r.json()
-        if "user" not in j or not j["user"]:
-            raise ApiException(r.status_code, 'No user details present in AndroidApi oauth response: %s' % r.text)
+        # tconnect web returns a null user
+        # if "user" not in j or not j["user"]:
+        #     raise ApiException(r.status_code, 'No user details present in AndroidApi oauth response: %s' % r.text)

        self.accessToken = j["accessToken"]
        self.accessTokenExpiresAt = j["accessTokenExpiresAt"]
        # NOTE: the refresh token is currently unused, instead a new access
        # token is obtained from scratch by re-logging in when it expires.
-        self.refreshToken = j["refreshToken"]
-        self.refreshTokenExpiresAt = j["refreshTokenExpiresAt"]
+        if "refreshToken" in j and "refreshTokenExpiresAt" in j:
+            self.refreshToken = j["refreshToken"]
+            self.refreshTokenExpiresAt = j["refreshTokenExpiresAt"]
        self.userId = j["user"]["id"]
-        self.patientObjectId = j["user"]["patientObjectId"]
+
+        logger.info("Logged in to AndroidApi successfully (expiration: %s, %s)" % (self.accessTokenExpiresAt, timeago(self.accessTokenExpiresAt)))

    def needs_relogin(self):
        diff = (arrow.get(self.accessTokenExpiresAt) - arrow.get())
@@ -73,14 +93,39 @@ class AndroidApi:
            raise Exception('No access token')
        return {'Authorization': 'Bearer %s' % self.accessToken}

-    def get(self, endpoint, query={}, **kwargs):
-        r = requests.get(self.BASE_URL + endpoint, query, headers=self.api_headers(), **kwargs)
+    def _get(self, endpoint, query={}, **kwargs):
+        r = self.session.get(self.BASE_URL + endpoint, data=query, headers={
+            'User-Agent': self.ANDROID_USER_AGENT,
+            'Content-Type': 'application/json',
+            **self.api_headers()
+        }, **kwargs)
+
        if r.status_code != 200:
-            raise ApiException(r.status_code, "Internal API HTTP %s response: %s" % (str(r.status_code), r.text))
+            raise ApiException(r.status_code, "Android API HTTP %s response: %s" % (str(r.status_code), r.text))
        return r.json()

+    def get(self, endpoint, query={}, tries=0, **kwargs):
+        try:
+            return self._get(endpoint, query, **kwargs)
+        except ApiException as e:
+            if tries > 0:
+                raise ApiException(e.status_code, "Android API HTTP %s on retry #%d: %s" % (e.status_code, tries, e))
+
+            # Trigger automatic re-login, and try again once
+            if e.status_code == 401:
+                self.accessTokenExpiresAt = time.time()
+                self.login(self._email, self._password)
+
+                return self.get(endpoint, query, tries=tries+1, **kwargs)
+
+            if e.status_code == 500:
+                return self.get(endpoint, query, tries=tries+1, **kwargs)
+
+            raise e
+
+
    def post(self, endpoint, query={}, **kwargs):
-        r = requests.post(self.BASE_URL + endpoint, query, headers=self.api_headers(), **kwargs)
+        r = self.session.post(self.BASE_URL + endpoint, query, headers=self.api_headers(), **kwargs)
        if r.status_code != 200:
            raise ApiException(r.status_code, "Internal API HTTP %s response: %s" % (str(r.status_code), r.text))
        return r.json()
@@ -105,6 +150,9 @@ class AndroidApi:
    # TODO: these methods are used in the web app, not the Android app,
    # but support the same auth tokens and are on this domain. They should
    # be moved to a new Api class.
+    # 3/17/2022: the API appears to be more stringently checking scopes,
+    # and some of these endpoints no longer work with the API token scoped
+    # to the Android app.

    """
    Returns BG and pump threshold values.
@@ -1,17 +1,138 @@
 import datetime
+from typing import List, Tuple
+import requests
+import random
+import arrow
+
+from tconnectsync import secret

 def parse_date(date):
    if type(date) == str:
        return date
    return (date or datetime.datetime.now()).strftime('%m-%d-%Y')

+def parse_ymd_date(date):
+    if type(date) == str:
+        date = arrow.get(date)
+    return (date or datetime.datetime.now()).strftime('%Y-%m-%d')
+
+def parsed_date_to_arrow(date):
+    return arrow.get(datetime.datetime.strptime(date, '%m-%d-%Y'))
+
+USER_AGENTS = [
+    'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_11_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/102.0.0.0 Safari/537.36',
+    'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_2) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/79.0.3945.88 Safari/537.36',
+    'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/100.0.4896.127 Safari/537.36',
+    'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/101.0.0.0 Safari/537.36',
+    'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/101.0.4951.54 Safari/537.36',
+    'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/101.0.4951.64 Safari/537.36',
+    'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/102.0.0.0 Safari/537.36',
+    'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/102.0.5005.115 Safari/537.36',
+    'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/102.0.5005.61 Safari/537.36',
+    'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/15.1 Safari/605.1.15',
+    'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/15.3 Safari/605.1.15',
+    'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/15.4 Safari/605.1.15',
+    'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/15.5 Safari/605.1.15',
+    'Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:100.0) Gecko/20100101 Firefox/100.0',
+    'Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:101.0) Gecko/20100101 Firefox/101.0',
+    'Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:102.0) Gecko/20100101 Firefox/102.0',
+    'Mozilla/5.0 (Windows NT 10.0; rv:91.0) Gecko/20100101 Firefox/91.0',
+    'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/100.0.4896.127 Safari/537.36',
+    'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/100.0.4896.127 Safari/537.36 OPR/86.0.4363.64',
+    'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/100.0.4896.127 Safari/537.36 OPR/86.0.4363.70',
+    'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/100.0.4896.75 Safari/537.36',
+    'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/101.0.0.0 Safari/537.36',
+    'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/101.0.4951.54 Safari/537.36',
+    'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/101.0.4951.64 Safari/537.36',
+    'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/101.0.4951.64 Safari/537.36 Edg/101.0.1210.47',
+    'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/101.0.4951.64 Safari/537.36 Edg/101.0.1210.53',
+    'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/101.0.4951.67 Safari/537.36',
+    'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/101.0.4951.67 Safari/537.36 OPR/87.0.4390.45',
+    'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/102.0.0.0 Safari/537.36',
+    'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/102.0.5005.115 Safari/537.36',
+    'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/102.0.5005.124 Safari/537.36 Edg/102.0.1245.41',
+    'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/102.0.5005.124 Safari/537.36 Edg/102.0.1245.44',
+    'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/102.0.5005.61 Safari/537.36',
+    'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/102.0.5005.62 Safari/537.36',
+    'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/102.0.5005.63 Safari/537.36',
+    'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/102.0.5005.63 Safari/537.36 Edg/102.0.1245.30',
+    'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/102.0.5005.63 Safari/537.36 Edg/102.0.1245.33',
+    'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/102.0.5005.63 Safari/537.36 Edg/102.0.1245.39',
+    'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/103.0.0.0 Safari/537.36',
+    'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/99.0.4844.84 Safari/537.36 OPR/85.0.4341.71',
+    'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:100.0) Gecko/20100101 Firefox/100.0',
+    'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:101.0) Gecko/20100101 Firefox/101.0',
+    'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:102.0) Gecko/20100101 Firefox/102.0',
+    'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101 Firefox/91.0',
+    'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:99.0) Gecko/20100101 Firefox/99.0',
+    'Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/102.0.0.0 Safari/537.36',
+    'Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/86.0.4240.198 Safari/537.36',
+    'Mozilla/5.0 (Windows NT 6.1; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/102.0.0.0 Safari/537.36',
+    'Mozilla/5.0 (Windows NT 6.1; Win64; x64; rv:100.0) Gecko/20100101 Firefox/100.0',
+    'Mozilla/5.0 (Windows NT 6.1; Win64; x64; rv:101.0) Gecko/20100101 Firefox/101.0',
+    'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/100.0.4896.127 Safari/537.36',
+    'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/101.0.0.0 Safari/537.36',
+    'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/101.0.4951.41 Safari/537.36',
+    'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/101.0.4951.64 Safari/537.36',
+    'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/102.0.0.0 Safari/537.36',
+    'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/102.0.5005.115 Safari/537.36',
+    'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/102.0.5005.61 Safari/537.36',
+    'Mozilla/5.0 (X11; Linux x86_64; rv:100.0) Gecko/20100101 Firefox/100.0',
+    'Mozilla/5.0 (X11; Linux x86_64; rv:101.0) Gecko/20100101 Firefox/101.0',
+    'Mozilla/5.0 (X11; Linux x86_64; rv:91.0) Gecko/20100101 Firefox/91.0',
+    'Mozilla/5.0 (X11; Linux x86_64; rv:95.0) Gecko/20100101 Firefox/95.0',
+    'Mozilla/5.0 (X11; Linux x86_64; rv:99.0) Gecko/20100101 Firefox/99.0',
+    'Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:100.0) Gecko/20100101 Firefox/100.0',
+    'Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:101.0) Gecko/20100101 Firefox/101.0'
+]
+
+# Consistent for entire runtime
+random_ua = random.choice(USER_AGENTS)
 def base_headers():
-    return {'user-agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/88.0.4324.182 Safari/537.36'}
+    return {'user-agent': random_ua}
+
+def base_session():
+    s = requests.Session()
+    if secret.REQUESTS_PROXY:
+        def wrapped_request(self, *args, **kwargs):
+            if not kwargs:
+                kwargs = {}
+            kwargs['proxies'] = {
+                'http': secret.REQUESTS_PROXY,
+                'https': secret.REQUESTS_PROXY
+            }
+            return self._original_request(*args, **kwargs)
+
+        s._original_request = s.request
+        s.request = wrapped_request.__get__(s, requests.Session)
+    return s
+
+def days_between(start, end) -> int:
+    diff = arrow.get(end) - arrow.get(start)
+    return diff.days
+
+# both inclusive
+def split_days_range(start_a, end_a, days: int = 5) -> List[Tuple[str, str]]:
+    ranges = []
+    start = arrow.get(start_a)
+    end = arrow.get(end_a)
+    cur_s = start
+    cur = start
+    while cur <= end:
+        if (cur - cur_s).days >= days-1:
+            ranges.append((cur_s, cur))
+            cur_s = cur + datetime.timedelta(days=1)
+
+        cur += datetime.timedelta(days=1)
+    if len(ranges) > 0 and (end - ranges[-1][-1]).days > 0:
+        ranges.append((cur_s, end))
+
+    return ranges

 class ApiException(Exception):
    def __init__(self, status_code, text, *args, **kwargs):
        self.status_code = status_code
-        super().__init__(text, *args, **kwargs)
+        super().__init__('%s%s' % (text, ' (HTTP %s)' % status_code if status_code else ''), *args, **kwargs)

 class ApiLoginException(ApiException):
    pass
@@ -1,79 +1,176 @@
-import requests
 import urllib
-import datetime
 import arrow
+import time
+import logging

 from bs4 import BeautifulSoup

-from .common import parse_date, base_headers, ApiException, ApiLoginException
+from ..util import timeago, cap_length
+from .common import parse_date, base_headers, base_session, ApiException, ApiLoginException
+
+logger = logging.getLogger(__name__)

 class ControlIQApi:
-    BASE_URL = 'https://tdcservices.tandemdiabetes.com/tconnect/controliq/api/'
+    BASE_URL = 'https://tdcservices.tandemdiabetes.com/'
    LOGIN_URL = 'https://tconnect.tandemdiabetes.com/login.aspx?ReturnUrl=%2f'

+    LAST_CONFIRMED_SOFTWARE_VERSION = 't:connect 7.17.2.3'
+
    userGuid = None
    accessToken = None
    accessTokenExpiresAt = None
+    tconnect_software_ver = None

    def __init__(self, email, password):
        self.login(email, password)
+        self._email = email
+        self._password = password

    def login(self, email, password):
-        with requests.Session() as s:
+        logger.info("Logging in to ControlIQApi...")
+        with base_session() as s:
            initial = s.get(self.LOGIN_URL, headers=base_headers())
            soup = BeautifulSoup(initial.content, features='lxml')
-            data = {
-                "__LASTFOCUS": "",
-                "__EVENTTARGET": "ctl00$ContentBody$LoginControl$linkLogin",
-                "__EVENTARGUMENT": "",
-                "__VIEWSTATE": soup.select_one("#__VIEWSTATE")["value"],
-                "__VIEWSTATEGENERATOR": soup.select_one("#__VIEWSTATEGENERATOR")["value"],
-                "__EVENTVALIDATION": soup.select_one("#__EVENTVALIDATION")["value"],
-                "ctl00$ContentBody$LoginControl$txtLoginEmailAddress": email,
-                "txtLoginEmailAddress_ClientState": '{"enabled":true,"emptyMessage":"","validationText":"%s","valueAsString":"%s","lastSetTextBoxValue":"%s"}' % (email, email, email),
-                "ctl00$ContentBody$LoginControl$txtLoginPassword": password,
-                "txtLoginPassword_ClientState": '{"enabled":true,"emptyMessage":"","validationText":"%s","valueAsString":"%s","lastSetTextBoxValue":"%s"}' % (password, password, password)
-            }
+            data = self._build_login_data(email, password, soup)
+
            req = s.post(self.LOGIN_URL, data=data, headers={'Referer': self.LOGIN_URL, **base_headers()}, allow_redirects=False)
+            # HTTP 200 is reported when credentials are incorrect
+            if req.status_code == 200:
+                login_error = self._find_login_error(req.text)
+                if not login_error:
+                    login_error = 'Check your login credentials.'
+                raise ApiLoginException(None, 'Error logging in to t:connect: %s' % login_error)
+
            if req.status_code != 302:
-                raise ApiLoginException(req.status_code, 'Error logging in to t:connect. Check your login credentials.')
+                raise ApiLoginException(req.status_code, 'Error logging in to t:connect')


            fwd = s.post(urllib.parse.urljoin(self.LOGIN_URL, req.headers['Location']), cookies=req.cookies, headers=base_headers())
            if fwd.status_code != 200:
+                logger.warn("Received non-HTTP 200: %s" % req.text)
                raise ApiException(fwd.status_code, 'Error retrieving t:connect login cookies.')

            self.userGuid = req.cookies['UserGUID']
-            self.accessToken = req.cookies['accessToken']
-            self.accessTokenExpiresAt = req.cookies['accessTokenExpiresAt']
+            if 'accessToken' in req.cookies and 'accessTokenExpiresAt' in req.cookies:
+                self.accessToken = req.cookies['accessToken']
+                self.accessTokenExpiresAt = req.cookies['accessTokenExpiresAt']
+                logger.info("Logged in to ControlIQApi successfully via accessToken cookie (expiration: %s, %s)" % (self.accessTokenExpiresAt, timeago(self.accessTokenExpiresAt)))
+            else:
+                logger.info("No accessToken cookie found when logging in to ControlIQApi. Triggering AndroidApi auth")
+
+                from .android import AndroidApi
+                android = AndroidApi(email, password)
+                self.accessToken = android.accessToken
+                self.accessTokenExpiresAt = android.accessTokenExpiresAt
+
+                logger.info("Logged in to AndroidApi successfully via accessToken param (expiration: %s, %s)" % (self.accessTokenExpiresAt, timeago(self.accessTokenExpiresAt)))
+
+
+            self.loginSession = s
            return True

+    def _build_login_data(self, email, password, soup):
+        try:
+            version = soup.select_one("#footer_version").text.strip()
+            self.tconnect_software_ver = version
+            logger.info("Reported tconnect software version: %s" % version)
+            if version != self.LAST_CONFIRMED_SOFTWARE_VERSION:
+                logger.warning("Newer API version than last confirmed working. Saw %s and expected %s" % (version, self.LAST_CONFIRMED_SOFTWARE_VERSION))
+                logger.warning("If you experience any issues, please report them to https://github.com/jwoglom/tconnectsync")
+        except Exception:
+            logger.warning("Unable to find tconnect software version.")
+            contents = "<unknown>"
+            if soup:
+                contents = "%s" % soup.encode_contents()
+                if len(contents) > 1000:
+                    contents = "%s[SNIP]%s" % (contents[:500], contents[-500:])
+            logger.info("BeautifulSoup parsed contents: %s" % contents)
+            pass
+        if not soup.select_one("#__VIEWSTATE"):
+            enc_contents = str(soup.encode_contents())
+            if "Web Page Blocked!" in enc_contents or "Attack ID:" in enc_contents:
+                logger.warn("Being ratelimited/blocked by web application firewall. Sleeping for 30 minutes before retrying.")
+                logger.info("BeautifulSoup parsed contents: %s" % enc_contents)
+                time.sleep(1800)
+                exit(1)
+        return {
+            "__LASTFOCUS": "",
+            "__EVENTTARGET": "ctl00$ContentBody$LoginControl$linkLogin",
+            "__EVENTARGUMENT": "",
+            "__VIEWSTATE": soup.select_one("#__VIEWSTATE")["value"],
+            "__VIEWSTATEGENERATOR": soup.select_one("#__VIEWSTATEGENERATOR")["value"],
+            "__EVENTVALIDATION": soup.select_one("#__EVENTVALIDATION")["value"],
+            "ctl00$ContentBody$LoginControl$txtLoginEmailAddress": email,
+            "txtLoginEmailAddress_ClientState": '{"enabled":true,"emptyMessage":"","validationText":"%s","valueAsString":"%s","lastSetTextBoxValue":"%s"}' % (email, email, email),
+            "ctl00$ContentBody$LoginControl$txtLoginPassword": password,
+            "txtLoginPassword_ClientState": '{"enabled":true,"emptyMessage":"","validationText":"%s","valueAsString":"%s","lastSetTextBoxValue":"%s"}' % (password, password, password)
+        }
+
+    def _find_login_error(self, text):
+        try:
+            soup = BeautifulSoup(text, features='lxml')
+            notice_error = soup.select_one(".notice_error").text.strip()
+            return notice_error
+        except Exception:
+            return None
+
    def needs_relogin(self):
+        if not self.accessTokenExpiresAt:
+            return False
+
        diff = (arrow.get(self.accessTokenExpiresAt) - arrow.get())
        return (diff.seconds <= 5 * 60)

    def api_headers(self):
        if not self.accessToken:
            raise Exception('No access token provided')
-        return {'Authorization': 'Bearer %s' % self.accessToken, **base_headers()}
+        return {
+            'Authorization': 'Bearer %s' % self.accessToken,
+            'Origin': 'https://tconnect.tandemdiabetes.com',
+            'Referer': 'https://tconnect.tandemdiabetes.com/',
+            **base_headers()
+        }
+
+    def _get(self, endpoint, query):
+        r = base_session().get(self.BASE_URL + endpoint, data=query, headers=self.api_headers())

-    def get(self, endpoint, query):
-        r = requests.get(self.BASE_URL + endpoint, query, headers=self.api_headers())
        if r.status_code != 200:
            raise ApiException(r.status_code, "ControlIQ API HTTP %s response: %s" % (str(r.status_code), r.text))
        return r.json()

+
+    def get(self, endpoint, query, tries=0):
+        try:
+            return self._get(endpoint, query)
+        except ApiException as e:
+            logger.warning("Received ApiException in ControlIQApi with endpoint '%s' (tries %d): %s" % (endpoint, tries, e))
+            if tries > 0:
+                raise ApiException(e.status_code, "ControlIQ API HTTP %d on retry #%d: %s", e.status_code, tries, e)
+
+            # Trigger automatic re-login, and try again once
+            if e.status_code == 401:
+                logger.info("Performing automatic re-login after HTTP 401 for ControlIQApi")
+                self.accessTokenExpiresAt = time.time()
+                self.login(self._email, self._password)
+
+                return self.get(endpoint, query, tries=tries+1)
+
+            if e.status_code == 500:
+                return self.get(endpoint, query, tries=tries+1)
+
+            raise e
+
    """
    Returns detailed basal event information and reasons for delivery suspension.
+    End-date inclusive: Returns data from 00:00 on start date to 23:59 on end date.
    """
    def therapy_timeline(self, start=None, end=None):
        startDate = parse_date(start)
        endDate = parse_date(end)

-        return self.get('therapytimeline/users/%s' % (self.userGuid), {
-            "startDate": startDate,
-            "endDate": endDate
-        })
+        # Microsoft-Azure-Application-Gateway/v2 WAF error message appears
+        # if startDate and endDate are not specified in exactly this order.
+        return self.get('tconnect/controliq/api/therapytimeline/users/%s?startDate=%s&endDate=%s' % (self.userGuid, startDate, endDate), {})

    """
    Returns a summary of pump and cgm activity.
@@ -86,7 +183,24 @@ class ControlIQApi:
        startDate = parse_date(start)
        endDate = parse_date(end)

-        return self.get('summary/users/%s' % (self.userGuid), {
-            "startDate": startDate,
-            "endDate": endDate
-        })
+        return self.get('tconnect/controliq/api/summary/users/%s?startDate=%s&endDate=%s' % (self.userGuid, startDate, endDate), {})
+    
+    """
+    Returns active account features, including the date when ControlIQ was enabled.
+    [{"serialNumber": "11111111", "features": {"controlIQ": {"feature": 1, "dateTimeFirstDetected": "YYYY-MM-DD:THH:MM:SS", "unixTimestamp": 1111111111}}}]
+    """
+    def pumpfeatures(self):
+        return self.get('tconnect/controliq/api/pumpfeatures/users/%s' % self.userGuid, {})
+
+    """
+    Returns therapy events, used by the webui Therapy Timeline.
+    {'event': [
+      {'type': 'Basal', 'basalRate': ...}, 
+      {'type': 'Bolus', 'standard': ...},
+      {'type': 'CGM', 'egv': ...}
+    ]}
+    """
+    def therapy_events(self, start_date=None, end_date=None):
+        startDate = parse_date(start_date)
+        endDate = parse_date(end_date)
+        return self.get('tconnect/therapyevents/api/TherapyEvents/%s/%s/false?userId=%s' % (startDate, endDate, self.userGuid), {})
@@ -0,0 +1,378 @@
+import urllib
+import arrow
+import time
+import logging
+import json
+import base64
+import hashlib
+import os
+import jwt
+import pickle
+
+from requests_oidc import make_auth_code_session
+from requests_oidc.plugins import OSCachedPlugin
+from requests_oidc.utils import ServerDetails
+from requests_oauthlib import OAuth2Session
+from jwt.algorithms import RSAAlgorithm
+
+
+from ..util import timeago, cap_length
+from .common import parse_ymd_date, base_headers, base_session, ApiException, ApiLoginException
+from ..secret import CACHE_CREDENTIALS, CACHE_CREDENTIALS_PATH
+
+logger = logging.getLogger(__name__)
+
+class TandemSourceApi:
+    LOGIN_PAGE_URL = 'https://sso.tandemdiabetes.com/'
+    LOGIN_API_URL = 'https://tdcservices.tandemdiabetes.com/accounts/api/login'
+    TDC_AUTH_CALLBACK_URL = 'https://sso.tandemdiabetes.com/auth/callback'
+    TDC_OAUTH_AUTHORIZE_URL = 'https://tdcservices.tandemdiabetes.com/accounts/api/oauth2/v1/authorize'
+    TDC_OIDC_JWKS_URL = 'https://tdcservices.tandemdiabetes.com/accounts/api/.well-known/openid-configuration/jwks'
+    TDC_OIDC_ISSUER = 'https://tdcservices.tandemdiabetes.com/accounts/api' # openid_config['issuer']
+    TDC_OIDC_CLIENT_ID = '0oa27ho9tpZE9Arjy4h7'
+    SOURCE_URL = 'https://source.tandemdiabetes.com/'
+
+
+    def __init__(self, email, password):
+        self.login(email, password)
+        self._email = email
+        self._password = password
+
+    def login(self, email, password):
+        logger.info("Logging in to TandemSourceApi...")
+        if self.try_load_cached_creds(email):
+            logger.info("Successfully used cached credentials")
+            return True
+
+        with base_session() as s:
+            initial = s.get(self.LOGIN_PAGE_URL, headers=base_headers())
+
+            data = {
+                "username": email,
+                "password": password
+            }
+
+            req = s.post(self.LOGIN_API_URL, json=data, headers={'Referer': self.LOGIN_PAGE_URL, **base_headers()}, allow_redirects=False)
+
+            logger.debug("1. made POST to LOGIN_API")
+            # {"redirectUrl":"/","status":"SUCCESS"}
+            if req.status_code != 200:
+                raise ApiException(req.status_code, 'Error sending POST to login_api_url: %s' % req.text)
+
+            req_json = req.json()
+            login_ok = req_json.get('status', '') == 'SUCCESS'
+
+            if not login_ok:
+                raise ApiException(req.status_code, 'Error parsing login_api_url: %s' % json.dumps(req_json))
+
+            logger.debug("2. starting OIDC")
+
+            # oidc
+            client_id = self.TDC_OIDC_CLIENT_ID
+            redirect_uri = 'https://sso.tandemdiabetes.com/auth/callback' # must be an allowlisted URI
+            scope = 'openid profile email'
+
+            token_endpoint = 'https://tdcservices.tandemdiabetes.com/accounts/api/connect/token' #openid_config['token_endpoint']
+
+
+            def generate_code_verifier():
+                """Generates a high-entropy code verifier."""
+                code_verifier = base64.urlsafe_b64encode(os.urandom(64)).decode('utf-8').rstrip('=')
+                return code_verifier
+
+            def generate_code_challenge(verifier):
+                """Generates a code challenge from the code verifier."""
+                sha256_digest = hashlib.sha256(verifier.encode('utf-8')).digest()
+                code_challenge = base64.urlsafe_b64encode(sha256_digest).decode('utf-8').rstrip('=')
+                return code_challenge
+
+
+            code_verifier = generate_code_verifier()
+            code_challenge = generate_code_challenge(code_verifier)
+
+            authorization_endpoint = 'https://tdcservices.tandemdiabetes.com/accounts/api/connect/authorize' #openid_config['authorization_endpoint']
+
+            oidc_step1_params = {
+                'client_id': client_id,
+                'response_type': 'code',
+                'scope': scope,
+                'redirect_uri': redirect_uri,
+                'code_challenge': code_challenge,
+                'code_challenge_method': 'S256',
+            }
+
+            logger.debug("3. calling oidc_step1 with %s" % json.dumps(oidc_step1_params))
+            oidc_step1 = s.get(
+                authorization_endpoint + '?' + urllib.parse.urlencode(oidc_step1_params),
+                headers={'Referer': self.LOGIN_PAGE_URL, **base_headers()},
+                allow_redirects=True
+            )
+
+
+            if oidc_step1.status_code // 100 != 2:
+                raise ApiException(oidc_step1.status_code, 'Got unexpected status code for oidc step1: %s' % oidc_step1.text)
+
+            oidc_step1_loc = oidc_step1.url
+            oidc_step1_query = urllib.parse.parse_qs(urllib.parse.urlparse(oidc_step1_loc).query)
+            if 'code' not in oidc_step1_query:
+                raise ApiException(oidc_step1.status_code, 'No code for oidc step1 ReturnUrl (%s): %s' % (oidc_step1_loc, json.dumps(oidc_step1_query)))
+
+            oidc_step1_callback_code = oidc_step1_query['code'][0]
+
+            oidc_step2_token_data = {
+                'grant_type': 'authorization_code',
+                'client_id': client_id,
+                'code': oidc_step1_callback_code,
+                'redirect_uri': redirect_uri,
+                'code_verifier': code_verifier,
+            }
+
+            logger.debug("4. calling oidc_step2 with %s" % json.dumps(oidc_step2_token_data))
+
+            oidc_step2 = s.post(token_endpoint, data=oidc_step2_token_data, headers={
+                'Content-Type': 'application/x-www-form-urlencoded',
+                **base_headers()
+            })
+
+            if oidc_step2.status_code//100 != 2:
+                raise ApiException(oidc_step1.status_code, 'Got unexpected status code for oidc step2: %s' % oidc_step1.text)
+
+            oidc_json = oidc_step2.json()
+            logger.debug("5. parsing oidc_step2 json response: %s" % json.dumps(oidc_json))
+
+            if not 'access_token' in oidc_json:
+                raise ApiException(oidc_step1.status_code, 'Missing access_token in oidc_step2 json: %s' % json.dumps(oidc_json))
+
+            if not 'id_token' in oidc_json:
+                raise ApiException(oidc_step1.status_code, 'Missing id_token in oidc_step2 json: %s' % json.dumps(oidc_json))
+
+            self.loginSession = s
+            self.idToken = oidc_json['id_token']
+            self.extract_jwt()
+
+
+            self.accessToken = oidc_json['access_token']
+            self.accessTokenExpiresAt = arrow.get(arrow.get().int_timestamp + oidc_json['expires_in'])
+
+            self.cache_creds(email)
+
+            return True
+
+    def extract_jwt(self):
+        logger.debug("6. extracting JWT from %s" % self.idToken)
+        id_token = self.idToken
+
+        jwks_response = self.loginSession.get(self.TDC_OIDC_JWKS_URL)
+        jwks = jwks_response.json()
+        public_keys = {}
+        for jwk in jwks['keys']:
+            kid = jwk['kid']
+            public_keys[kid] = RSAAlgorithm.from_jwk(json.dumps(jwk))
+
+        # Get the key ID (kid) from the headers of the ID Token
+        unverified_header = jwt.get_unverified_header(id_token)
+        kid = unverified_header['kid']
+
+        key = public_keys.get(kid)
+        if not key:
+            raise ApiException(0, 'Public key not found for JWT: %s' % kid)
+
+        audience = self.TDC_OIDC_CLIENT_ID
+        issuer = self.TDC_OIDC_ISSUER
+
+        # Decode and verify the ID Token
+        id_token_claims = jwt.decode(
+            id_token,
+            key=key,
+            algorithms=['RS256'],
+            audience=audience,
+            issuer=issuer,
+        )
+
+        logger.info("Decoded JWT: %s" % json.dumps(id_token_claims))
+
+        self.jwtData = id_token_claims
+        self.pumperId = id_token_claims['pumperId']
+        self.accountId = id_token_claims['accountId']
+
+    def try_load_cached_creds(self, email):
+        if not CACHE_CREDENTIALS:
+            return False
+
+        if not os.path.exists(CACHE_CREDENTIALS_PATH):
+            logger.info("No cached credentials exist")
+            return False
+
+        _saved_blob = {}
+        try:
+            with open(CACHE_CREDENTIALS_PATH, 'rb') as f:
+                _saved_blob = pickle.load(f)
+        except Exception as e:
+            logger.warning(f"Could not load cached credentials at {CACHE_CREDENTIALS_PATH}: {e}")
+            return False
+
+        if not _saved_blob:
+            logger.warning(f"Could not load cached credentials at {CACHE_CREDENTIALS_PATH}: empty dict")
+            return False
+
+        if _saved_blob.get('cache_creds_version') != 1.0:
+            logger.warning(f"Unexpected cache_creds_version at {CACHE_CREDENTIALS_PATH}: {_saved_blob['cache_creds_version']}, expected 1.0")
+            return False
+
+        if _saved_blob.get('cache_creds_email') != email:
+            logger.warning(f"Cached credentials are for a different email ({_saved_blob['cache_creds_email']} in cache, but using {email}), skipping")
+            return False
+
+        at_expiry = _saved_blob['accessTokenExpiresAt']
+        if arrow.get().int_timestamp >= arrow.get(at_expiry).int_timestamp:
+            logger.info(f"Cached credentials have expired ({_saved_blob['accessTokenExpiresAt']}), skipping")
+            return False
+
+        self.jwtData = _saved_blob['jwtData']
+        self.pumperId = _saved_blob['pumperId']
+        self.accountId = _saved_blob['accountId']
+        self.idToken = _saved_blob['idToken']
+        self.accessToken = _saved_blob['accessToken']
+        self.accessTokenExpiresAt = _saved_blob['accessTokenExpiresAt']
+        self.loginSession = _saved_blob['loginSession']
+
+        def est_time(t):
+            now = arrow.get()
+            if now < t:
+                sec = (t - now).seconds
+            else:
+                sec = (now - t).seconds
+            min = sec//60
+            hr = min//60
+            min = min % 60
+            sec = sec % 60
+            r = ''
+            if hr:
+                r += f'{hr} hr '
+            if min:
+                r += f'{min} min '
+            if sec:
+                r += f'{sec} sec '
+            if not r:
+                return 'now'
+            elif now < t:
+                return 'in '+r.strip()
+            else:
+                return r.strip()+' ago'
+
+
+        sa = _saved_blob['cache_creds_saved_at']
+        ex = _saved_blob['accessTokenExpiresAt']
+        logger.info(f"Loaded cached credentials from {CACHE_CREDENTIALS_PATH}: saved at {sa} ({est_time(sa)}), access token expiry {ex} ({est_time(ex)})")
+
+        return True
+
+
+    def cache_creds(self, email):
+        if not CACHE_CREDENTIALS:
+            logger.info("Credentials caching is disabled, skipping save")
+            return
+
+        _saved_blob = {
+            'cache_creds_version': 1.0,
+            'cache_creds_saved_at': arrow.get(),
+            'cache_creds_email': email,
+            'jwtData': self.jwtData,
+            'pumperId': self.pumperId,
+            'accountId': self.accountId,
+            'idToken': self.idToken,
+            'accessToken': self.accessToken,
+            'accessTokenExpiresAt': self.accessTokenExpiresAt,
+            'loginSession': self.loginSession
+        }
+
+        if not os.path.exists(CACHE_CREDENTIALS_PATH):
+            mkdir = os.path.dirname(CACHE_CREDENTIALS_PATH)
+            logger.debug(f"Running mkdir on {mkdir}")
+            os.makedirs(mkdir, exist_ok=True)
+
+        with open(CACHE_CREDENTIALS_PATH, 'wb') as f:
+            pickle.dump(_saved_blob, f)
+            logger.info(f"Saved cached credentials to {CACHE_CREDENTIALS_PATH}")
+
+
+    def needs_relogin(self):
+        if not self.accessTokenExpiresAt:
+            return False
+
+        diff = (arrow.get(self.accessTokenExpiresAt) - arrow.get())
+        return (diff.seconds <= 5 * 60)
+
+    def api_headers(self):
+        if not self.accessToken:
+            raise Exception('No access token provided')
+        return {
+            'Authorization': 'Bearer %s' % self.accessToken,
+            'Origin': 'https://tconnect.tandemdiabetes.com',
+            'Referer': 'https://tconnect.tandemdiabetes.com/',
+            **base_headers()
+        }
+
+    def _get(self, endpoint, query):
+        r = base_session().get(self.SOURCE_URL + endpoint, data=query, headers=self.api_headers())
+
+        if r.status_code != 200:
+            raise ApiException(r.status_code, "TandemSourceApi HTTP %s response: %s" % (str(r.status_code), r.text))
+        return r.json()
+
+
+    def get(self, endpoint, query, tries=0):
+        try:
+            return self._get(endpoint, query)
+        except ApiException as e:
+            logger.warning("Received ApiException in TandemSourceApi with endpoint '%s' (tries %d): %s" % (endpoint, tries, e))
+            if tries > 0:
+                raise ApiException(e.status_code, "TandemSourceApi HTTP %d on retry #%d: %s", e.status_code, tries, e)
+
+            # Trigger automatic re-login, and try again once
+            if e.status_code == 401:
+                logger.info("Performing automatic re-login after HTTP 401 for TandemSourceApi")
+                self.accessTokenExpiresAt = time.time()
+                self.login(self._email, self._password)
+
+                return self.get(endpoint, query, tries=tries+1)
+
+            if e.status_code == 500:
+                return self.get(endpoint, query, tries=tries+1)
+
+            raise e
+
+    """
+    Returns information about the user and available pumps.
+    """
+    def pumper_info(self):
+        return self.get('api/pumpers/pumpers/%s' % (self.pumperId), {})
+
+    """
+    Returns metadata for pump events. Returns a list of dict's per-pump on the account.
+    [
+        {'tconnectDeviceId', 'serialNumber', 'modelNumber', 'minDateWithEvents', 'maxDateWithEvents', 'lastUpload', 'patientName', 'patientDateOfBirth', 'patientCareGiver', 'softwareVersion', 'partNumber'},
+    ]
+    """
+    def pump_event_metadata(self):
+        return self.get('api/reports/reportsfacade/%s/pumpeventmetadata' % (self.pumperId), {})
+
+    """
+    Returns raw unparsed string for pump events
+    tconnect_device_id is "tconnectDeviceId" from pump_event_metadata()
+    """
+    def pump_events_raw(self, tconnect_device_id, min_date=None, max_date=None):
+        minDate = parse_ymd_date(min_date)
+        maxDate = parse_ymd_date(max_date)
+        logger.debug(f'pump_events_raw({minDate}, {maxDate})')
+
+        # 229,5,28,4,26,99,279,3,16,59,21,55,20,280,64,65,66,61,33,371,171,369,460,172,370,461,372,399,256,213,406,394,212,404,214,405,447,313,60,14,6,90,230,140,12,11,53,13,63,203,307,191
+        eventIdsFilter = '229%2C5%2C28%2C4%2C26%2C99%2C279%2C3%2C16%2C59%2C21%2C55%2C20%2C280%2C64%2C65%2C66%2C61%2C33%2C371%2C171%2C369%2C460%2C172%2C370%2C461%2C372%2C399%2C256%2C213%2C406%2C394%2C212%2C404%2C214%2C405%2C447%2C313%2C60%2C14%2C6%2C90%2C230%2C140%2C12%2C11%2C53%2C13%2C63%2C203%2C307%2C191'
+        return self.get('api/reports/reportsfacade/pumpevents/%s/%s?minDate=%s&maxDate=%s&eventIds=%s' % (
+            self.pumperId,
+            tconnect_device_id,
+            minDate,
+            maxDate,
+            eventIdsFilter
+        ), {})
+
@@ -0,0 +1,296 @@
+from typing import Dict, List, Tuple
+import requests
+import urllib
+import datetime
+import arrow
+import time
+import logging
+
+from bs4 import BeautifulSoup
+
+from tconnectsync.domain.device_settings import Device, Profile, ProfileSegment, DeviceSettings
+from tconnectsync.util import removesuffix, removeprefix
+from tconnectsync.util.constants import MMOLL_TO_MGDL
+
+from .common import base_headers, ApiException
+
+logger = logging.getLogger(__name__)
+
+"""
+WebUIScraper contains data that is scraped from the t:connect Web UI and is
+not accessible via any known API.
+"""
+class WebUIScraper:
+    BASE_URL = "https://tconnect.tandemdiabetes.com/"
+
+    def __init__(self, controliq):
+        self.controliq = controliq
+
+    def needs_relogin(self):
+        return self.controliq.needs_relogin()
+
+    def _get(self, endpoint):
+        r = self.controliq.loginSession.get(self.BASE_URL + endpoint, headers=base_headers(), allow_redirects=True)
+
+        if r.status_code != 200:
+            raise ApiException(r.status_code, "WebUIScraper HTTP %s response: %s" % (str(r.status_code), r.text))
+
+        if 'login.aspx' in r.url:
+            raise ApiException(401, "WebUIScraper HTTP %s response for login page, returning 401: %s" % (str(r.status_code), r.url))
+
+        return r
+
+
+    def get(self, endpoint, tries=0):
+        try:
+            return self._get(endpoint)
+        except ApiException as e:
+            logger.warning("Received ApiException in WebUIScraper with endpoint '%s' (tries %d): %s" % (endpoint, tries, e))
+            if tries > 0:
+                raise ApiException(e.status_code, "WebUIScraper HTTP %d on retry #%d: %s", e.status_code, tries, e)
+
+            # Trigger automatic re-login, and try again once
+            if e.status_code == 401:
+                logger.info("Performing automatic re-login to ControlIQApi after HTTP 401 for ControlIQApi")
+                self.controliq.accessTokenExpiresAt = time.time()
+                self.controliq.login(self.controliq._email, self.controliq._password)
+
+                return self.get(endpoint, tries=tries+1)
+
+            if e.status_code == 500:
+                return self.get(endpoint, tries=tries+1)
+
+            raise e
+    
+    def strip(self, txt):
+        # Remove errant whitespace between litearl newlines (and literal &nbsp;)
+        sep = '\r\n'
+        if sep not in txt and '\n' in txt:
+            sep = '\n'
+        return ' '.join([i.replace('\xa0',' ').strip() for i in txt.strip().split(sep)])
+
+    
+    """
+    Returns a mapping between pump/device IDs and information about that device,
+    including the GUID used for obtaining pump settings.
+    """
+    def my_devices(self) -> Dict[str, DeviceSettings]:
+        devices = {}
+        r = self.get('myaccount/my_devices.aspx')
+        soup = BeautifulSoup(r.content, features='lxml')
+
+        for device in soup.select('#content > div.box'):
+            device_name = self.strip(device.select_one('.subTitle').text)
+
+            def find_label_value(lbl):
+                label = device.find(text=lbl)
+                if label:
+                    tds = label.parent.parent.parent.select('td')
+                    if len(tds) > 1:
+                        return self.strip(tds[1].text)
+                return None
+            
+            serial_number = find_label_value('Serial #')
+            model_number = find_label_value('Model #')
+            status = find_label_value('Status')
+
+            settings_span = device.find(text='View Settings')
+            settings_guid = None
+            if settings_span:
+                settings_a = settings_span.parent.parent
+                settings_guid = settings_a.attrs['href'].split('?guid=')[1]
+            
+            if serial_number:
+                devices[serial_number] = Device(
+                    name=device_name,
+                    model_number=model_number,
+                    status=status,
+                    guid=settings_guid)
+        
+        return devices
+    
+    """
+    Returns a parsed representation of a pump's settings.
+    Note that pump_guid is NOT the serial number of the pump, and
+    should be obtained from my_devices()[str(serial_number)].guid
+    """
+    def device_settings_from_guid(self, pump_guid: str) -> Tuple[List[Profile], DeviceSettings]:
+        profiles = []
+        settings = {}
+        r = self.get('myaccount/DeviceSettings.aspx?guid=%s' % pump_guid)
+        soup = BeautifulSoup(r.content, features='lxml')
+        settings["upload_date"] = self.strip(soup.select_one('#lblUploadDate').text)
+
+        divxml = soup.select_one('#divXML')
+        divxmlDiv = divxml.findChild('div')
+        for tbl in divxmlDiv.findChildren('table', recursive=False):
+            setting_bg = tbl.select_one('.setting_bg')
+            if setting_bg and self.strip(setting_bg.text) == 'Profile':
+                profiles.append(self._parse_profile_tbl(tbl))
+            else:
+                settings.update(self._parse_settings_tbl(tbl))
+        
+        low_bg_threshold, high_bg_threshold = self._extract_bg_thresholds(settings)
+
+        dev_settings = DeviceSettings(
+            low_bg_threshold=low_bg_threshold,
+            high_bg_threshold=high_bg_threshold,
+            raw_settings=settings
+        )
+        
+        return profiles, dev_settings
+    
+    def _parse_profile_tbl(self, tbl) -> Profile:
+        profile = {}
+        profile["title"] = self.strip(tbl.select_one('.setting_title').text)
+        profile["active"] = bool(tbl.find(text='Active at the time of upload'))
+        profile["segments"] = []
+
+        def parse_basal_rate(rate) -> float:
+            return float(removesuffix(rate, ' u/hr'))
+        
+        def parse_factor(ratio) -> int:
+            return parse_bg_mgdl(removeprefix(ratio, '1u:'))
+
+        def parse_ratio(ratio) -> float:
+            return float(removesuffix(removeprefix(ratio, '1u:'), ' g'))
+        
+        def parse_bg_mgdl(bg) -> int:
+            if bg.endswith(' mg/dL'):
+                return float(removesuffix(bg, ' mg/dL'))
+            elif bg.endswith(' mmol/L'):
+                return float(removesuffix(bg, ' mmol/L')) * MMOLL_TO_MGDL
+            raise ValueError(bg)
+        
+        def hours_to_mins(text) -> int:
+            hrmin = removesuffix(text, " hours")
+            hr, min = hrmin.split(":", 1)
+            return int(min) + int(hr)*60
+
+        for tr in tbl.select('tr'):
+            # Skip header rows
+            if tr.select_one('.setting_bg'):
+                continue
+            if tr.find(text='Start Time'):
+                continue
+            
+            tds = tr.select('td')
+            def is_time_row(td):
+                txt = self.strip(td.select_one('strong').text)
+                return " AM" in txt or " PM" in txt or txt in ("Midnight", "Noon")
+
+            if len(tds) > 0 and is_time_row(tds[0]):
+                display_time = self.strip(tds[0].text)
+                t = display_time
+                if display_time == "Midnight":
+                    t = "12:00 AM"
+                elif display_time == "Noon":
+                    t = "12:00 PM"
+
+                segment = {
+                    "display_time": display_time,
+                    "time": t,
+                    "basal_rate": parse_basal_rate(self.strip(tds[1].text)),
+                    "correction_factor": parse_factor(self.strip(tds[2].text)),
+                    "carb_ratio": parse_ratio(self.strip(tds[3].text)),
+                    "target_bg_mgdl": parse_bg_mgdl(self.strip(tds[4].text))
+                }
+                profile["segments"].append(ProfileSegment(**segment))
+                continue
+            
+            if tr.find(text='Calculated Total Daily Basal'):
+                profile["calculated_total_daily_basal"] = float(removesuffix(self.strip(tds[1].text), " units"))
+                continue
+            
+            # Last row
+            if tr.find(text='Duration of Insulin:'):
+                lastrow = self.strip(tr.text)
+                for part in lastrow.split(' |'):
+                    if len(part) < 1:
+                        continue
+
+                    key, val = part.split(': ')
+                    key = self.strip(key)
+                    val = self.strip(val)
+                    if key == 'Duration of Insulin':
+                        profile["insulin_duration_min"] = hours_to_mins(val)
+                    elif key == 'Carbohydrates':
+                        profile["carbs_enabled"] = self.strip(val.lower()) == "on"
+
+
+        return Profile(**profile)
+
+    def _parse_settings_tbl(self, tbl):
+        outer_tr = tbl.select('tr')[2]
+
+        settings = {}
+        def loop(td, subhead):
+            settings[subhead] = {}
+            for tr in td.select('.settingstable > tr'):
+                if not tr.select_one('strong'):
+                    continue
+
+                key = self.strip(tr.select_one('strong').text)
+
+                tds = tr.select('td')
+                if len(tds) == 1:
+                    subhead = key
+                    settings[subhead] = {}
+                    continue
+
+                val_text = self.strip(tds[1].text)
+                val = {}
+                if tds[1].find(text=' - '):
+                    val['value'] = False
+                elif tds[1].find(text='Off'):
+                    val['value'] = False
+                    val_text = self.strip(val_text.split('Off', 1)[1])
+                elif tds[1].find(text='On'):
+                    val['value'] = True
+                    val_text = self.strip(val_text.split('On', 1)[1])
+
+                val['text'] = val_text
+                settings[subhead][key] = val
+
+        children = outer_tr.findChildren('td', recursive=False)
+        loop(children[0], 'Alerts')
+        loop(children[1], 'Pump Settings')
+
+        return settings
+    
+    def _extract_bg_thresholds(self, settings):
+        # Nightscout needs default values
+        low_bg_threshold = 70
+        high_bg_threshold = 180
+        if 'CGM Alerts' in settings:
+            if 'Low Alert' in settings['CGM Alerts']:
+                low = settings['CGM Alerts']['Low Alert']
+                if low['value']:
+                    low_bg_threshold = int(low['text'].split(' mg/dL')[0])
+            if 'High Alert' in settings['CGM Alerts']:
+                high = settings['CGM Alerts']['High Alert']
+                if high['value']:
+                    high_bg_threshold = int(high['text'].split(' mg/dL')[0])
+        
+        return low_bg_threshold, high_bg_threshold
+    
+    """
+    Wraps a call to my_devices to identify the device GUID from the
+    given pump serial, and then returns device_settings_from_guid.
+    """
+    def device_settings(self, pump_serial: str) -> Tuple[List[Profile], DeviceSettings]:
+        devices = self.my_devices()
+        if str(pump_serial) in devices.keys():
+            dev = devices[str(pump_serial)]
+            return self.device_settings_from_guid(dev['guid'])
+        
+        raise RuntimeError('Unable to find pump with serial number: %s. Known devices: %s' % (pump_serial, devices))
+
+
+
+
+
+
+
+
+                
@@ -1,25 +1,34 @@
 import requests
 import datetime
 import csv
+import logging
+import time
+import json

-from .common import parse_date, base_headers, ApiException
+from .common import base_session, parse_date, parsed_date_to_arrow, base_headers, days_between, split_days_range, ApiException
+
+logger = logging.getLogger(__name__)

 class WS2Api:
    BASE_URL = 'https://tconnectws2.tandemdiabetes.com/'

+    MAX_RETRIES = 2
+    SLEEP_SECONDS_INCREMENT = 60
+
    userGuid = None

    def __init__(self, userGuid):
        self.userGuid = userGuid
+        self.session = base_session()

-    def get(self, endpoint, query):
-        r = requests.get(self.BASE_URL + endpoint, query, headers=base_headers())
+    def get(self, endpoint, **kwargs):
+        r = self.session.get(self.BASE_URL + endpoint, headers=base_headers(), **kwargs)
        if r.status_code != 200:
            raise ApiException(r.status_code, "WS2 API HTTP %s response: %s" % (str(r.status_code), r.text))
        return r.text

-    def get_jsonp(self, endpoint):
-        r = requests.get(self.BASE_URL + endpoint, {'callback': 'cb'}, headers=base_headers())
+    def get_jsonp(self, endpoint, **kwargs):
+        r = self.session.get(self.BASE_URL + endpoint + '?callback=cb', headers=base_headers(), **kwargs)
        if r.status_code != 200:
            raise ApiException(r.status_code, "WS2 API HTTP %s response: %s" % (str(r.status_code), r.text))

@@ -29,7 +38,7 @@ class WS2Api:
        if t.endswith(')'):
            t = t[:-1]

-        return t
+        return json.loads(t)

    def _split_empty_sections(self, text):
        sections = [[]]
@@ -54,12 +63,60 @@ class WS2Api:
        return data


-    def therapy_timeline_csv(self, start=None, end=None):
+    """
+    Returns information on therapy, displayed in the therapy timeline on the
+    t:connect website.
+    Contains BG reading (CGM), IOB, basal, and bolus data.
+    
+    Basal data does NOT appear for the specified time range if using Control-IQ.
+    The ControlIQ API endpoints must be used for basal data instead.
+    However, all other fields are still accessed via this endpoint.
+
+    This has its own built-in retry logic because Tandem's frontend serving
+    the API returns 500s when its backend times out.
+    """
+    MAX_THERAPY_TIMELINE_DAYS = 2
+    def therapy_timeline_csv(self, start=None, end=None, tries=0):
        startDate = parse_date(start)
        endDate = parse_date(end)

-        req_text = self.get('therapytimeline2csv/%s/%s/%s?format=csv' % (self.userGuid, startDate, endDate), {})
+        pStart = parsed_date_to_arrow(startDate)
+        pEnd = parsed_date_to_arrow(endDate)
+        if days_between(pStart, pEnd) > self.MAX_THERAPY_TIMELINE_DAYS:
+            ranges = split_days_range(pStart, pEnd, self.MAX_THERAPY_TIMELINE_DAYS)
+            logger.debug("Splitting call to therapy_timeline_csv(%s, %s) into: %s", start, end, ranges)
+            outputs = []
+            for rng in ranges:
+                rStart, rEnd = rng
+                logger.debug("split therapy_timeline_csv(%s, %s)", rStart, rEnd)
+                output = self.therapy_timeline_csv(rStart, rEnd, tries=tries)
+                logger.debug("split therapy_timeline_csv(%s, %s) = %s", rStart, rEnd, ["%s: %s items" % (key, len(val)) for key, val in output.items()])
+                outputs.append(output)
+            full = {}
+            for o in outputs:
+                for key, val in o.items():
+                    if key not in full:
+                        full[key] = val
+                    elif val is not None:
+                        full[key] += val
+            
+            logger.debug("therapy_timeline_csv merge: %s", ["%s: %s items" % (key, len(val)) for key, val in full.items()])
+            return full

+        try:
+            req_text = self.get('therapytimeline2csv/%s/%s/%s?format=csv' % (self.userGuid, startDate, endDate), timeout=10)
+        except ApiException as e:
+            # This seems to occur as some kind of soft rate-limit.
+            logger.warning("Received ApiException in therapy_timeline_csv: (retry count %d) %s" % (tries, e))
+            if e.status_code == 500:
+                sleep_seconds = (tries+1) * self.SLEEP_SECONDS_INCREMENT
+                logger.error("Retrying in %d seconds after HTTP 500 in therapy_timeline_csv (retry count %d): %s" % (sleep_seconds, tries, e))
+                time.sleep(sleep_seconds)
+                if tries < self.MAX_RETRIES:
+                    return self.therapy_timeline_csv(start, end, tries+1)
+            raise e
+
+        logger.debug('req_text: %s', req_text)
        sections = self._split_empty_sections(req_text)

        readingData = None
@@ -86,6 +143,26 @@ class WS2Api:
            "basalData": self._csv_to_dict(basalData),
            "bolusData": self._csv_to_dict(bolusData)
        }
+    
+    """
+    Returns information on basal suspension. The filterbasal option only returns site/cartridge changes.
+    SuspendReason values are:
+     - "site-cart"
+     - "basal-profile"
+     - "manual"
+     - "previous"
+     - "alarm"
+    
+    End-date inclusive: Returns data from 00:00 on start date to 23:59 on end date.
+
+    {"BasalSuspension":[{"EventDateTime":"/Date(EPOCH_MS-0000)/", "SuspendReason": "reason"}]}
+    """
+    def basalsuspension(self, start=None, end=None, filterbasal=False):
+        startDate = parse_date(start)
+        endDate = parse_date(end)
+        arg = "filterbasal/1" if filterbasal else ""
+
+        return self.get_jsonp('basalsuspension/%s/%s/%s/%s' % (self.userGuid, startDate, endDate, arg), timeout=10)

    """
    Returns info on BasalIQ in JSONP format.
@@ -94,4 +171,4 @@ class WS2Api:
        startDate = parse_date(start)
        endDate = parse_date(end)

-        return self.get_jsonp('basaliqtech/%s/%s/%s' % (self.userGuid, startDate, endDate))
+        return self.get_jsonp('basaliqtech/%s/%s/%s' % (self.userGuid, startDate, endDate), timeout=10)
@@ -1,61 +1,207 @@
 import time
+import logging
+import datetime
+import sys

 from .process import process_time_range
-from .secret import (
-    PUMP_SERIAL_NUMBER,
-    AUTOUPDATE_DEFAULT_SLEEP_SECONDS,
-    AUTOUPDATE_MAX_SLEEP_SECONDS,
-    AUTOUPDATE_USE_FIXED_SLEEP
-)
+from .features import DEFAULT_FEATURES
+from . import secret

-"""
-Performs the auto-update functionality. Runs indefinitely in a loop
-until stopped (ctrl+c).
-"""
-def process_auto_update(tconnect, nightscout, time_start, time_end, pretend):
-    # Read from android api, find exact interval to cut down on API calls
-    # Refresh API token. If failure, die, have wrapper script re-run.
+logger = logging.getLogger(__name__)

-    last_event_index = None
-    last_event_time = None
-    time_diffs = []
-    while True:
-        last_event = tconnect.android.last_event_uploaded(PUMP_SERIAL_NUMBER)
-        if not last_event_index or last_event['maxPumpEventIndex'] > last_event_index:
+class Autoupdate:
+    """Wrap access to secrets for easier testing."""
+    def __init__(self, secret):
+        self.secret = secret
+        self.autoupdate_invocations = 0
+        self.last_event_index = None
+        self.last_event_time = None
+        self.last_successful_process_time_range = None
+        self.time_diffs_between_updates = []
+        self.last_attempt_time = None
+        self.time_diffs_between_attempts = []
+
+    """
+    Performs the auto-update functionality. Runs indefinitely in a loop
+    until stopped (ctrl+c), or a maximum of AUTOUPDATE_MAX_LOOP_INVOCATIONS times.
+    Stops if AUTOUPDATE_RESTART_ON_FAILURE is set and an error occurs.
+    """
+    def process(self, tconnect, nightscout, time_start, time_end, pretend, features=None):
+        if features is None:
+            features = DEFAULT_FEATURES
+
+        # Read from android api, find exact interval to cut down on API calls
+        # Refresh API token. If failure, die, have wrapper script re-run.
+
+        self.autoupdate_start = time.time()
+
+        while True:
+            logger.debug("autoupdate loop")
            now = time.time()
-            print('New event index:', last_event['maxPumpEventIndex'], 'last:', last_event_index)
+            last_event = tconnect.android.last_event_uploaded(self.secret.PUMP_SERIAL_NUMBER)
+            if not self.last_event_index or last_event['maxPumpEventIndex'] > self.last_event_index:
+                logger.info('New reported t:connect data. (event index: %s last: %s)' % (last_event['maxPumpEventIndex'], self.last_event_index))

-            if pretend:
-                print('Would update now')
+                if pretend:
+                    logger.info('Would update now if not in pretend mode')
+                else:
+                    added = process_time_range(tconnect, nightscout, time_start, time_end, pretend, features=features)
+                    logger.info('Added %d items from process_time_range' % added)
+                    if added == 0:
+                        # If we've been unable to find new events, but the last_event_index is increasing,
+                        # suggesting there are more events being added, we might be in a bugged
+                        # situation where we can't get any more data without restarting.
+                        # We skip this check on the first process cycle, since we might
+                        # just already be in sync with tconnect's pump data.
+                        if self.last_event_index:
+
+                            # Find the timestamp of the last time we've successfully obtained data,
+                            # or the time when the autoupdate run started, if we haven't at all.
+                            last_action_or_start = self.last_successful_process_time_range
+                            if not last_action_or_start:
+                                last_action_or_start = self.autoupdate_start
+
+                            # If it's been AUTOUPDATE_FAILURE_MINUTES in the state of not seeing
+                            # event index changes reflected in the tconnect data we're pulling,
+                            # raise an error and potentially restart.
+                            # This is likely a tconnectsync problem, not a problem with the pump or app
+                            # (we can see the indexes increasing, so we know something's happening!)
+                            if (now - last_action_or_start) >= 60 * self.secret.AUTOUPDATE_FAILURE_MINUTES:
+                                logger.error(AutoupdateFailureError(
+                                        ("%s: An event index change was recorded, but no new data was found via the API. " % datetime.datetime.now()) +
+                                        "The %s was %d minutes ago. This is a problem with tconnectsync." %
+                                        ("last processed event" if self.last_successful_process_time_range else "start of autoupdate", (now - last_action_or_start)//60)))
+
+                                if self.secret.AUTOUPDATE_RESTART_ON_FAILURE:
+                                    logger.error("Exiting with error code due to AUTOUPDATE_RESTART_ON_FAILURE")
+                                    return 1
+                            else:
+                                logger.warning(AutoupdateFailureWarning(("%s: An event index change was recorded, but no new data was found via the API. " % datetime.datetime.now()) +
+                                            "The %s was %d minutes ago. Resetting TConnectApi to attempt to solve this problem." %
+                                            ("last processed event" if self.last_successful_process_time_range else "start of autoupdate", (now - last_action_or_start)//60)))
+
+                                # As a stop-gap, try to re-initialize TConnectApi (triggering a re-login)
+                                # Use __class__ instead of direct TConnectApi invocation to avoid initializing a real TConnectApi over a fake
+                                tconnect = tconnect.__class__(self.secret.TCONNECT_EMAIL, self.secret.TCONNECT_PASSWORD)
+                    else:
+                        # Mark the last successful time we got data from tconnect
+                        self.last_successful_process_time_range = now
+
+
+                # Track the time it took to find a new event between runs,
+                # but skip this calculation the first process cycle (since
+                # we don't know at what exact point the event index changed)
+                if self.last_event_index:
+                    self.time_diffs_between_updates.append(now - self.last_event_time)
+                    logger.debug('Updating tracking of time since last update: %s' % self.time_diffs_between_updates)
+
+                # Mark the last event index uploaded from the pump and timestamp
+                self.last_event_index = last_event['maxPumpEventIndex']
+                self.last_event_time = now
+                self.last_attempt_time = now
+                self.time_diffs_between_attempts = []
            else:
-                added = process_time_range(tconnect, nightscout, time_start, time_end, pretend)
-                print('Added', added, 'items')
+                logger.info('No new reported t:connect data. (last event index: %s)' % last_event['maxPumpEventIndex'])

-            if last_event_index:
-                time_diffs.append(now - last_event_time)
-                print('Time diffs:', time_diffs)
+                # If we haven't seen the pump event index update in AUTOUPDATE_NO_DATA_FAILURE_MINUTES,
+                # then trigger an error and potentially restart.
+                # The most likely case here is that the pump isn't uploading right now.
+                if self.last_event_time and (now - self.last_event_time) >= 60 * self.secret.AUTOUPDATE_NO_DATA_FAILURE_MINUTES:
+                    logger.error(AutoupdateNoEventIndexesDetectedError(
+                        "%s: No new data event indexes have been detected for %d minutes. " % (datetime.datetime.now(), (now - self.last_event_time)//60) +
+                        "The t:connect app might no longer be functioning."))

-            last_event_index = last_event['maxPumpEventIndex']
-            last_event_time = now
-        else:
-            print('No event index change:', last_event['maxPumpEventIndex'])
+                    # TODO: restarting doesn't really help anything here.
+                    # Should we notify the user?
+                    if self.secret.AUTOUPDATE_RESTART_ON_FAILURE:
+                        logger.error("Exiting with error code due to AUTOUPDATE_RESTART_ON_FAILURE")
+                        return 1

-            if len(time_diffs) > 2:
-                print('Sleeping 60 seconds after unexpected no index change')
-                time.sleep(60)
-                continue
+                # Similarly, if we HAVE seen pump event indexes update but have not successfully
+                # found any associated data updates from the tconnect API for AUTOUPDATE_NO_DATA_FAILURE_MINUTES,
+                # trigger an error and potentially restart. This could either be a tconnectsync problem,
+                # where we can see the indexes increasing, but it takes us until a period of no index
+                # update to reach our AUTOUPDATE_FAILURE_MINUTES threshold; or, a side effect of the
+                # above no indexes warning.
+                elif self.last_successful_process_time_range and (now - self.last_successful_process_time_range) >= 60 * self.secret.AUTOUPDATE_FAILURE_MINUTES:
+                    logger.error(AutoupdateNoNewDataDetectedError(
+                        "%s: No new data has been detected via the API for %d minutes. " % (datetime.datetime.now(), (now - self.last_successful_process_time_range)//60) +
+                        "tconnectsync might not be functioning properly."))

-        sleep_secs = AUTOUPDATE_DEFAULT_SLEEP_SECONDS
-        if AUTOUPDATE_USE_FIXED_SLEEP != 1:
-            if len(time_diffs) > 10:
-                time_diffs = time_diffs[1:]
+                    if self.secret.AUTOUPDATE_RESTART_ON_FAILURE:
+                        logger.error("%s: Exiting with error code due to AUTOUPDATE_RESTART_ON_FAILURE" % datetime.datetime.now())
+                        return 1

-            if len(time_diffs) > 2:
-                sleep_secs = sum(time_diffs) / len(time_diffs)
+                # Track how long we've been retrying
+                if self.last_attempt_time:
+                    self.time_diffs_between_attempts.append(now - self.last_attempt_time)

-            if sleep_secs > AUTOUPDATE_MAX_SLEEP_SECONDS:
-                sleep_secs = AUTOUPDATE_MAX_SLEEP_SECONDS
+                self.last_attempt_time = now

-        # Sleep for a rolling average of time between updates
-        print('Sleeping for', sleep_secs, 'sec')
-        time.sleep(sleep_secs)
+                # If it's been 3 loops since the last time we found new data,
+                # then we're not in sync with the rate at which pump data is being
+                # uploaded, so
+                if len(self.time_diffs_between_attempts) >= 3:
+                    # The pump hasn't sent us data that, based on previous cadence, we were expecting
+                    logger.warning(AutoupdateNoIndexChangeWarning("Sleeping %d seconds after unexpected no index change based on previous cadence. (New data might be delayed.)" %
+                        int(self.secret.AUTOUPDATE_UNEXPECTED_NO_INDEX_SLEEP_SECONDS)))
+
+                    logger.debug("Last event time: %s, time diffs between attempts: %s" % (self.last_event_time, self.time_diffs_between_attempts))
+
+                    time.sleep(self.secret.AUTOUPDATE_UNEXPECTED_NO_INDEX_SLEEP_SECONDS)
+
+                    # Since we bail early, update the invocations count and potentially exit after sleeping.
+                    self.autoupdate_invocations += 1
+                    if self.secret.AUTOUPDATE_MAX_LOOP_INVOCATIONS > 0 and self.autoupdate_invocations >= self.secret.AUTOUPDATE_MAX_LOOP_INVOCATIONS:
+                        return 0
+
+                    continue
+
+            sleep_secs = self.secret.AUTOUPDATE_DEFAULT_SLEEP_SECONDS
+
+            # Sleep for a rolling average of time between updates
+            if self.secret.AUTOUPDATE_USE_FIXED_SLEEP != 1:
+                logger.debug("Time diffs between updates: %s" % self.time_diffs_between_updates)
+
+                # Only keep the 10 latest time diffs
+                if len(self.time_diffs_between_updates) > 10:
+                    self.time_diffs_between_updates = self.time_diffs_between_updates[1:]
+
+                # If we have less than 3 data points,
+                if len(self.time_diffs_between_updates) > 2:
+                    sleep_secs = sum(self.time_diffs_between_updates) / len(self.time_diffs_between_updates)
+
+                # At minimum, update every AUTOUPDATE_MAX_SLEEP_SECONDS regardless
+                # of how often we're seeing new data appear
+                if sleep_secs > self.secret.AUTOUPDATE_MAX_SLEEP_SECONDS:
+                    sleep_secs = self.secret.AUTOUPDATE_MAX_SLEEP_SECONDS
+
+            logger.info('Sleeping for %0.01f sec' % sleep_secs)
+            time.sleep(sleep_secs)
+
+            self.autoupdate_invocations += 1
+            if self.secret.AUTOUPDATE_MAX_LOOP_INVOCATIONS > 0 and self.autoupdate_invocations >= self.secret.AUTOUPDATE_MAX_LOOP_INVOCATIONS:
+                return 0
+
+
+class AutoupdateError(RuntimeError):
+    def __str__(self):
+        return "%s: %s" % (self.__class__.__name__, super().__str__())
+
+class AutoupdateWarning(RuntimeWarning):
+    def __str__(self):
+        return "%s: %s" % (self.__class__.__name__, super().__str__())
+class AutoupdateFailureError(AutoupdateError):
+    pass
+
+class AutoupdateFailureWarning(AutoupdateWarning):
+    pass
+
+class AutoupdateNoEventIndexesDetectedError(AutoupdateError):
+    pass
+
+class AutoupdateNoNewDataDetectedError(AutoupdateError):
+    pass
+
+class AutoupdateNoIndexChangeWarning(AutoupdateWarning):
+    pass
@@ -1,58 +1,239 @@
+import sys
+import time
+import arrow
+import logging
+import traceback
+import pkg_resources
+from datetime import datetime
+from pprint import pformat as pformat_base
+
 from .nightscout import NightscoutApi
+from .parser.nightscout import BASAL_EVENTTYPE, BOLUS_EVENTTYPE
+from .parser.tconnect import TConnectEntry
+from .sync.basal import process_ciq_basal_events
+
+try:
+    __version__ = pkg_resources.require("tconnectsync")[0].version
+except Exception:
+    __version__ = "UNKNOWN"

 """
 Attempts to authenticate with each t:connect API,
 and returns the output of a sample API call from each.
 Also attempts to connect to the Nightscout API.
 """
-def check_login(tconnect, time_start, time_end):
+def check_login(tconnect, time_start, time_end, verbose=False, sanitize=True):
    errors = 0

-    print("Logging in to t:connect ControlIQ API...")
+    loglines = []
+    def log(*args):
+        print(*args)
+        loglines.append(" ".join([str(i) for i in args]) + "\n")
+
+    def log_err(e):
+        try:
+            out = ''.join(list(traceback.TracebackException.from_exception(e).format()))
+            log(out)
+        except Exception:
+            log("could not log exception traceback: {}".format(e))
+
+    def debug(*args):
+        if verbose:
+            print(*args)
+        loglines.append(" ".join([str(i) for i in args]) + "\n")
+
+    log("tconnectsync version %s" % __version__)
+    log("Python version %s" % sys.version)
+    log("System platform %s" % sys.platform)
+    log("Running checks with time range %s to %s" % (time_start, time_end))
+    log("Current time: %s" % datetime.now())
+    log("time.tzname: %s" % str(time.tzname))
+
+    log("Loading secrets...")
+    try:
+        from .secret import TCONNECT_EMAIL, TCONNECT_PASSWORD, PUMP_SERIAL_NUMBER, NS_URL, NS_SECRET, TIMEZONE_NAME
+    except ImportError as e:
+        log("Error: Unable to load config file. Please check your .env file or environment variables")
+        log_err(e)
+    
+    if not TCONNECT_EMAIL or TCONNECT_EMAIL == 'email@email.com':
+        log("Error: You have not specified a TCONNECT_EMAIL")
+        errors += 1
+    
+    if not TCONNECT_PASSWORD or TCONNECT_PASSWORD == 'password':
+        log("Error: You have not specified a TCONNECT_PASSWORD")
+        errors += 1
+    
+    if not PUMP_SERIAL_NUMBER or PUMP_SERIAL_NUMBER == '11111111':
+        log("Error: You have not specified a PUMP_SERIAL_NUMBER")
+        errors += 1
+    
+    if not NS_URL or NS_URL == 'https://yournightscouturl/':
+        log("Error: You have not specified a NS_URL")
+        errors += 1
+    
+    if not NS_SECRET or NS_SECRET == 'apisecret':
+        log("Error: You have not specified a NS_SECRET")
+        errors += 1
+
+    log("TIMEZONE_NAME: %s" % TIMEZONE_NAME)
+
+    log("-----")
+
+    log("Logging in to t:connect ControlIQ API...")
    try:
        summary = tconnect.controliq.dashboard_summary(time_start, time_end)
-        print("ControlIQ dashboard summary: %s" % summary)
+        debug("ControlIQ dashboard summary: \n%s" % pformat(summary))
+        log("tconnect_software_ver: %s" % tconnect.controliq.tconnect_software_ver)
    except Exception as e:
-        print("Error occurred querying ControlIQ API: %s" % e)
+        log("Error occurred querying ControlIQ API for dashboard_summary:")
+        log_err(e)
+        if e and "HTTP 404" in str(e):
+            log("<!> The API returns a 404 error if there is no data for the provided dates (currently %s - %s). Try re-running with an earlier start date using --start-date and --end-date arguments." % (time_start, time_end))
        errors += 1
+    
+    log("Querying ControlIQ therapy_timeline...")
+    lastBasalTime = None
+    lastBasalDuration = None
+    try:
+        tt = tconnect.controliq.therapy_timeline(time_start, time_end)
+        debug("ControlIQ therapy_timeline: \n%s" % pformat(tt))
+        if tt:
+            processed_tt = process_ciq_basal_events(tt)
+            debug("ControlIQ processed therapy_timeline: \n%s" % pformat(processed_tt))
+            if processed_tt:
+                log("Last ControlIQ processed therapy_timeline event: \n%s" % pformat(processed_tt[-1]))
+                lastBasalTime = processed_tt[-1]['time']
+                lastBasalDuration = processed_tt[-1]['duration_mins']
+    except Exception as e:
+        log("Error occurred querying ControlIQ therapy_timeline:")
+        log_err(e)
+        errors += 1
+    
+    log("Querying ControlIQ therapy_events...")
+    try:
+        androidevents = tconnect.controliq.therapy_events(time_start, time_end)
+        debug("controliq therapy_events: \n%s" % pformat(androidevents))
+    except Exception as e:
+        log("Error occurred querying ControlIQ therapy_events:")
+        log_err(e)
+        errors += 1
+    
+    log("-----")

-    print("\nLogging in to t:connect WS2 API...")
+    log("Initializing t:connect WS2 API...")
+    ws2_loggedin = False
    try:
        summary = tconnect.ws2.basaliqtech(time_start, time_end)
-        print("WS2 basaliq status: %s" % summary)
+        debug("WS2 basaliq status: \n%s" % pformat(summary))
+        ws2_loggedin = True
    except Exception as e:
-        print("Error occurred querying WS2 API: %s" % e)
+        log("Error occurred querying WS2 API. This is okay so long as you are not using the PUMP_EVENTS or IOB sync features.")
+        log_err(e)
        errors += 1
+    
+    lastReadingTime = None
+    if ws2_loggedin:
+        log("Querying WS2 therapy_timeline_csv...")
+        try:
+            ttcsv = tconnect.ws2.therapy_timeline_csv(time_start, time_end)
+            debug("therapy_timeline_csv: \n%s" % pformat(ttcsv))
+            if ttcsv and "readingData" in ttcsv and len(ttcsv["readingData"]) > 0:
+                log("Last therapy_timeline_csv reading: \n%s" % pformat(ttcsv["readingData"][-1]))
+                lastReadingTime = TConnectEntry._datetime_parse(ttcsv["readingData"][-1]['EventDateTime'])
+        except Exception as e:
+            log("Error occurred querying WS2 therapy_timeline_csv. This is okay so long as you are not using the PUMP_EVENTS or IOB sync features.")
+            log_err(e)
+            errors += 1
+    else:
+        log("Not able to log in to WS2 API, so skipping therapy_timeline_csv")
+    
+    log("-----")

-    print("\nLogging in to t:connect Android API...")
+    log("Logging in to t:connect Android API...")
+    summary = None
    try:
        summary = tconnect.android.user_profile()
-        print("Android user profile: %s" % summary)
-
-        from .secret import PUMP_SERIAL_NUMBER
+        debug("Android user profile: \n%s" % pformat(summary))

        event = tconnect.android.last_event_uploaded(PUMP_SERIAL_NUMBER)
-        print("\nAndroid last uploaded event: %s" % event)
-    except ImportError:
-        print("Error: Unable to load config file.")
+        debug("Android last uploaded event: \n%s" % pformat(event))
    except Exception as e:
-        print("Error occurred querying Android API: %s" % e)
+        log("Error occurred querying Android API:")
+        log_err(e)
        errors += 1
+    
+    log("-----")

-    print("\nLogging in to Nightscout...")
+    log("Logging in to Nightscout...")
    try:
-        from .secret import NS_URL, NS_SECRET
+        nightscout = NightscoutApi(NS_URL, NS_SECRET)
+        status = nightscout.api_status()
+        debug("Nightscout status: \n%s" % pformat(status))

-        status = NightscoutApi(NS_URL, NS_SECRET).api_status()
-        print("\nNightscout status: %s" % status)
-    except ImportError:
-        print("Error: Unable to load config file.")
+        last_upload_basal = nightscout.last_uploaded_entry(BASAL_EVENTTYPE)
+        debug("Nightscout last uploaded basal: \n%s" % pformat(last_upload_basal))
+
+        last_upload_bolus = nightscout.last_uploaded_entry(BOLUS_EVENTTYPE)
+        debug("Nightscout last uploaded bolus: \n%s" % pformat(last_upload_bolus))
    except Exception as e:
-        print("Error occurred querying Nightscout API: %s" % e)
+        log("Error occurred querying Nightscout API:")
+        log_err(e)
        errors += 1

+    log("-----")
+
+    def time_ago(t):
+        return '%s ago' % (arrow.now() - arrow.get(t)) if t else 'n/a'
+
+    log("Last basal start time: %s (%s)" % (lastBasalTime, time_ago(lastBasalTime)))
+    log("Last basal duration: %s" % lastBasalDuration)
+    log("Last reading time: %s (%s)" % (lastReadingTime, time_ago(lastReadingTime)))
+
+    log("-----")
+
    if errors == 0:
-        print("\nNo API errors returned!")
+        log("No API errors returned!")
    else:
-        print("\nAPI errors occurred. Please check the errors above.")
+        log("API errors occurred. Please check the errors above.")
+    

+    with open('tconnectsync-check-output.log', 'w') as f:
+
+        if sanitize:
+            sanitizedData = {
+                'TCONNECT_EMAIL': TCONNECT_EMAIL,
+                'TCONNECT_PASSWORD': TCONNECT_PASSWORD,
+                'PUMP_SERIAL_NUMBER': PUMP_SERIAL_NUMBER,
+                'NS_URL': NS_URL,
+                'NS_SECRET': NS_SECRET
+            }
+
+            if summary:
+                sanitizedData.update({
+                    'ANDROID_PROFILE_USERID': summary.get('userID'),
+                    'ANDROID_PROFILE_PATIENT_FULLNAME': summary.get('patientFullName'),
+                    'ANDROID_PROFILE_CAREGIVER_FULLNAME': summary.get('caregiverFullName')
+                })
+
+            loglines = [run_sanitize(i, sanitizedData) for i in loglines]
+
+        f.writelines(loglines)
+
+    print("Created file tconnectsync-check-output.log containing additional debugging information.")
+    print("For support, you can upload this file to https://github.com/jwoglom/tconnectsync/issues/new")
+    if sanitize:
+        print("The file -- but NOT the output printed above -- has been sanitized to remove sensitive data.")
+    print("Please verify and remove any sensitive data, such as your Nightscout URL/secret and pump serial number,")
+    print("as necessary.")
+
+def run_sanitize(s, sanitizedData):
+    ret = str(s)
+    for k, v in sanitizedData.items():
+        if v and len(str(v)) > 0:
+            ret = ret.replace(str(v), '[%s]' % k)
+    return ret
+
+def pformat(*args, **kwargs):
+    kwargs['width'] = 160
+    return pformat_base(*args, **kwargs)
@@ -0,0 +1,25 @@
+from dataclasses import dataclass, asdict
+
+
+@dataclass
+class Bolus:
+    description: str
+    complete: str # "1" / "0"
+    completion: str
+    request_time: str # _datetime_parse timestamp
+    completion_time: str # _datetime_parse timestamp
+    insulin: str
+    requested_insulin: str
+    carbs: str
+    bg: str # potentially ""
+    user_override: str
+    extended_bolus: str # "1" / "0"
+    bolex_completion_time: str
+    bolex_start_time: str
+
+    def to_dict(self):
+        return asdict(self)
+    
+    @property
+    def is_extended_bolus(self):
+        return self.extended_bolus == "1"
@@ -0,0 +1,44 @@
+from dataclasses import dataclass, replace
+from typing import List, Optional
+
+@dataclass
+class Device:
+    name: str
+    model_number: str
+    status: str
+    guid: Optional[str]
+
+@dataclass
+class ProfileSegment:
+    display_time: str # Identical to time except written out as Midnight or Noon
+    time: str
+    basal_rate: float # _ u/hr
+    correction_factor: int # 1u: _ mg/dL
+    carb_ratio: float # 1u: _ g
+    target_bg_mgdl: int
+
+@dataclass
+class Profile:
+    title: str
+    active: bool
+    segments: List[ProfileSegment]
+    calculated_total_daily_basal: float # in units
+    insulin_duration_min: int
+    carbs_enabled: bool
+
+    def activeProfile(self):
+        p = self.copy()
+        p.active = True
+        return p
+
+    def copy(self):
+        p = replace(self)
+        p.segments = [replace(s) for s in p.segments]
+        return p
+
+# Settings stored globally in the pump that are stored per-profile in Nightscout
+@dataclass
+class DeviceSettings:
+    low_bg_threshold: int
+    high_bg_threshold: int
+    raw_settings: dict
@@ -0,0 +1,39 @@
+from enum import Enum
+
+from ...eventparser import events
+
+class EventClass(set, Enum):
+    # LidBasalDelivery = every 5min entry
+    # LidBasalRateChange = only when basal rate changes
+    BASAL = {events.LidBasalDelivery} # , LidBasalRateChange
+    BASAL_SUSPENSION = {events.LidPumpingSuspended}
+    BASAL_RESUME = {events.LidPumpingResumed}
+    ALARM = {events.LidAlarmActivated, events.LidMalfunctionActivated}
+    BOLUS = {
+        events.LidBolusRequestedMsg1, # carb amount, bg, iob
+        events.LidBolusRequestedMsg2, # more robust bolus type
+        events.LidBolusRequestedMsg3, # total bolus requested amount
+        events.LidBolusCompleted, # final event showing amount delivered
+        events.LidBolexCompleted # extended bolus
+    }
+    CARTRIDGE = {events.LidCartridgeFilled, events.LidCannulaFilled, events.LidTubingFilled}
+    CGM_ALERT = {events.LidCgmAlertActivated, events.LidCgmAlertActivatedDex, events.LidCgmAlertActivatedFsl2}
+    _CGM_START = {events.LidCgmStartSessionGx, events.LidCgmStartSessionFsl2}
+    _CGM_JOIN = {events.LidCgmJoinSessionGx, events.LidCgmJoinSessionG7, events.LidCgmJoinSessionFsl2}
+    _CGM_STOP = {events.LidCgmStopSessionGx, events.LidCgmStopSessionG7, events.LidCgmStopSessionFsl2}
+    CGM_START_JOIN_STOP = {*_CGM_START, *_CGM_JOIN, *_CGM_STOP}
+    CGM_READING = {events.LidCgmDataGxb, events.LidCgmDataG7, events.LidCgmDataFsl2}
+    USER_MODE = {events.LidAaUserModeChange}
+
+    @staticmethod
+    def for_event(evt):
+        for typ, vals in EventClass.__members__.items():
+            if typ.startswith('_'):
+                continue
+            if type(evt) == type and evt in vals:
+                return EventClass.__members__[typ]
+            elif type(evt) in vals:
+                return EventClass.__members__[typ]
+        return None
+
+
@@ -0,0 +1,52 @@
+from dataclasses import dataclass
+from dataclasses_json import dataclass_json
+from typing import List
+
+@dataclass_json
+@dataclass
+class PumpProfileSegment:
+    startTime: int # minutes
+    basalRate: int # milliunits
+    isf: int
+    carbRatio: int
+    targetBg: int
+
+    @property
+    def skip(self):
+        return self.startTime == 0 and self.basalRate == 0 and self.isf == 0 and self.carbRatio == 0 and self.targetBg == 0
+
+@dataclass_json
+@dataclass
+class PumpProfile:
+    name: str
+    idp: int
+    tDependentSegs: List[PumpProfileSegment]
+    insulinDuration: int # minutes
+    carbEntry: int # 1 / 0
+    maxBolus: int # milliunits
+
+@dataclass_json
+@dataclass
+class PumpProfiles:
+    activeIdp: int
+    profile: List[PumpProfile]
+
+@dataclass_json
+@dataclass
+class PumpGlucoseAlertSettings:
+    mgPerDl: int
+    enabled: int # 1 / 0
+    duration: int # minutes
+    status: int # unknown
+
+@dataclass_json
+@dataclass
+class PumpCgmSettings:
+    highGlucoseAlert: PumpGlucoseAlertSettings
+    lowGlucoseAlert: PumpGlucoseAlertSettings
+
+@dataclass_json
+@dataclass
+class PumpSettings:
+    profiles: PumpProfiles
+    cgmSettings: PumpCgmSettings
@@ -0,0 +1,483 @@
+import arrow
+
+from tconnectsync.domain.bolus import Bolus
+
+from ..secret import TIMEZONE_NAME
+
+
+def _datetime_parse(date):
+    # consistent format with ws2 endpoint
+    return arrow.get(date, tzinfo=TIMEZONE_NAME).format("YYYY-MM-DD HH:mm:ssZZ")
+
+class TherapyEvent:
+    type = None
+    eventDateTime = None
+    sourceRecId = None
+
+    def parse(self, json):
+        self.type = json['type']
+        self.eventDateTime = json['eventDateTime']
+        self.sourceRecId = json['sourceRecId']
+        self.rawJson = json
+    
+    def __str__(self):
+        return "%s(%s)" % (self.type, self.rawJson)
+
+class CGMTherapyEvent(TherapyEvent):
+    eventID = None
+    egv = None
+    """
+    {
+        "eventDateTime": "2022-07-21T00:00:08",
+        "eventID": 256,
+        "requestDateTime": "0001-01-01T00:00:00",
+        "type": "CGM",
+        "description": "EGV",
+        "sourceRecId": 0,
+        "eventTypeId": 0,
+        "deviceType": "t:slim X2 Insulin Pump",
+        "serialNumber": "xxx",
+        "indexId": 0,
+        "uploadId": 0,
+        "interactive": 0,
+        "tempRateId": 0,
+        "tempRateCompleted": 0,
+        "tempRateActivated": 0,
+        "egv": {
+            "estimatedGlucoseValue": 174,
+            "hypo": 0,
+            "belowTarget": 0,
+            "withinTarget": 1,
+            "aboveTarget": 0,
+            "hyper": 0
+        }
+    },
+    """
+    @classmethod
+    def parse(_, json):
+        self = CGMTherapyEvent()
+        TherapyEvent.parse(self, json)
+        self.eventID = json['eventID']
+        self.egv = json['egv']['estimatedGlucoseValue']
+        return self
+
+class BGTherapyEvent(TherapyEvent):
+    eventID = None
+    egv = None
+    """
+    {   
+        'bg': 160, # note in EGV
+        'cgmCalibration': 1, # not in EGV
+        'description': 'BG',
+        'deviceType': 't:slim X2 Insulin Pump',
+        'eventDateTime': '2022-08-20T07:25:24',
+        'eventTypeId': 16,
+        'indexId': 844955,
+        'interactive': 0,
+        'iob': 0.75,
+        'note': {   'active': False,
+                'eventId': 0, # different location than EGV
+                'eventTypeId': 16,
+                'id': 0,
+                'indexId': '',
+                'sourceRecordId': 0},
+        'requestDateTime': '0001-01-01T00:00:00',
+        'serialNumber': 'xxx',
+        'sourceRecId': 793549667,
+        'tempRateActivated': 0,
+        'tempRateCompleted': 0,
+        'tempRateId': 0,
+        'type': 'BG',
+        'uploadId': 748700213}
+    """    
+    @classmethod
+    def parse(_, json):
+        self = BGTherapyEvent()
+        TherapyEvent.parse(self, json)
+        self.eventID = json['note']['eventId']
+        # This is probably not how we want to provide CGM calibrations to Nightscout,
+        # but will just include it as egv data for now to keep the thing from crashing :)
+        self.egv = json['bg']
+        return self
+
+class BolusTherapyEvent(TherapyEvent):
+    bolusRequestOptions = None
+    REQUEST_AUTOMATIC = "Automatic Bolus/Correction"
+    REQUEST_STANDARD = "Standard"
+
+    bolusType = None
+    TYPE_AUTOMATIC = "Automatic Correction"
+    TYPE_CARB = "Carb"
+
+    carbSize = None
+    correctionBolusSize = None
+    foodBolusSize = None
+    
+    insulinDelivered = None
+    insulinRequested = None
+    completionDateTime = None
+
+    completionStatus = None
+    STATUS_COMPLETED = "Completed"
+
+    eventHistoryReportDetails = None
+
+    standardPercent = None
+    sourceRecId = None
+
+    @classmethod
+    def parse(_, json):
+        self = BolusTherapyEvent()
+        TherapyEvent.parse(self, json)
+        self.description = json.get("description")
+        self.complete = json.get("standard", {}).get("bolusIsComplete")
+        self.completion = json.get("standard", {}).get("completionStatusDesc")
+        self.request_time = json.get("requestDateTime")
+        self.completion_time = json.get("standard", {}).get("insulinDelivered", {}).get("completionDateTime")
+        # TODO: separate extended vs standard bolus into separate fields
+        self.insulin = json.get("standard", {}).get("insulinDelivered", {}).get("value")
+        self.requested_insulin = json.get("standard", {}).get("insulinRequested")
+        self.carbs = json.get("carbSize")
+        self.bg = json.get("bg")
+        self.user_override = json.get("userOverride")
+        self.extended_bolus = json.get("bolusRequestOptions") == "Extended"
+        if self.extended_bolus and self.complete:
+            # TODO(https://github.com/jwoglom/tconnectsync/issues/19): read more extended bolus info
+            self.complete = json.get("bolex", {}).get("extendedBolusIsComplete")
+            self.completion = json.get("bolex", {}).get("completionStatusDesc")
+            self.bolex_completion_time = json.get("bolex", {}).get("insulinDelivered", {}).get("completionDateTime")
+            self.bolex_start_time = json.get("bolex", {}).get("bolexStartDateTime")
+        else:
+            self.bolex_completion_time = ""
+            self.bolex_start_time = ""
+        return self
+    
+    def to_bolus(self):
+        return Bolus(
+            description=self.description,
+            complete="1" if self.complete else "0",
+            completion=self.completion or "",
+            request_time=_datetime_parse(self.request_time),
+            completion_time=_datetime_parse(self.completion_time),
+            insulin=str(self.insulin),
+            requested_insulin=str(self.requested_insulin),
+            carbs=str(self.carbs or "0"), # Nightscout expects non-empty carbs
+            bg=str(self.bg or ""),
+            user_override=str(self.user_override),
+            extended_bolus="1" if self.extended_bolus else "0",
+            bolex_completion_time=_datetime_parse(self.bolex_completion_time) if self.bolex_completion_time else "",
+            bolex_start_time=_datetime_parse(self.bolex_start_time) if self.bolex_start_time else ""
+        )
+
+    """
+    Correction:
+    {
+        "actualTotalBolusRequested": 2.9,
+        "bg": 254,
+        "bolusRequestOptions": "Automatic Bolus/Correction",
+        "bolusType": "Automatic Correction",
+        "carbSize": 0,
+        "correctionBolusSize": 2.9,
+        "correctionFactor": 30,
+        "declinedCorrection": 0,
+        "duration": 0,
+        "eventDateTime": "2022-07-21T11:53:08",
+        "eventHistoryReportDetails": "CF 1:30 - Carb Ratio 1:0 - Target BG 110",
+        "eventHistoryReportEventDesc": "Correction Bolus",
+        "foodBolusSize": 0,
+        "isQuickBolus": 0,
+        "note": {
+            "id": 0,
+            "indexId": "572946",
+            "eventTypeId": 64,
+            "sourceRecordId": 0,
+            "eventId": 0,
+            "active": false
+        },
+        "requestDateTime": "2022-07-21T11:53:08",
+        "standard": {
+            "insulinDelivered": {
+                "completionDateTime": "2022-07-21T11:55:24",
+                "value": 2.9
+            },
+            "foodDelivered": 0,
+            "correctionDelivered": 2.9,
+            "insulinRequested": 2.9,
+            "completionStatusId": 3,
+            "completionStatusDesc": "Completed",
+            "bolusIsComplete": 1,
+            "bolusRequestId": 3361,
+            "bolusCompletionId": 3361
+        },
+        "standardPercent": 100,
+        "targetBG": 110,
+        "userOverride": 0,
+        "type": "Bolus",
+        "description": "Automatic Bolus/Correction",
+        "sourceRecId": 1171791787,
+        "eventTypeId": 0,
+        "indexId": 0,
+        "uploadId": 0,
+        "interactive": 0,
+        "tempRateId": 0,
+        "tempRateCompleted": 0,
+        "tempRateActivated": 0
+    },
+    Standard:
+    {
+        "actualTotalBolusRequested": 4.17,
+        "bolusRequestOptions": "Standard",
+        "bolusType": "Carb",
+        "carbSize": 25,
+        "correctionBolusSize": 0,
+        "correctionFactor": 30,
+        "declinedCorrection": 0,
+        "duration": 0,
+        "eventDateTime": "2022-07-21T12:27:36",
+        "eventHistoryReportDetails": "CF 1:30 - Carb Ratio 1:6 - Target BG 110",
+        "eventHistoryReportEventDesc": "Food Bolus",
+        "foodBolusSize": 4.17,
+        "iob": 2.62,
+        "isQuickBolus": 0,
+        "note": {
+            "id": 0,
+            "indexId": "573042",
+            "eventTypeId": 64,
+            "sourceRecordId": 0,
+            "eventId": 0,
+            "active": false
+        },
+        "requestDateTime": "2022-07-21T12:27:36",
+        "standard": {
+            "insulinDelivered": {
+                "completionDateTime": "2022-07-21T12:29:21",
+                "value": 4.17
+            },
+            "foodDelivered": 4.17,
+            "correctionDelivered": 0,
+            "insulinRequested": 4.17,
+            "completionStatusId": 3,
+            "completionStatusDesc": "Completed",
+            "bolusIsComplete": 1,
+            "bolusRequestId": 3362,
+            "bolusCompletionId": 3362
+        },
+        "standardPercent": 100,
+        "targetBG": 110,
+        "userOverride": 0,
+        "type": "Bolus",
+        "description": "Standard",
+        "sourceRecId": 1171853319,
+        "eventTypeId": 0,
+        "indexId": 0,
+        "uploadId": 0,
+        "interactive": 0,
+        "tempRateId": 0,
+        "tempRateCompleted": 0,
+        "tempRateActivated": 0
+    },
+    Extended bolus incomplete:
+    {
+        "actualTotalBolusRequested": 0.4,
+        "bg": 131,
+        "bolex": {
+            "size": 0.2,
+            "bolexStartDateTime": "2022-08-09T23:20:04",
+            "iob": 0,
+            "completionStatusId": 0,
+            "extendedBolusIsComplete": 0,
+            "insulinRequested": 0,
+            "bolexCompletionId": 0
+        },
+        "bolusRequestOptions": "Extended",
+        "bolusType": "Carb",
+        "carbSize": 0,
+        "correctionBolusSize": 0.0,
+        "correctionFactor": 30.0,
+        "declinedCorrection": 0,
+        "duration": 15,
+        "eventDateTime": "2022-08-09T23:19:15",
+        "eventHistoryReportDetails": "CF 1:30 - Carb Ratio 1:6 - Target BG 110<br/>Override: Pump calculated Bolus = 0.0 units",
+        "eventHistoryReportEventDesc": "Food Bolus: 50&#37; Extended 15 mins",
+        "foodBolusSize": 0.0,
+        "iob": 5.87,
+        "isQuickBolus": 0,
+        "note": {
+            "id": 0,
+            "indexId": "631597",
+            "eventTypeId": 64,
+            "sourceRecordId": 0,
+            "eventId": 0,
+            "active": false
+        },
+        "requestDateTime": "2022-08-09T23:19:15",
+        "standard": {
+            "insulinDelivered": {
+                "completionDateTime": "2022-08-09T23:20:04",
+                "value": 0.2
+            },
+            "foodDelivered": 0.0,
+            "correctionDelivered": 0.0,
+            "insulinRequested": 0.2,
+            "completionStatusId": 3,
+            "completionStatusDesc": "Completed",
+            "bolusIsComplete": 1,
+            "bolusRequestId": 3636.0,
+            "bolusCompletionId": 3636.0
+        },
+        "standardPercent": 50.0,
+        "targetBG": 110,
+        "userOverride": 1,
+        "type": "Bolus",
+        "description": "Extended 50.00%/0.00",
+        "sourceRecId": 1209631944,
+        "eventTypeId": 0,
+        "indexId": 0,
+        "uploadId": 0,
+        "interactive": 0,
+        "tempRateId": 0,
+        "tempRateCompleted": 0,
+        "tempRateActivated": 0
+    }
+    Extended bolus (complete):
+    {
+        "actualTotalBolusRequested": 0.4,
+        "bg": 131,
+        "bolex": {
+            "size": 0.2,
+            "bolexStartDateTime": "2022-08-09T23:20:04",
+            "insulinDelivered": {
+                "completionDateTime": "2022-08-09T23:35:03",
+                "value": 0.2
+            },
+            "iob": 5.7,
+            "completionStatusId": 3.0,
+            "completionStatusDesc": "Completed",
+            "extendedBolusIsComplete": 1,
+            "insulinRequested": 0.2,
+            "bolexCompletionId": 16757133
+        },
+        "bolusRequestOptions": "Extended",
+        "bolusType": "Carb",
+        "carbSize": 0,
+        "correctionBolusSize": 0.0,
+        "correctionFactor": 30.0,
+        "declinedCorrection": 0,
+        "duration": 15,
+        "eventDateTime": "2022-08-09T23:19:15",
+        "eventHistoryReportDetails": "CF 1:30 - Carb Ratio 1:6 - Target BG 110<br/>Override: Pump calculated Bolus = 0.0 units",
+        "eventHistoryReportEventDesc": "Food Bolus: 50&#37; Extended 15 mins",
+        "foodBolusSize": 0.0,
+        "iob": 5.87,
+        "isQuickBolus": 0,
+        "note": {
+            "id": 0,
+            "indexId": "631597",
+            "eventTypeId": 64,
+            "sourceRecordId": 0,
+            "eventId": 0,
+            "active": false
+        },
+        "requestDateTime": "2022-08-09T23:19:15",
+        "standard": {
+            "insulinDelivered": {
+                "completionDateTime": "2022-08-09T23:20:04",
+                "value": 0.2
+            },
+            "foodDelivered": 0.0,
+            "correctionDelivered": 0.0,
+            "insulinRequested": 0.2,
+            "completionStatusId": 3,
+            "completionStatusDesc": "Completed",
+            "bolusIsComplete": 1,
+            "bolusRequestId": 3636.0,
+            "bolusCompletionId": 3636.0
+        },
+        "standardPercent": 50.0,
+        "targetBG": 110,
+        "userOverride": 1,
+        "type": "Bolus",
+        "description": "Extended 50.00%/0.00",
+        "sourceRecId": 1209631944,
+        "eventTypeId": 0,
+        "indexId": 0,
+        "uploadId": 0,
+        "interactive": 0,
+        "tempRateId": 0,
+        "tempRateCompleted": 0,
+        "tempRateActivated": 0
+    }
+    CGM Calibration (Therapy Event Type BG):
+    {   'bg': 160,
+        'cgmCalibration': 1,
+        'description': 'BG',
+        'deviceType': 't:slim X2 Insulin Pump',
+        'eventDateTime': '2022-08-20T07:25:24',
+        'eventTypeId': 16,
+        'indexId': 844955,
+        'interactive': 0,
+        'iob': 0.75,
+        'note': {   'active': False,
+                    'eventId': 0,
+                    'eventTypeId': 16,
+                    'id': 0,
+                    'indexId': '',
+                    'sourceRecordId': 0},
+        'requestDateTime': '0001-01-01T00:00:00',
+        'serialNumber': 'xxx',
+        'sourceRecId': 793549667,
+        'tempRateActivated': 0,
+        'tempRateCompleted': 0,
+        'tempRateId': 0,
+        'type': 'BG',
+        'uploadId': 0}
+    """
+
+class BasalTherapyEvent(TherapyEvent):
+    """
+    {
+        'basalRate': {
+            'duration': 0, 
+            'percent': 0, 
+            'value': 0.0
+        }, 
+        'displayInHistory': 0, 
+        'eventDateTime': '2022-12-02T00:00:00', 
+        'note': {
+            'id': 0, 
+            'indexId': '16403', 
+            'eventTypeId': 90, 
+            'sourceRecordId': 0, 
+            'eventId': 0, 
+            'active': False
+        }, 
+        'noteDate': {}, 
+        'requestDateTime': '0001-01-01T00:00:00', 
+        'type': 'Basal', 
+        'description': 'NDE', 
+        'sourceRecId': xxx, 
+        'eventTypeId': 0, 
+        'indexId': 0, 
+        'uploadId': 0, 
+        'interactive': 1, 
+        'tempRateId': 0, 
+        'tempRateCompleted': 0, 
+        'tempRateActivated': 0
+    }
+    """
+    basalRateValue = None
+    basalRatePercent = None
+    basalRateDuration = None
+    eventTime = None
+
+
+    @classmethod
+    def parse(_, json):
+        self = CGMTherapyEvent()
+        TherapyEvent.parse(self, json)
+        if 'basalRate' in json:
+            self.basalRateValue = json['basalRate']['value']
+            self.basalRatePercent = json['basalRate']['percent']
+            self.basalRateDuration = json['basalRate']['duration']
+        self.eventTime = json['eventDateTime']
+        return self
@@ -0,0 +1,24 @@
+#!/usr/bin/env python3
+
+class Time:
+    def __init__(self, hour: int, min: int):
+        self.hour = hour
+        self.min = min
+    
+    @classmethod
+    def parse(cls, input):
+        if ' ' not in input:
+            raise ValueError('unable to parse time: %s' % input)
+
+        hrmin, ampm = input.split(' ')
+        
+        hr, min = hrmin.split(':')
+        hr = int(hr)
+        min = int(min)
+
+        if ampm.lower() == 'pm':
+            hr += 12
+        elif ampm.lower() != 'am':
+            raise ValueError('unable to parse time: %s' % input)
+        
+        return cls(hr, min)
@@ -0,0 +1,172 @@
+header = '''# THIS FILE IS AUTOGENERATED. DO NOT EDIT.
+import struct
+import logging
+from dataclasses import dataclass
+from enum import Enum, IntFlag
+from .raw_event import RawEvent
+
+logger = logging.getLogger(__name__)
+
+EVENT_LEN = 26
+
+@dataclass
+class BaseEvent:
+    @staticmethod
+    def build(raw):
+        raise NotImplemented
+
+'''
+
+TYPE_TO_STRUCT = {
+    'uint8': '>B',
+    'int8': '>b',
+    'uint16': '>H',
+    'int16': '>h',
+    'uint32': '>I',
+    'float32': '>f',
+}
+
+for k, v in TYPE_TO_STRUCT.items():
+    header += f"{k.upper()} = '{v}'\n"
+
+TYPE_TO_PYOBJ = {
+    'uint8': 'int',
+    'int8': 'int',
+    'uint16': 'int',
+    'int16': 'int',
+    'uint32': 'int',
+    'float32': 'float',
+}
+
+HEADER_SIZE = 10
+def unpack_command_for(field_def):
+    return f'struct.unpack_from({field_def["type"].upper()}, raw[:EVENT_LEN], {HEADER_SIZE + field_def["offset"]})'
+
+TEMPLATE = '''
+@dataclass
+class {name}(BaseEvent):
+    """{id}: {raw_name}"""
+    ID = {id}
+    NAME = "{raw_name}"
+
+    raw: RawEvent
+{fields}
+
+{transform_funcs}
+    @staticmethod
+    def build(raw):
+{build_p1}
+
+        return {name}(
+            raw = RawEvent.build(raw),
+{build_p2}
+        )
+
+    @property
+    def eventTimestamp(self):
+        return self.raw.timestamp
+
+    @property
+    def eventId(self):
+        return self.raw.seqNum
+
+'''
+
+def firstLower(text):
+    if not text:
+        return text
+    return f'{text[0].lower()}{text[1:]}'
+
+def eventNameFormat(text):
+    if not text:
+        return text
+    return text.replace('_', ' ').title().replace(' ', '')
+
+def fieldNameFormat(text):
+    if not text or all([i.isupper() for i in text]):
+        return text
+    return firstLower(text.replace('_', ' ').title().replace(' ', ''))
+
+
+def build_fields(event_def):
+    ret = []
+    for name, field in event_def["data"].items():
+        suffix = 'Raw' if "transform" in field else ''
+        f = f'{fieldNameFormat(name)}{suffix}: {TYPE_TO_PYOBJ[field["type"]]}'
+        if "uom" in field:
+            f += ' # ' + field['uom']
+        ret.append(f)
+    return '\n'.join([f'{" "*4}{f}' for f in ret])
+
+
+
+def build_decode(event_def):
+    p1s = []
+    p2s = []
+    for name, field in event_def["data"].items():
+        p1 = f'{fieldNameFormat(name)}, = {unpack_command_for(field)}'
+        p1s.append(p1)
+
+        suffix = 'Raw' if "transform" in field else ''
+
+        p2 = f'{fieldNameFormat(name)}{suffix} = {fieldNameFormat(name)},'
+        p2s.append(p2)
+
+
+    return '\n'.join([f'{" "*8}{f}' for f in p1s]), '\n'.join([f'{" "*12}{f}' for f in p2s])
+
+def build_transform_funcs(event_def):
+    try:
+        from transforms import TRANSFORMS
+    except ImportError:
+        from .transforms import TRANSFORMS
+
+    ret = []
+
+    for name, field in event_def["data"].items():
+        if not "transform" in field:
+            continue
+
+        for tx in field["transform"]:
+            ret += TRANSFORMS[tx[0]](event_def, name, fieldNameFormat(name), field, tx[1])
+
+    return '\n'.join([f'{" "*4}{f}' if f else '' for f in ret])
+
+def build_event(event_id, event_def):
+    return TEMPLATE.format(
+        name = eventNameFormat(event_def["name"]),
+        fields = build_fields(event_def),
+        build_p1 = build_decode(event_def)[0],
+        build_p2 = build_decode(event_def)[1],
+        transform_funcs = build_transform_funcs(event_def),
+        id = event_id,
+        raw_name = event_def["name"]
+    )
+
+def build_events_map(events):
+    ret = ['EVENT_IDS = {']
+    for event_id, event_def in events.items():
+        ret += [f'{" "*4}{event_id}: {eventNameFormat(event_def["name"])},']
+
+    ret += ['}', '']
+
+    ret += ['EVENT_NAMES = {']
+    for event_id, event_def in events.items():
+        ret += [f'{" "*4}"{event_def["name"]}": {eventNameFormat(event_def["name"])},']
+
+    ret += ['}', '']
+
+    return '\n'.join(ret)
+
+if __name__ == '__main__':
+    import json
+
+    output = f'{header}'
+    with open("events.json", "r") as f:
+        j = json.loads(f.read())
+        for event_id, event_def in j["events"].items():
+            output += build_event(event_id, event_def)
+
+        output += build_events_map(j["events"])
+
+    print(output)
@@ -0,0 +1,15 @@
+import struct
+import base64
+
+from dataclasses import dataclass
+
+from .raw_event import RawEvent, EVENT_LEN
+from .events import EVENT_IDS
+from .utils import batched
+
+
+Event = lambda x: EVENT_IDS[RawEvent.build(x).id].build(x)
+Events = lambda x: (Event(bytearray(e)) for e in batched(x, EVENT_LEN))
+
+def decode_raw_events(raw):
+    return base64.b64decode(raw)
@@ -0,0 +1,35 @@
+import struct
+import arrow
+
+from dataclasses import dataclass
+
+EVENT_LEN = 26
+UINT16 = '>H'
+UINT32 = '>I'
+TANDEM_EPOCH = 1199145600
+
+@dataclass
+class RawEvent:
+    source: int
+    id: int
+    timestampRaw: int
+    seqNum: int
+    raw: bytearray
+
+    @staticmethod
+    def build(raw):
+        source_and_id, = struct.unpack_from(UINT16, raw[:EVENT_LEN], 0)
+        timestampRaw, = struct.unpack_from(UINT32, raw[:EVENT_LEN], 2)
+        seqNum, = struct.unpack_from(UINT32, raw[:EVENT_LEN], 6)
+
+        return RawEvent(
+            source = (source_and_id & 0xF000) >> 12,
+            id = source_and_id & 0x0FFF,
+            timestampRaw = timestampRaw,
+            seqNum = seqNum,
+            raw = raw
+        )
+    
+    @property
+    def timestamp(self):
+        return arrow.get(TANDEM_EPOCH + self.timestampRaw)
@@ -0,0 +1,144 @@
+
+ALERTS_DICT = {
+    "0": "LOW_INSULIN_ALERT",
+    "1": "USB_CONNECTION_ALERT",
+    "2": "LOW_POWER_ALERT",
+    "3": "LOW_POWER_ALERT2",
+    "4": "DATA_ERROR_ALERT",
+    "5": "AUTO_OFF_ALERT",
+    "6": "MAX_BASAL_RATE_ALERT",
+    "7": "POWER_SOURCE_ALERT",
+    "8": "MIN_BASAL_ALERT",
+    "9": "CONNECTION_ERROR_ALERT",
+    "10": "CONNECTION_ERROR_ALERT2",
+    "11": "INCOMPLETE_BOLUS_ALERT",
+    "12": "INCOMPLETE_TEMP_RATE_ALERT",
+    "13": "INCOMPLETE_CARTRIDGE_CHANGE_ALERT",
+    "14": "INCOMPLETE_FILL_TUBING_ALERT",
+    "15": "INCOMPLETE_FILL_CANNULA_ALERT",
+    "16": "INCOMPLETE_SETTING_ALERT",
+    "17": "LOW_INSULIN_ALERT2",
+    "18": "MAX_BASAL_ALERT",
+    "19": "LOW_TRANSMITTER_ALERT",
+    "20": "TRANSMITTER_ALERT",
+    "21": "DEFAULT_ALERT_21",
+    "22": "SENSOR_EXPIRING_ALERT",
+    "23": "PUMP_REBOOTING_ALERT",
+    "24": "DEVICE_CONNECTION_ERROR",
+    "25": "CGM_GRAPH_REMOVED",
+    "26": "MIN_BASAL_ALERT2",
+    "27": "INCOMPLETE_CALIBRATION",
+    "28": "CALIBRATION_TIMEOUT",
+    "29": "INVALID_TRANSMITTER_ID",
+    "30": "DEFAULT_ALERT_30",
+    "32": "DEFAULT_ALERT_32",
+    "33": "BUTTON_ALERT",
+    "34": "QUICK_BOLUS_ALERT",
+    "35": "BASAL_IQ_ALERT",
+    "36": "DEFAULT_ALERT_36",
+    "37": "DEFAULT_ALERT_37",
+    "38": "DEFAULT_ALERT_38",
+    "39": "TRANSMITTER_END_OF_LIFE",
+    "40": "CGM_ERROR",
+    "41": "CGM_ERROR2",
+    "42": "CGM_ERROR3",
+    "43": "DEFAULT_ALERT_43",
+    "44": "TRANSMITTER_EXPIRING_ALERT",
+    "45": "TRANSMITTER_EXPIRING_ALERT2",
+    "46": "TRANSMITTER_EXPIRING_ALERT3",
+    "47": "DEFAULT_ALERT_47",
+    "48": "CGM_UNAVAILABLE",
+    "49": "DEFAULT_ALERT_49",
+    "50": "DEFAULT_ALERT_50",
+    "51": "DEFAULT_ALERT_51",
+    "52": "DEFAULT_ALERT_52",
+    "53": "DEFAULT_ALERT_53",
+    "54": "DEVICE_PAIRED",
+    "55": "DEFAULT_ALERT_55",
+    "56": "DEFAULT_ALERT_56",
+    "57": "DEFAULT_ALERT_57",
+    "58": "DEFAULT_ALERT_58",
+    "59": "DEFAULT_ALERT_59",
+    "60": "DEFAULT_ALERT_60",
+    "61": "DEFAULT_ALERT_61",
+    "62": "DEFAULT_ALERT_62",
+    "63": "DEFAULT_ALERT_63",
+}
+
+ALARMS_DICT = {
+    "0": "CARTRIDGE_ALARM",
+    "1": "CARTRIDGE_ALARM2",
+    "2": "OCCLUSION_ALARM",
+    "3": "PUMP_RESET_ALARM",
+    "4": "DEFAULT_ALARM_4",
+    "5": "CARTRIDGE_ALARM3",
+    "6": "CARTRIDGE_ALARM4",
+    "7": "AUTO_OFF_ALARM",
+    "8": "EMPTY_CARTRIDGE_ALARM",
+    "9": "CARTRIDGE_ALARM5",
+    "10": "TEMPERATURE_ALARM",
+    "11": "TEMPERATURE_ALARM2",
+    "12": "BATTERY_SHUTDOWN_ALARM",
+    "13": "DEFAULT_ALARM_13",
+    "14": "INVALID_DATE_ALARM",
+    "15": "TEMPERATURE_ALARM3",
+    "16": "CARTRIDGE_ALARM6",
+    "17": "DEFAULT_ALARM_17",
+    "18": "RESUME_PUMP_ALARM",
+    "19": "DEFAULT_ALARM_19",
+    "20": "CARTRIDGE_ALARM7",
+    "21": "ALTITUDE_ALARM",
+    "22": "STUCK_BUTTON_ALARM",
+    "23": "RESUME_PUMP_ALARM2",
+    "24": "ATMOSPHERIC_PRESSURE_OUT_OF_RANGE_ALARM",
+    "25": "CARTRIDGE_REMOVED_ALARM",
+    "26": "OCCLUSION_ALARM2",
+    "27": "DEFAULT_ALARM_27",
+    "28": "DEFAULT_ALARM_28",
+    "29": "CARTRIDGE_ALARM10",
+    "30": "CARTRIDGE_ALARM11",
+    "31": "CARTRIDGE_ALARM12",
+    "32": "DEFAULT_ALARM_32",
+    "33": "DEFAULT_ALARM_33",
+    "34": "DEFAULT_ALARM_34",
+    "35": "DEFAULT_ALARM_35",
+    "36": "DEFAULT_ALARM_36",
+    "37": "DEFAULT_ALARM_37",
+    "38": "DEFAULT_ALARM_38",
+    "39": "DEFAULT_ALARM_39",
+    "40": "DEFAULT_ALARM_40",
+    "41": "DEFAULT_ALARM_41",
+    "42": "DEFAULT_ALARM_42",
+    "43": "DEFAULT_ALARM_43",
+    "44": "DEFAULT_ALARM_44",
+    "45": "DEFAULT_ALARM_45",
+    "46": "DEFAULT_ALARM_46",
+    "47": "DEFAULT_ALARM_47",
+    "48": "DEFAULT_ALARM_48",
+    "49": "DEFAULT_ALARM_49",
+    "50": "DEFAULT_ALARM_50",
+    "51": "DEFAULT_ALARM_51",
+    "52": "DEFAULT_ALARM_52",
+    "53": "DEFAULT_ALARM_53",
+    "54": "DEFAULT_ALARM_54",
+    "55": "DEFAULT_ALARM_55",
+    "56": "DEFAULT_ALARM_56",
+    "57": "DEFAULT_ALARM_57",
+    "58": "DEFAULT_ALARM_58",
+    "59": "DEFAULT_ALARM_59",
+    "60": "DEFAULT_ALARM_60",
+    "61": "DEFAULT_ALARM_61",
+    "62": "DEFAULT_ALARM_62",
+    "63": "DEFAULT_ALARM_63",
+}
+
+CGM_ALERTS_DICT = {
+    "11": "CGM Sensor Fail",
+    "13": "CGM Sensor Expired",
+    "14": "CGM Out Of Range",
+    "20": "CGM Transmitter Error",
+    "26": "CGM Temperature",
+    "27": "CGM Failed Connection",
+    "39": "CGM Transmitter Expired",
+    "40": "Pump Bluetooth Error"
+}
@@ -0,0 +1,121 @@
+import json
+try:
+    from static_dicts import ALERTS_DICT, ALARMS_DICT, CGM_ALERTS_DICT
+except ImportError:
+    from .static_dicts import ALERTS_DICT, ALARMS_DICT, CGM_ALERTS_DICT
+
+def enumNameFormat(text):
+    if not text:
+        return text
+    t = text.replace('_', ' ').title().replace(' ', '')
+    if t.startswith('no,'):
+        return 'No'
+    if t.startswith('yes,'):
+        return 'Yes'
+
+    rem = None
+    for i in '-,.':
+        spl = t.split(i)
+        t = spl[0]
+        if len(spl) > 1:
+            rem = rem or spl[1]
+
+    for i in '()/"\u201c\u201d':
+        t = t.replace(i, '')
+
+    if t.lower() == 'false':
+        return 'FalseVal'
+    if t.lower() == 'true':
+        return 'TrueVal'
+    if t.lower() == 'none':
+        return 'NoneVal'
+    if t.lower() == 'reserved':
+        return None
+    if t.lower() == 'unused':
+        return None
+    if t.lower() == 'unavailable' and rem:
+        suffix = enumNameFormat(rem)
+        t += f'{suffix[0].lower()}{suffix[1:]}'
+
+    return f'{t[0].upper()}{t[1:]}'
+
+def transform_enum(event_def, name, name_fmt, field, tx):
+    out = []
+    lines_for_out = json.dumps(tx, indent=4).splitlines()
+    out += [f'{enumNameFormat(name_fmt)}Map = {lines_for_out[0]}']
+    out += lines_for_out[1:]
+    out += ['']
+    out += [f'class {enumNameFormat(name_fmt)}Enum(Enum):']
+    out += [
+        f'    {enumNameFormat(v)} = {k}' for k, v in tx.items() if enumNameFormat(v)
+    ]
+    out += ['']
+    out += [
+        '@property',
+        f'def {name_fmt}(self):',
+        f'    try:',
+        f'        return self.{enumNameFormat(name_fmt)}Enum(self.{name_fmt}Raw)',
+        f'    except ValueError as e:',
+        f'        logger.error("Invalid {name_fmt}Raw in {enumNameFormat(name_fmt)} for "+str(self))',
+        f'        logger.error(e)',
+        f'        return None',
+        ''
+    ]
+
+    return out
+
+def transform_dictionary(event_def, name, name_fmt, field, tx):
+    if tx == 'alerts':
+        return transform_enum(event_def, name, name_fmt, field, ALERTS_DICT)
+
+    if tx == 'alarms':
+        return transform_enum(event_def, name, name_fmt, field, ALARMS_DICT)
+
+    if tx == 'dalerts':
+        return transform_enum(event_def, name, name_fmt, field, CGM_ALERTS_DICT)
+    return [f'# Dictionary unknown: {tx}']
+
+def transform_bitmask(event_def, name, name_fmt, field, tx):
+    out = []
+    lines_for_out = json.dumps(tx, indent=4).splitlines()
+    out += [f'{enumNameFormat(name_fmt)}Map = {lines_for_out[0]}']
+    out += lines_for_out[1:]
+    out += ['']
+    out += [f'class {enumNameFormat(name_fmt)}Bitmask(IntFlag):',]
+    out += [
+        f'    {enumNameFormat(v)} = 2**{k}' for k, v in tx.items() if enumNameFormat(v)
+    ]
+    out += ['']
+    out += [
+        '@property',
+        f'def {name_fmt}(self):',
+        f'    try:',
+        f'        return self.{enumNameFormat(name_fmt)}Bitmask(self.{name_fmt}Raw)',
+        f'    except ValueError as e:',
+        f'        logger.error("Invalid {name_fmt}Raw in {enumNameFormat(name_fmt)}Bitmask for "+str(self))',
+        f'        logger.error(e)',
+        f'        return None',
+        f''
+    ]
+
+    return out
+
+def transform_ratio(event_def, name, name_fmt, field, tx):
+    out = []
+    out += [
+        '@property',
+        f'def {name_fmt}(self):',
+        f'    return self.{name_fmt}Raw * {tx}',
+        ''
+    ]
+
+    return out
+
+
+
+TRANSFORMS = {
+    'enum': transform_enum,
+    'dictionary': transform_dictionary,
+    'bitmask': transform_bitmask,
+    'ratio': transform_ratio
+}
@@ -0,0 +1,23 @@
+import itertools
+
+def batched(iterable, n):
+    """
+    Batch data into iterators of length n. The last batch may be shorter.
+    This is a polyfill for itertools.batched() in Python 3.12+
+    """
+    if n < 1:
+        raise ValueError('n must be at least one')
+    it = iter(iterable)
+    while True:
+        chunk_it = itertools.islice(it, n)
+        try:
+            first_el = next(chunk_it)
+        except StopIteration:
+            return
+        yield itertools.chain((first_el,), chunk_it)
+
+def bitmask_to_list(intflag):
+    n = type(intflag).__name__
+    if not str(intflag).startswith(n):
+        return []
+    return str(intflag)[len(n)+1:].split('|')
@@ -0,0 +1,37 @@
+from .secret import ENABLE_TESTING_MODES
+
+"""Supported synchronization features."""
+BASAL = "BASAL"
+BOLUS = "BOLUS"
+IOB = "IOB"
+BOLUS_BG = "BOLUS_BG"
+CGM = "CGM"
+PUMP_EVENTS = "PUMP_EVENTS"
+PUMP_EVENTS_BASAL_SUSPENSION = "PUMP_EVENTS_BASAL_SUSPENSION"
+PROFILES = "PROFILES"
+CGM_ALERTS = "CGM_ALERTS"
+
+DEFAULT_FEATURES = [
+    BASAL,
+    BOLUS,
+    PUMP_EVENTS,
+    PROFILES
+]
+
+ALL_FEATURES = [
+    BASAL,
+    BOLUS,
+    IOB,
+    PUMP_EVENTS,
+    PUMP_EVENTS_BASAL_SUSPENSION,
+    PROFILES,
+    CGM,
+    CGM_ALERTS,
+]
+
+
+# These modes are not yet ready for wide use.
+if ENABLE_TESTING_MODES:
+    ALL_FEATURES += [
+        BOLUS_BG
+    ]
@@ -1,24 +1,40 @@
-import sys
+import datetime
 import requests
 import hashlib
 import time
 import urllib.parse
+import arrow
+import logging

 from urllib.parse import urljoin

 from .api.common import ApiException
 from .parser.nightscout import ENTERED_BY

-# try:
-#     from .secret import NS_URL, NS_SECRET
-# except Exception:
-#     print('Unable to import Nightscout secrets from secret.py')
-#     sys.exit(1)
+def format_datetime(date):
+	return arrow.get(date).isoformat()

+def time_range(field_name, start_time, end_time, t_to_space=False):
+	def fmt(date):
+		ret = format_datetime(date)
+		if t_to_space:
+			return ret.replace('T', ' ')
+		return ret
+	arg = ''
+	if start_time:
+		arg += '&find[%s][$gte]=%s' % (field_name, fmt(start_time))
+	if end_time:
+		arg += '&find[%s][$lte]=%s' % (field_name, fmt(end_time))
+	return arg
+
+
+logger = logging.getLogger(__name__)
 class NightscoutApi:
-	def __init__(self, url, secret):
+	def __init__(self, url, secret, skip_verify=False, ignore_conn_errors=False):
 		self.url = url
 		self.secret = secret
+		self.verify = False if skip_verify else None
+		self.ignore_conn_errors = ignore_conn_errors


 	def upload_entry(self, ns_format, entity='treatments'):
@@ -26,51 +42,117 @@ class NightscoutApi:
 			'Accept': 'application/json',
 			'Content-Type': 'application/json',
 			'api-secret': hashlib.sha1(self.secret.encode()).hexdigest()
-		})
+		}, verify=self.verify)
 		if r.status_code != 200:
-			raise ApiException(r.status_code, "Nightscout upload response: %s" % r.text)
+			raise ApiException(r.status_code, "Nightscout upload %s response: %s" % (r.status_code, r.text))

 	def delete_entry(self, entity):
 		r = requests.delete(urljoin(self.url, 'api/v1/' + entity + '?api_secret=' + self.secret), json={}, headers={
 			'Accept': 'application/json',
 			'Content-Type': 'application/json',
 			'api-secret': hashlib.sha1(self.secret.encode()).hexdigest()
-		})
+		}, verify=self.verify)
 		if r.status_code != 200:
-			raise ApiException(r.status_code, "Nightscout delete response: %s" % r.text)
+			raise ApiException(r.status_code, "Nightscout delete %s response: %s" % (r.status_code, r.text))

 	def put_entry(self, ns_format, entity):
 		r = requests.put(urljoin(self.url, 'api/v1/' + entity + '?api_secret=' + self.secret), json=ns_format, headers={
 			'Accept': 'application/json',
 			'Content-Type': 'application/json',
 			'api-secret': hashlib.sha1(self.secret.encode()).hexdigest()
-		})
+		}, verify=self.verify)
 		if r.status_code != 200:
-			raise ApiException(r.status_code, "Nightscout put response: %s" % r.text)
+			raise ApiException(r.status_code, "Nightscout put %s response: %s" % (r.status_code, r.text))

-	def last_uploaded_entry(self, eventType):
-		latest = requests.get(urljoin(self.url, 'api/v1/treatments?count=1&find[enteredBy]=' + urllib.parse.quote(ENTERED_BY) + '&find[eventType]=' + urllib.parse.quote(eventType) + '&ts=' + str(time.time())), headers={
-			'api-secret': hashlib.sha1(self.secret.encode()).hexdigest()
-		})
-		if latest.status_code != 200:
-			raise ApiException(latest.status_code, "Nightscout treatments response: %s" % latest.text)
+	def last_uploaded_entry(self, eventType, time_start=None, time_end=None):
+		def internal(t_to_space):
+			dateFilter = time_range('created_at', time_start, time_end, t_to_space=t_to_space)
+			latest = requests.get(urljoin(self.url, 'api/v1/treatments?count=1&find[enteredBy]=' + urllib.parse.quote(ENTERED_BY) + '&find[eventType]=' + urllib.parse.quote(eventType) + dateFilter + '&ts=' + str(time.time())), headers={
+				'api-secret': hashlib.sha1(self.secret.encode()).hexdigest()
+			}, verify=self.verify)
+			if latest.status_code != 200:
+				raise ApiException(latest.status_code, "Nightscout last_uploaded_entry %s response: %s" % (latest.status_code, latest.text))

-		j = latest.json()
-		if j and len(j) > 0:
-			return j[0]
-		return None
+			j = latest.json()
+			if j and len(j) > 0:
+				return j[0]
+			return None
+		try:
+			ret = None
+			try:
+				ret = internal(False)
+			except ApiException as e:
+				#logger.warning("last_uploaded_entry with no t_to_space: %s", e)
+				ret = None
+			if ret is None and (time_start or time_end):
+				try:
+					ret = internal(True)
+				except ApiException as e:
+					#logger.warning("last_uploaded_entry with t_to_space: %s", e)
+					ret = None
+				if ret is not None:
+					logger.warning("last_uploaded_entry with eventType=%s time_start=%s time_end=%s only returned data when timestamps contained a space" % (eventType, time_start, time_end))
+			return ret
+		except requests.exceptions.ConnectionError as e:
+			if self.ignore_conn_errors:
+				logger.warn('Ignoring ConnectionError because ignore_conn_errors=true', e)
+			else:
+				raise e

-	def last_uploaded_activity(self, activityType):
-		latest = requests.get(urljoin(self.url, 'api/v1/activity?find[enteredBy]=' + urllib.parse.quote(ENTERED_BY) + '&find[activityType]=' + urllib.parse.quote(activityType) + '&ts=' + str(time.time())), headers={
-			'api-secret': hashlib.sha1(self.secret.encode()).hexdigest()
-		})
-		if latest.status_code != 200:
-			raise ApiException(latest.status_code, "Nightscout activity response: %s" % latest.text)
+	def last_uploaded_bg_entry(self, time_start=None, time_end=None):
+		def internal(t_to_space):
+			dateFilter = time_range('dateString', time_start, time_end, t_to_space=t_to_space)
+			latest = requests.get(urljoin(self.url, 'api/v1/entries.json?count=1&find[device]=' + urllib.parse.quote(ENTERED_BY) + dateFilter + '&ts=' + str(time.time())), headers={
+				'api-secret': hashlib.sha1(self.secret.encode()).hexdigest()
+			}, verify=self.verify)
+			if latest.status_code != 200:
+				raise ApiException(latest.status_code, "Nightscout last_uploaded_bg_entry %s response: %s" % (latest.status_code, latest.text))

-		j = latest.json()
-		if j and len(j) > 0:
-			return j[0]
-		return None
+			j = latest.json()
+			if j and len(j) > 0:
+				return j[0]
+			return None
+
+		try:
+			ret = internal(False)
+			if ret is None and (time_start or time_end):
+				ret = internal(True)
+				if ret is not None:
+					logger.warning("last_uploaded_bg_entry with time_start=%s time_end=%s only returned data when timestamps contained a space" % (time_start, time_end))
+
+			return ret
+		except requests.exceptions.ConnectionError as e:
+			if self.ignore_conn_errors:
+				logger.warn('Ignoring ConnectionError because ignore_conn_errors=true', e)
+			else:
+				raise e
+
+	def last_uploaded_activity(self, activityType, time_start=None, time_end=None):
+		def internal(t_to_space):
+			dateFilter = time_range('created_at', time_start, time_end, t_to_space=t_to_space)
+			latest = requests.get(urljoin(self.url, 'api/v1/activity?find[enteredBy]=' + urllib.parse.quote(ENTERED_BY) + '&find[activityType]=' + urllib.parse.quote(activityType) + dateFilter + '&ts=' + str(time.time())), headers={
+				'api-secret': hashlib.sha1(self.secret.encode()).hexdigest()
+			}, verify=self.verify)
+			if latest.status_code != 200:
+				raise ApiException(latest.status_code, "Nightscout activity %s response: %s" % (latest.status_code, latest.text))
+
+			j = latest.json()
+			if j and len(j) > 0:
+				return j[0]
+			return None
+
+		try:
+			ret = internal(False)
+			if ret is None and (time_start or time_end):
+				ret = internal(True)
+				if ret is not None:
+					logger.warning("last_uploaded_activity with activityType=%s time_start=%s time_end=%s only returned data when timestamps contained a space" % (activityType, time_start, time_end))
+			return ret
+		except requests.exceptions.ConnectionError as e:
+			if self.ignore_conn_errors:
+				logger.warn('Ignoring ConnectionError because ignore_conn_errors=true', e)
+			else:
+				raise e

 	"""
 	Returns general status information about the Nightscout server.
@@ -78,7 +160,21 @@ class NightscoutApi:
 	def api_status(self):
 		status = requests.get(urljoin(self.url, 'api/v1/status.json'), headers={
 			'api-secret': hashlib.sha1(self.secret.encode()).hexdigest()
-		})
+		}, verify=self.verify)
 		if status.status_code != 200:
 			raise Exception('HTTP error status code (%d) from Nightscout: %s' % (status.status_code, status.text))
-		return status.json()
+		return status.json()
+
+	"""
+	Returns information on the currently configured Nightscout profile data store
+	(contains all profiles in Nightscout under one mongo object).
+	"""
+	def current_profile(self, time_start=None, time_end=None):
+		r = requests.get(urljoin(self.url, 'api/v1/profile/current?api_secret=' + self.secret), json={}, headers={
+			'Accept': 'application/json',
+			'Content-Type': 'application/json',
+			'api-secret': hashlib.sha1(self.secret.encode()).hexdigest()
+		}, verify=self.verify)
+		if r.status_code != 200:
+			raise ApiException(r.status_code, "Nightscout current_profile %s response: %s" % (r.status_code, r.text))
+		return r.json()
@@ -0,0 +1,27 @@
+from tconnectsync.domain.therapy_event import BolusTherapyEvent, CGMTherapyEvent, BGTherapyEvent, BasalTherapyEvent
+from tconnectsync.parser.tconnect import TConnectEntry
+
+import logging
+
+logger = logging.getLogger(__name__)
+
+def split_therapy_events(ciqTherapyEvents):
+    bolusEvents = []
+    cgmEvents = []
+    bgEvents = []
+    basalEvents = []
+    for e in ciqTherapyEvents['event']:
+        event = TConnectEntry.parse_therapy_event(e)
+        if isinstance(event, BolusTherapyEvent):
+            bolusEvents.append(event)
+        elif isinstance(event, CGMTherapyEvent): 
+            cgmEvents.append(event)
+        elif isinstance(event, BGTherapyEvent):
+            bgEvents.append(event)
+        elif isinstance(event, BasalTherapyEvent):
+            basalEvents.append(event)
+
+        
+    logger.debug("split_therapy_events: %d bolus, %d CGM, %d BG, %d basal" % (len(bolusEvents), len(cgmEvents), len(bgEvents), len(basalEvents)))
+    # TODO: BG events (CGM Calibration) values are not currently returned from ciq_therapy_events.py
+    return bolusEvents, cgmEvents
@@ -1,41 +1,325 @@
+import arrow
+
+from ..domain.device_settings import Profile, DeviceSettings
+from ..domain.tandemsource.pump_settings import PumpProfile, PumpSettings
+from ..secret import TIMEZONE_NAME, NIGHTSCOUT_PROFILE_CARBS_HR_VALUE, NIGHTSCOUT_PROFILE_DELAY_VALUE
+
 ENTERED_BY = "Pump (tconnectsync)"
+
 BASAL_EVENTTYPE = "Temp Basal"
 BOLUS_EVENTTYPE = "Combo Bolus"
+SITECHANGE_EVENTTYPE = "Site Change"
+BASALSUSPENSION_EVENTTYPE = "Basal Suspension"
+BASALRESUME_EVENTTYPE = "Basal Resume"
+ACTIVITY_EVENTTYPE = "Activity"
+EXERCISE_EVENTTYPE = "Exercise"
+SLEEP_EVENTTYPE = "Sleep"
+ALARM_EVENTTYPE = "Alarm"
+CGM_ALERT_EVENTTYPE = "CGM Alert"
+CGM_START_EVENTTYPE = "Sensor Start"
+CGM_JOIN_EVENTTYPE = "Sensor Start"
+CGM_STOP_EVENTTYPE = "Sensor Stop"
+
 IOB_ACTIVITYTYPE = "tconnect_iob"

+
 """
 Conversion methods for parsing data into Nightscout objects.
 """
 class NightscoutEntry:
    @staticmethod
-    def basal(value, duration_mins, created_at, reason=""):
+    def basal(value, duration_mins, created_at, reason="", pump_event_id=""):
        return {
            "eventType": BASAL_EVENTTYPE,
            "reason": reason,
            "duration": float(duration_mins) if duration_mins else None,
            "absolute": float(value),
+            "rate": float(value),
            "created_at": created_at,
            "carbs": None,
            "insulin": None,
-            "enteredBy": ENTERED_BY
+            "enteredBy": ENTERED_BY,
+            "pump_event_id": pump_event_id
        }

+    # Note that Nightscout is not consistent and uses "Sensor"/"Finger"
+    # for treatment objects, unlike "sgv"/"mbg" for entries
+    SENSOR = "Sensor"
+    FINGER = "Finger"
+
    @staticmethod
-    def bolus(bolus, carbs, created_at, notes=""):
-        return {
+    def bolus(bolus, carbs, created_at, notes="", bg="", bg_type="", pump_event_id=""):
+        data = {
            "eventType": BOLUS_EVENTTYPE,
 			"created_at": created_at,
-			"carbs": int(carbs),
+			"carbs": int(carbs) if carbs else 0,
 			"insulin": float(bolus),
 			"notes": notes,
 			"enteredBy": ENTERED_BY,
+            "pump_event_id": pump_event_id
        }
+        if bg:
+            if bg_type:
+                if bg_type not in (NightscoutEntry.SENSOR, NightscoutEntry.FINGER):
+                    raise InvalidBolusTypeException("bg_type: %s (%s)" % (bg_type, data))
+
+                data.update({
+                    "glucose": str(bg),
+                    "glucoseType": bg_type
+                })
+            else:
+                data.update({
+                    "glucose": str(bg)
+                })
+        return data

    @staticmethod
    def iob(iob, created_at):
        return {
            "activityType": IOB_ACTIVITYTYPE,
-            "iob": iob,
+            "iob": float(iob),
            "created_at": created_at,
            "enteredBy": ENTERED_BY
-        }
+        }
+
+    @staticmethod
+    def entry(sgv, created_at, pump_event_id=""):
+        return {
+            "type": "sgv",
+            "sgv": int(sgv),
+            "date": int(1000 * arrow.get(created_at).timestamp()),
+            "dateString": arrow.get(created_at).strftime('%Y-%m-%dT%H:%M:%S%z'),
+            "device": ENTERED_BY,
+            "pump_event_id": pump_event_id,
+            # delta, direction are undefined
+        }
+
+    @staticmethod
+    def sitechange(created_at, reason="", pump_event_id=""):
+        return {
+            "eventType": SITECHANGE_EVENTTYPE,
+            "reason": reason,
+            "notes": reason,
+            "created_at": created_at,
+            "enteredBy": ENTERED_BY,
+            "pump_event_id": pump_event_id
+        }
+
+    @staticmethod
+    def basalsuspension(created_at, reason="", pump_event_id=""):
+        return {
+            "eventType": BASALSUSPENSION_EVENTTYPE,
+            "reason": reason,
+            "notes": reason,
+            "created_at": created_at,
+            "enteredBy": ENTERED_BY,
+            "pump_event_id": pump_event_id
+        }
+
+    @staticmethod
+    def basalresume(created_at, pump_event_id=""):
+        return {
+            "eventType": BASALRESUME_EVENTTYPE,
+            "reason": "Basal resumed",
+            "notes": "Basal resumed",
+            "created_at": created_at,
+            "enteredBy": ENTERED_BY,
+            "pump_event_id": pump_event_id
+        }
+
+    @staticmethod
+    def alarm(created_at, reason="", pump_event_id=""):
+        return {
+            "eventType": ALARM_EVENTTYPE,
+            "reason": reason,
+            "notes": reason,
+            "created_at": created_at,
+            "enteredBy": ENTERED_BY,
+            "pump_event_id": pump_event_id
+        }
+
+    @staticmethod
+    def cgm_alert(created_at, reason="", pump_event_id=""):
+        return {
+            "eventType": CGM_ALERT_EVENTTYPE,
+            "reason": reason,
+            "notes": reason,
+            "created_at": created_at,
+            "enteredBy": ENTERED_BY,
+            "pump_event_id": pump_event_id
+        }
+
+    @staticmethod
+    def cgm_start(created_at, reason="", pump_event_id=""):
+        return {
+            "eventType": CGM_START_EVENTTYPE,
+            "reason": reason,
+            "notes": reason,
+            "created_at": created_at,
+            "enteredBy": ENTERED_BY,
+            "pump_event_id": pump_event_id
+        }
+
+    @staticmethod
+    def cgm_join(created_at, reason="", pump_event_id=""):
+        return {
+            "eventType": CGM_JOIN_EVENTTYPE,
+            "reason": reason,
+            "notes": reason,
+            "created_at": created_at,
+            "enteredBy": ENTERED_BY,
+            "pump_event_id": pump_event_id
+        }
+
+    @staticmethod
+    def cgm_stop(created_at, reason="", pump_event_id=""):
+        return {
+            "eventType": CGM_STOP_EVENTTYPE,
+            "reason": reason,
+            "notes": reason,
+            "created_at": created_at,
+            "enteredBy": ENTERED_BY,
+            "pump_event_id": pump_event_id
+        }
+
+    @staticmethod
+    def activity(created_at, duration, reason="", event_type=ACTIVITY_EVENTTYPE, pump_event_id=""):
+        return {
+            "eventType": event_type,
+            "reason": reason,
+            "notes": reason,
+            "duration": float(duration),
+            "created_at": created_at,
+            "enteredBy": ENTERED_BY,
+            "pump_event_id": pump_event_id
+        }
+
+    # Tandem-scraped profile to Nightscout profile store entry
+    @staticmethod
+    def profile_store(profile: Profile, device_settings: DeviceSettings) -> dict:
+        return {
+            # insulin duration in hours; Nightscout JS bug requires all top-level fields to be strings
+            "dia": "%s" % (profile.insulin_duration_min / 60),
+            "carbratio": [
+                {
+                    "time": tandem_to_ns_time(segment.time),
+                    "timeAsSeconds": tandem_to_ns_time_seconds(segment.time),
+                    "value": segment.carb_ratio
+                } for segment in profile.segments
+            ],
+
+            "carbs_hr": NIGHTSCOUT_PROFILE_CARBS_HR_VALUE,
+            "delay": NIGHTSCOUT_PROFILE_DELAY_VALUE,
+            "sens": [ # Correction factor
+                {
+                    "time": tandem_to_ns_time(segment.time),
+                    "timeAsSeconds": tandem_to_ns_time_seconds(segment.time),
+                    "value": segment.correction_factor
+                } for segment in profile.segments
+            ],
+            "basal": [
+                {
+                    "time": tandem_to_ns_time(segment.time),
+                    "timeAsSeconds": tandem_to_ns_time_seconds(segment.time),
+                    "value": segment.basal_rate
+                } for segment in profile.segments
+            ],
+            "target_low": [
+                {
+                    "time": "00:00",
+                    "timeAsSeconds": 0,
+                    "value": device_settings.low_bg_threshold
+                }
+            ],
+            "target_high": [
+                {
+                    "time": "00:00",
+                    "timeAsSeconds": 0,
+                    "value": device_settings.high_bg_threshold
+                }
+            ],
+            "timezone": TIMEZONE_NAME, # tconnectsync settings timezone
+            "startDate": "1970-01-01T00:00:00.000Z",
+            "units": "mg/dl"
+        }
+
+
+
+    # TandemSource profile to Nightscout profile store entry
+    @staticmethod
+    def tandemsource_profile_store(profile: PumpProfile, pump_settings: PumpSettings) -> dict:
+        return {
+            # insulin duration in hours; Nightscout JS bug requires all top-level fields to be strings
+            "dia": "%s" % (profile.insulinDuration / 60),
+            "carbratio": [
+                {
+                    "time": minutes_to_ns_time(segment.startTime),
+                    "timeAsSeconds": segment.startTime * 60,
+                    "value": segment.carbRatio / 1000 # milliunits->units
+                } for segment in profile.tDependentSegs
+            ],
+
+            "carbs_hr": NIGHTSCOUT_PROFILE_CARBS_HR_VALUE,
+            "delay": NIGHTSCOUT_PROFILE_DELAY_VALUE,
+            "sens": [ # Correction factor / isf
+                {
+                    "time": minutes_to_ns_time(segment.startTime),
+                    "timeAsSeconds": segment.startTime * 60,
+                    "value": segment.isf
+                } for segment in profile.tDependentSegs
+            ],
+            "basal": [
+                {
+                    "time": minutes_to_ns_time(segment.startTime),
+                    "timeAsSeconds": segment.startTime * 60,
+                    "value": segment.basalRate / 1000 # milliunits->units
+                } for segment in profile.tDependentSegs
+            ],
+            "target_low": [
+                {
+                    "time": "00:00",
+                    "timeAsSeconds": 0,
+                    "value": pump_settings.cgmSettings.lowGlucoseAlert.mgPerDl
+                }
+            ],
+            "target_high": [
+                {
+                    "time": "00:00",
+                    "timeAsSeconds": 0,
+                    "value": pump_settings.cgmSettings.highGlucoseAlert.mgPerDl
+                }
+            ],
+            "timezone": TIMEZONE_NAME, # tconnectsync settings timezone
+            "startDate": "1970-01-01T00:00:00.000Z",
+            "units": "mg/dl"
+        }
+
+def tandem_to_ns_time(tandem_time: str) -> str:
+    numbers, ampm = tandem_time.split(' ')
+    hr, min = numbers.split(':')
+    if ampm.lower().strip() == 'am':
+        return "%02d:%02d" % (int(hr) % 12, int(min))
+    elif ampm.lower().strip() == 'pm':
+        return "%02d:%02d" % (12 + (int(hr) % 12), int(min))
+    raise InvalidTimeException(tandem_time)
+
+def tandem_to_ns_time_seconds(tandem_time: str) -> int:
+    numbers, ampm = tandem_time.split(' ')
+    hr, min = numbers.split(':')
+    if ampm.lower().strip() == 'am':
+        return 60 * (60 * (int(hr) % 12) + int(min))
+    elif ampm.lower().strip() == 'pm':
+        return 60 * (60 * (12 + (int(hr) % 12)) + int(min))
+    raise InvalidTimeException(tandem_time)
+
+def minutes_to_ns_time(minutes_time: int) -> str:
+    hr = minutes_time // 60
+    mn = minutes_time % 60
+
+    return "%02d:%02d" % (hr, mn)
+
+class InvalidBolusTypeException(RuntimeError):
+    pass
+
+class InvalidTimeException(RuntimeError):
+    pass
@@ -1,5 +1,9 @@
+from os import stat
 import sys
 import arrow
+from tconnectsync.domain.bolus import Bolus
+
+from tconnectsync.domain.therapy_event import BolusTherapyEvent, CGMTherapyEvent, BGTherapyEvent, BasalTherapyEvent

 try:
    from ..secret import TIMEZONE_NAME
@@ -13,7 +17,6 @@ a more digestable format, which is used internally.
 """
 class TConnectEntry:
    BASAL_EVENTS = { 0: "Suspension", 1: "Profile", 2: "TempRate", 3: "Algorithm" }
-    ACTIVITY_EVENTS = { 1: "Sleep", 2: "Exercise", 3: "AutoBolus", 4: "CarbOnly" }

    @staticmethod
    def _epoch_parse(x):
@@ -27,6 +30,10 @@ class TConnectEntry:
        # is overwritten with America/New_York, resulting in 2020-09-01T06:00:00-04:00, the
        # correct timestamp.
        return arrow.get(x, tzinfo="America/Los_Angeles").replace(tzinfo=TIMEZONE_NAME)
+    
+    @staticmethod
+    def _jsonp_epoch_parse(x):
+        return TConnectEntry._epoch_parse(int(x.replace('/Date(', '').replace('-0000)/', '')))

    @staticmethod
    def parse_ciq_basal_entry(data, delivery_type=""):
@@ -40,6 +47,16 @@ class TConnectEntry:
            "duration_mins": duration_mins,
            "basal_rate": basal_rate,
        }
+    
+    @staticmethod
+    def manual_suspension_to_basal_entry(parsedSuspension, seconds):
+        duration_mins = seconds / 60
+        return {
+            "time": parsedSuspension["time"],
+            "delivery_type": "%s suspension" % parsedSuspension["suspendReason"],
+            "duration_mins": duration_mins,
+            "basal_rate": 0.0
+        }

    @staticmethod
    def parse_suspension_entry(data):
@@ -85,19 +102,120 @@ class TConnectEntry:
    @staticmethod
    def parse_bolus_entry(data):
        # All DateTime's are stored in the user's timezone.
-        complete = (data["ExtendedBolusIsComplete"] or data["BolusIsComplete"])
+        def is_complete(s):
+            return s and int(s) == 1
+
+        complete = is_complete(data["ExtendedBolusIsComplete"]) or is_complete(data["BolusIsComplete"])
        extended_bolus = ("extended" in data["Description"].lower())

-        return {
+        return Bolus(**{
            "description": data["Description"],
            "complete": "1" if complete else "",
            "completion": data["CompletionStatusDesc"] if not extended_bolus else data["BolexCompletionStatusDesc"],
-            "request_time": TConnectEntry._datetime_parse(data["RequestDateTime"]).format() if complete and not extended_bolus else None,
-            "completion_time": TConnectEntry._datetime_parse(data["CompletionDateTime"]).format() if complete and not extended_bolus else None,
+            "request_time": TConnectEntry._datetime_parse(data["RequestDateTime"]).format() if not extended_bolus else None,
+            "completion_time": TConnectEntry._datetime_parse(data["CompletionDateTime"]).format() if not extended_bolus else None,
            "insulin": data["InsulinDelivered"],
+            "requested_insulin": data["ActualTotalBolusRequested"],
            "carbs": data["CarbSize"],
+            "bg": data["BG"], # Note: can be empty string for automatic Control-IQ boluses
            "user_override": data["UserOverride"],
            "extended_bolus": "1" if extended_bolus else "",
-            "bolex_completion_time": TConnectEntry._datetime_parse(data["BolexCompletionDateTime"]).format() if complete and extended_bolus else None,
-            "bolex_start_time": TConnectEntry._datetime_parse(data["BolexStartDateTime"]).format() if complete and extended_bolus else None,
-        }
+            # Note: completion time can be empty if the extended bolus is in progress
+            "bolex_completion_time": TConnectEntry._datetime_parse(data["BolexCompletionDateTime"]).format() if data["BolexCompletionDateTime"] and complete and extended_bolus else None,
+            "bolex_start_time": TConnectEntry._datetime_parse(data["BolexStartDateTime"]).format() if data["BolexStartDateTime"] and complete and extended_bolus else None,
+        })
+    
+    @staticmethod
+    def parse_reading_entry(data):
+        return {
+            "time": TConnectEntry._datetime_parse(data["EventDateTime"]).format(),
+            "bg": data["Readings (CGM / BGM)"],
+            "type": data["Description"]
+        }
+
+    ACTIVITY_EVENTS = { 1: "Sleep", 2: "Exercise", 3: "AutoBolus", 4: "CarbOnly" }
+
+    @staticmethod
+    def parse_ciq_activity_event(data):
+        if data["eventType"] not in TConnectEntry.ACTIVITY_EVENTS.keys():
+            raise UnknownCIQActivityEventException(data)
+
+        time = TConnectEntry._epoch_parse(data["x"])
+        return {
+            "time": time.format(),
+            "duration_mins": data["duration"] / 60,
+            "event_type": TConnectEntry.ACTIVITY_EVENTS[data["eventType"]]
+        }
+    
+    BASALSUSPENSION_EVENTS = {
+        # site-cart corresponds to a Site or Cartridge change,
+        # specifically a Tubing Filled: Norm AND a Cannula Filled: Norm alert.
+        # (This means that a typical changing of a cartridge and then a site
+        # will result in two consecutive events of this type.)
+        "site-cart": "Site/Cartridge Change",
+
+        # alarm corresponds to one of the following:
+        # - an Empty Cartridge alarm
+        # - a Pump shutdown
+        "alarm": "Empty Cartridge/Pump Shutdown",
+
+        # manual corresponds to a Pumping Suspended by User event
+        "manual": "User Suspended",
+
+        # temp-profile corresponds to a Basal Rate Change event to 0u/hr
+        "temp-profile": "Basal Rate Change"
+    }
+
+    BASALSUSPENSION_SKIPPED_EVENTS = {
+        # basal-profile events are not very useful; with ControlIQ enabled,
+        # Tandem does not show them in the tconnect UI.
+        "basal-profile",
+
+        # If an event continues to occur after the date switches over to the next
+        # day, then the pump generates a "previous" event. This isn't useful to
+        # us, so we skip them.
+        "previous",
+    }
+    @staticmethod
+    def parse_basalsuspension_event(data):
+        if not data or "SuspendReason" not in data:
+            return None
+
+        if data["SuspendReason"] in TConnectEntry.BASALSUSPENSION_SKIPPED_EVENTS:
+            return None
+
+        if data["SuspendReason"] not in TConnectEntry.BASALSUSPENSION_EVENTS.keys():
+            raise UnknownBasalSuspensionEventException(data)
+
+        time = TConnectEntry._jsonp_epoch_parse(data["EventDateTime"])
+        return {
+            "time": time.format(),
+            "event_type": TConnectEntry.BASALSUSPENSION_EVENTS[data["SuspendReason"]]
+        }
+    
+    # Parses an entry from controliq.therapy_events() and returns a TherapyEvent
+    @staticmethod
+    def parse_therapy_event(data):
+        if data["type"] == "Bolus":
+            return BolusTherapyEvent.parse(data)
+        elif data["type"] == "CGM":
+            return CGMTherapyEvent.parse(data)
+        elif data["type"] == "BG":
+            return BGTherapyEvent.parse(data)
+        elif data["type"] == "Basal":
+            return BasalTherapyEvent.parse(data)
+        
+        raise UnknownTherapyEventException(data)
+
+class UnknownCIQActivityEventException(Exception):
+    def __init__(self, data):
+        super().__init__("Unknown CIQ activity event type: %s" % data)
+
+class UnknownBasalSuspensionEventException(Exception):
+    def __init__(self, data):
+        super().__init__("Unknown basal suspension event type: %s" % data)
+
+class UnknownTherapyEventException(Exception):
+    def __init__(self, data):
+        typ = data["type"]
+        super().__init__(f"Unknown therapy event type: {typ} in {data}")
@@ -1,5 +1,11 @@
-from datetime import datetime
+import logging
+import datetime
+import arrow
+import time

+from tconnectsync.parser.ciq_therapy_events import split_therapy_events
+
+from .util import timeago
 from .api.common import ApiException
 from .sync.basal import (
    process_ciq_basal_events,
@@ -14,49 +20,183 @@ from .sync.iob import (
    process_iob_events,
    ns_write_iob_events
 )
+from .sync.cgm import (
+    process_cgm_events,
+    ns_write_cgm_events
+)
+from .sync.pump_events import (
+    process_ciq_activity_events,
+    process_basalsuspension_events,
+    ns_write_pump_events
+)
+from .sync.profile import process_profiles
+from .parser.tconnect import TConnectEntry
+from .features import BASAL, BOLUS, IOB, BOLUS_BG, CGM, DEFAULT_FEATURES, PUMP_EVENTS, PROFILES, PUMP_EVENTS_BASAL_SUSPENSION
+from tconnectsync.sync import basal
+
+logger = logging.getLogger(__name__)

 """
 Given a TConnectApi object and start/end range, performs a single
 cycle of synchronizing data within the time range.
 If pretend is true, then doesn't actually write data to Nightscout.
 """
-def process_time_range(tconnect, nightscout, time_start, time_end, pretend):
-    print("Downloading t:connect ControlIQ data")
-    try:
-        ciqTherapyTimelineData = tconnect.controliq.therapy_timeline(time_start, time_end)
-    except ApiException as e:
-        # The ControlIQ API returns a 404 if the user did not have a ControlIQ enabled
-        # device in the time range which is queried. Since it launched in early 2020,
-        # ignore 404's before February.
-        if e.status_code == 404 and time_start.date() < datetime.date(2020, 2, 1):
-            print("Ignoring HTTP 404 for ControlIQ API request before Feb 2020")
-            ciqTherapyTimelineData = None
+def process_time_range(tconnect, nightscout, time_start, time_end, pretend, features=DEFAULT_FEATURES):
+    ciqTherapyTimelineData = None
+    if BASAL in features or PUMP_EVENTS in features:
+        logger.info("Downloading t:connect ControlIQ data")
+
+        try:
+            ciqTherapyTimelineData = tconnect.controliq.therapy_timeline(time_start, time_end)
+        except ApiException as e:
+            # The ControlIQ API returns a 404 if the user did not have a ControlIQ enabled
+            # device in the time range which is queried. Since it launched in early 2020,
+            # ignore 404's before February.
+            if e.status_code == 404 and time_start.date() < datetime.date(2020, 2, 1):
+                logger.warning("Ignoring HTTP 404 for ControlIQ API request before Feb 2020")
+                ciqTherapyTimelineData = None
+            else:
+                raise e
+    
+    csvReadingData = None
+    csvIobData = None
+    csvBasalData = None
+    csvBolusData = None
+
+    ciqBolusData = None
+    ciqReadingData = None
+    if BOLUS in features:
+        logger.info("Downloading t:connect therapy_events")
+        ciqTherapyEventsData = tconnect.controliq.therapy_events(time_start, time_end)
+        ciqBolusData, ciqReadingData = split_therapy_events(ciqTherapyEventsData)
+
+        if ciqReadingData and len(ciqReadingData) > 0:
+            lastReading = ciqReadingData[-1].eventDateTime
+            lastReading = TConnectEntry._datetime_parse(lastReading)
+            logger.debug(ciqReadingData[-1])
+            logger.info("Last CGM reading from t:connect CIQ: %s (%s)" % (lastReading, timeago(lastReading)))
        else:
-            raise e
+            logger.warning("No last CGM reading is able to be determined from CIQ")
+        
+        if ciqBolusData and len(ciqBolusData) > 0:
+            lastBolus = ciqBolusData[-1].eventDateTime
+            lastReading = TConnectEntry._datetime_parse(lastBolus)
+            logger.debug(ciqBolusData[-1].to_bolus())
+            logger.info("Last bolus from t:connect CIQ: %s (%s)" % (lastBolus, timeago(lastBolus)))

-    print("Downloading t:connect CSV data")
-    csvdata = tconnect.ws2.therapy_timeline_csv(time_start, time_end)
+    bolusFallingBack = (BOLUS in features and not ciqBolusData)
+    ciqFallingBack = (CGM in features and not ciqReadingData)
+    if bolusFallingBack or \
+       ciqFallingBack or \
+       BOLUS_BG in features or \
+       IOB in features:
+        logger.warning("Downloading t:connect CSV data")
+        if bolusFallingBack:
+            logger.warning("Falling back on WS2 CSV data source because BOLUS is an enabled feature and CIQ bolus data was empty!!")
+        if ciqFallingBack:
+            logger.warning("Falling back on WS2 CSV data source because CGM is an enabled feature and CIQ cgm data was empty!!")
+        if BOLUS_BG in features:
+            logger.warning("Falling back on WS2 CSV data source because BOLUS_BG is an enabled feature. " +
+                        "Please consider disabling this feature to improve synchronization reliability.")
+        if IOB in features:
+            logger.warning("Falling back on WS2 CSV data source because IOB is an enabled feature. " +
+                        "Please consider disabling this feature to improve synchronization reliability.")
+        
+        logger.warning("<!!> The WS2 data source is unreliable and may prevent timely synchronization")
+        csvdata = tconnect.ws2.therapy_timeline_csv(time_start, time_end)

-    readingData = csvdata["readingData"]
-    iobData = csvdata["iobData"]
-    csvBasalData = csvdata["basalData"]
-    bolusData = csvdata["bolusData"]
+        csvReadingData = csvdata["readingData"]
+        csvIobData = csvdata["iobData"]
+        csvBasalData = csvdata["basalData"]
+        csvBolusData = csvdata["bolusData"]
+
+        if csvReadingData and len(csvReadingData) > 0:
+            lastReading = csvReadingData[-1]['EventDateTime'] if 'EventDateTime' in csvReadingData[-1] else 0
+            lastReading = TConnectEntry._datetime_parse(lastReading)
+            logger.debug(csvReadingData[-1])
+            logger.info("Last CGM reading from t:connect CSV: %s (%s)" % (lastReading, timeago(lastReading)))
+        else:
+            logger.warning("No last CGM reading is able to be determined from CSV")

-    if readingData and len(readingData) > 0:
-        print("Last CGM reading from t:connect:", readingData[-1]['EventDateTime'] if 'EventDateTime' in readingData[-1] else readingData)

    added = 0

-    basalEvents = process_ciq_basal_events(ciqTherapyTimelineData)
-    if csvBasalData:
-        add_csv_basal_events(basalEvents, csvBasalData)
+    if csvReadingData:
+        cgmData = None
+        if CGM in features or BOLUS_BG in features:
+            logger.debug("Processing CGM events")
+            cgmData = process_cgm_events(csvReadingData)
+        
+        if CGM in features:
+            logger.debug("Writing CGM events")
+            added += ns_write_cgm_events(nightscout, cgmData, pretend, time_start=time_start, time_end=time_end)
+            logger.debug("Finished writing CGM events")

-    added += ns_write_basal_events(nightscout, basalEvents, pretend=pretend)
+    if BASAL in features:
+        basalEvents = process_ciq_basal_events(ciqTherapyTimelineData)
+        if csvBasalData:
+            logger.debug("CSV basal data found: processing it")
+            add_csv_basal_events(basalEvents, csvBasalData)
+        else:
+            logger.debug("No CSV basal data found")
+        
+        if basalEvents and len(basalEvents) > 0:
+            logger.info("Last basal event from CIQ: %s" % basalEvents[-1])

-    bolusEvents = process_bolus_events(bolusData)
-    added += ns_write_bolus_events(nightscout, bolusEvents, pretend=pretend)
+        logger.debug("Writing basal events")
+        added += ns_write_basal_events(nightscout, basalEvents, pretend=pretend, time_start=time_start, time_end=time_end)
+        logger.debug("Finished writing basal events")

-    iobEvents = process_iob_events(iobData)
-    added += ns_write_iob_events(nightscout, iobEvents, pretend=pretend)
+    if PUMP_EVENTS_BASAL_SUSPENSION in features:
+        logger.warning("Using WS2 data source for basalsuspension because PUMP_EVENTS_BASAL_SUSPENSION is an enabled feature")
+        logger.warning("<!!> The WS2 data source is unreliable and may prevent timely synchronization")
+        ws2BasalSuspension = tconnect.ws2.basalsuspension(time_start, time_end)

-    return added
+        bsPumpEvents = process_basalsuspension_events(ws2BasalSuspension)
+        logger.debug("basalsuspension events: %s" % bsPumpEvents)
+
+        logger.debug("Writing pump basalsuspension events")
+        added += ns_write_pump_events(nightscout, bsPumpEvents, pretend=pretend, time_start=time_start, time_end=time_end)
+        logger.debug("Finished writing basal events")
+
+    if PUMP_EVENTS in features:
+        pumpEvents = process_ciq_activity_events(ciqTherapyTimelineData)
+        logger.debug("CIQ activity events: %s" % pumpEvents)
+
+        logger.debug("Writing pump events")
+        added += ns_write_pump_events(nightscout, pumpEvents, pretend=pretend, time_start=time_start, time_end=time_end)
+        logger.debug("Finished writing basal events")
+
+    if BOLUS in features:
+        bolusEvents = []
+        if ciqBolusData:
+            logger.info("Processing ciqBolusData (%d entries)" % len(ciqBolusData))
+            bolusEvents = process_bolus_events(ciqBolusData, source="ciq")
+
+        if csvBolusData and not bolusEvents:
+            logger.warning("Falling back on non-CIQ csvBolusData")
+            bolusEvents = process_bolus_events(csvBolusData, source="csv")
+            logger.debug("ciq bolusEvents: %s" % bolusEvents)
+        
+        logger.info("finalized bolusEvents: %s" % bolusEvents)
+        logger.debug("Writing bolus events")
+        added += ns_write_bolus_events(nightscout, bolusEvents, pretend=pretend, include_bg=(BOLUS_BG in features), time_start=time_start, time_end=time_end)
+        logger.debug("Finished writing bolus events")
+
+    if csvIobData:
+        if IOB in features:
+            iobEvents = process_iob_events(csvIobData)
+            logger.debug("Writing iob events")
+            added += ns_write_iob_events(nightscout, iobEvents, pretend=pretend)
+            logger.debug("Finished writing iob events")
+    
+    if PROFILES in features:
+        logger.debug("Running profiles feature")
+        if process_profiles(tconnect, nightscout, pretend=pretend):
+            added += 1
+
+    if pretend:
+        logger.info("Would have written %d events to Nightscout this process cycle (in pretend mode)" % added)
+    else:
+        logger.info("Wrote %d events to Nightscout this process cycle" % added)
+    return added
@@ -1,40 +1,87 @@
-import os, sys
-from dotenv import load_dotenv
+import os, sys, pathlib
+from dotenv import dotenv_values

-load_dotenv()
+cwd_path = os.path.join(os.getcwd(), '.env')
+global_path = os.path.join(pathlib.Path.home(), '.config/tconnectsync/.env')

-def get(*args):
-    return os.environ.get(*args)
+cwd_creds_path = os.path.join(os.getcwd(), '.creds_cache')
+global_creds_path = os.path.join(pathlib.Path.home(), '.config/tconnectsync/.creds_cache')
+
+values = {}
+
+if os.path.exists(cwd_path):
+    values = dotenv_values(cwd_path)
+elif os.path.exists(global_path):
+    values = dotenv_values(global_path)
+else:
+    values = dotenv_values()
+
+def get(val, default=None):
+    return os.environ.get(val, values.get(val, default))
+
+def get_one_of(name, default=None, options=[]):
+    val = get(name, default)
+    if val not in options:
+        print("Error: %s must be one of: %s" % (name, options))
+        print("Current value: %s" % val)
+        sys.exit(1)
+    return val

 def get_number(name, default):
    val = get(name, default)
    try:
-        return int(val)
+        return float(val)
    except ValueError:
        print("Error: %s must be a number." % name)
        print("Current value: %s" % val)
        sys.exit(1)

+def get_bool(name, default):
+    return str(get(name, default) or '').lower() in ('true', '1')
+
 TCONNECT_EMAIL = get('TCONNECT_EMAIL', 'email@email.com')
 TCONNECT_PASSWORD = get('TCONNECT_PASSWORD', 'password')

-PUMP_SERIAL_NUMBER = get_number('PUMP_SERIAL_NUMBER', '11111111')
+PUMP_SERIAL_NUMBER = int(get_number('PUMP_SERIAL_NUMBER', '11111111'))

 NS_URL = get('NS_URL', 'https://yournightscouturl/')
 NS_SECRET = get('NS_SECRET', 'apisecret')

+if not get('NS_SECRET') and get('API_SECRET'):
+    print('API_SECRET environment variable is set, overriding NS_SECRET')
+    NS_SECRET = get('API_SECRET')
+
+NS_SKIP_TLS_VERIFY = get_bool('NS_SKIP_TLS_VERIFY', 'false')
+NS_IGNORE_CONN_ERRORS = get_bool('NS_IGNORE_CONN_ERRORS', 'false')
+
 TIMEZONE_NAME = get('TIMEZONE_NAME', 'America/New_York')

+if not get('TIMEZONE_NAME') and get('TZ'):
+    print('TZ environment variable is set, overriding TIMEZONE_NAME')
+    TIMEZONE_NAME = get('TZ')
+
 # Optional configuration

-AUTOUPDATE_DEFAULT_SLEEP_SECONDS = get_number('AUTOUPDATE_DEFAULT_SLEEP_SECONDS', '60')
-AUTOUPDATE_MAX_SLEEP_SECONDS = get_number('AUTOUPDATE_MAX_SLEEP_SECONDS', '600')
-AUTOUPDATE_USE_FIXED_SLEEP = get_number('AUTOUPDATE_USE_FIXED_SLEEP', '0')
+CACHE_CREDENTIALS = get_bool('CACHE_CREDENTIALS', 'true')
+CACHE_CREDENTIALS_PATH = get('CACHE_CREDENTIALS', cwd_creds_path if os.path.exists(cwd_creds_path) else global_creds_path)
+AUTOUPDATE_DEFAULT_SLEEP_SECONDS = get_number('AUTOUPDATE_DEFAULT_SLEEP_SECONDS', '300') # 5 minutes
+AUTOUPDATE_MAX_SLEEP_SECONDS = get_number('AUTOUPDATE_MAX_SLEEP_SECONDS', '1500') # 25 minutes
+AUTOUPDATE_UNEXPECTED_NO_INDEX_SLEEP_SECONDS = get_number('AUTOUPDATE_UNEXPECTED_NO_INDEX_SLEEP_SECONDS', '60') # 1 minute
+AUTOUPDATE_USE_FIXED_SLEEP = get_bool('AUTOUPDATE_USE_FIXED_SLEEP', 'false')
+AUTOUPDATE_NO_DATA_FAILURE_MINUTES = get_number('AUTOUPDATE_NO_DATA_FAILURE_MINUTES', '180') # 3 hours
+AUTOUPDATE_FAILURE_MINUTES = get_number('AUTOUPDATE_FAILURE_MINUTES', '15') # 15 minutes
+AUTOUPDATE_RESTART_ON_FAILURE = get_bool('AUTOUPDATE_RESTART_ON_FAILURE', 'true')
+AUTOUPDATE_MAX_LOOP_INVOCATIONS = get_number('AUTOUPDATE_MAX_LOOP_INVOCATIONS', '-1')

-_config = ['TCONNECT_EMAIL', 'TCONNECT_PASSWORD', 'PUMP_SERIAL_NUMBER',
-          'NS_URL', 'NS_SECRET', 'TIMEZONE_NAME',
-          'AUTOUPDATE_DEFAULT_SLEEP_SECONDS', 'AUTOUPDATE_MAX_SLEEP_SECONDS',
-          'AUTOUPDATE_USE_FIXED_SLEEP']
+NIGHTSCOUT_PROFILE_UPLOAD_MODE = get_one_of('NIGHTSCOUT_PROFILE_UPLOAD_MODE', 'add', ['add', 'replace'])
+
+# Default Nightscout profile segment fields which aren't stored by Tandem
+NIGHTSCOUT_PROFILE_CARBS_HR_VALUE = get('NIGHTSCOUT_PROFILE_CARBS_HR_VALUE', '20')
+NIGHTSCOUT_PROFILE_DELAY_VALUE = get('NIGHTSCOUT_PROFILE_DELAY_VALUE', '20')
+
+ENABLE_TESTING_MODES = get_bool('ENABLE_TESTING_MODES', 'false')
+SKIP_NS_LAST_UPLOADED_CHECK = get_bool('SKIP_NS_LAST_UPLOADED_CHECK', 'false')
+REQUESTS_PROXY = get('REQUESTS_PROXY', '')

 if __name__ == '__main__':
    for k in locals():
@@ -1,11 +1,14 @@
 import arrow
+import logging

 from ..parser.nightscout import (
    BASAL_EVENTTYPE,
    NightscoutEntry
 )
 from ..parser.tconnect import TConnectEntry
+from ..secret import SKIP_NS_LAST_UPLOADED_CHECK

+logger = logging.getLogger(__name__)

 """
 Merges together input from the therapy timeline API
@@ -30,11 +33,53 @@ def process_ciq_basal_events(data):
    for b in data["basal"]["profileDeliveryEvents"]:
        basalEvents.append(TConnectEntry.parse_ciq_basal_entry(b, delivery_type="profileDelivery"))

-    basalEvents.sort(key=lambda x: arrow.get(x["time"]))

+    # Suspensions with suspendReason 'control-iq' will match a basal event found above.
    for i in basalEvents:
        if i["time"] in suspensionEvents:
-            i["suspendReason"] = suspensionEvents[i["time"]]["suspendReason"]
+            i["delivery_type"] += " (" + suspensionEvents[i["time"]]["suspendReason"] + " suspension)"
+
+            del suspensionEvents[i["time"]]
+    
+    # Suspensions with suspendReason 'manual' do not have an associated basal event,
+    # and require extra processing.
+
+    basalEvents.sort(key=lambda x: arrow.get(x["time"]))
+
+    unprocessedSuspensions = list(suspensionEvents.values())
+    unprocessedSuspensions.sort(key=lambda x: arrow.get(x["time"]))
+
+    # For the remaining suspensions which did not match with an existing basal event,
+    # add a new event manually. This means we need to calculate the duration of the
+    # suspension.
+    newEvents = []
+    for i in range(len(basalEvents)):
+        if len(unprocessedSuspensions) == 0:
+            break
+
+        existingTime = arrow.get(basalEvents[i]["time"])
+        unprocessedTime = arrow.get(unprocessedSuspensions[0]["time"])
+        
+        # If we've found an event which occurs after the suspension, then the
+        # difference in their timestamps is the duration of the suspension.
+        if i > 0 and existingTime > unprocessedTime:
+            suspension = unprocessedSuspensions.pop(0)
+
+            # TConnect's internal duration object tracks the duration in seconds
+            seconds = (existingTime - unprocessedTime).seconds
+
+            newEvent = TConnectEntry.manual_suspension_to_basal_entry(suspension, seconds)
+            logger.debug("Adding basal event for unprocessed suspension: %s" % newEvent)
+            newEvents.append(newEvent)
+
+    # Any remaining suspensions which have not been processed have not ended,
+    # which means we do not know their duration; so we will skip them (for now)
+
+    # Add any new events and re-sort
+    if newEvents:
+        basalEvents += newEvents
+        basalEvents.sort(key=lambda x: arrow.get(x["time"]))
+

    return basalEvents

@@ -59,18 +104,24 @@ def add_csv_basal_events(basalEvents, data):
 """
 Given processed basal data, adds basal events to Nightscout.
 """
-def ns_write_basal_events(nightscout, basalEvents, pretend=False):
-    last_upload = nightscout.last_uploaded_entry(BASAL_EVENTTYPE)
+def ns_write_basal_events(nightscout, basalEvents, pretend=False, time_start=None, time_end=None):
+    logger.debug("ns_write_basal_events: querying for last uploaded entry")
+    last_upload = nightscout.last_uploaded_entry(BASAL_EVENTTYPE, time_start=time_start, time_end=time_end)
    last_upload_time = None
    if last_upload:
        last_upload_time = arrow.get(last_upload["created_at"])
-    print("Last Nightscout basal upload:", last_upload_time)
+    logger.info("Last Nightscout basal upload: %s" % last_upload_time)
+
+    if SKIP_NS_LAST_UPLOADED_CHECK:
+        logger.warning("Overriding last upload check")
+        last_upload = None
+        last_upload_time = None

    add_count = 0
    for event in basalEvents:
        if last_upload_time and arrow.get(event["time"]) < last_upload_time:
            if pretend:
-                print("Skipping basal event before last upload time:", event)
+                logger.info("Skipping basal event before last upload time: %s (time range: %s - %s)" % (event, time_start, time_end))
            continue

        recent_needs_update = False
@@ -97,13 +148,14 @@ def ns_write_basal_events(nightscout, basalEvents, pretend=False):

        add_count += 1

-        print("  Processing basal:", event, "entry:", entry)
+        logger.info("  Processing basal: %s entry: %s" % (event, entry))
        if recent_needs_update:
-            print("Replacing last uploaded entry:", last_upload)
+            logger.info("Replacing last uploaded entry: %s" % last_upload)
            if not pretend:
                entry['_id'] = last_upload['_id']
                nightscout.put_entry(entry, entity='treatments')
        elif not pretend:
            nightscout.upload_entry(entry)

+    logger.debug("ns_write_basal_events: added %d events" % add_count)
    return add_count
@@ -1,59 +1,119 @@
 import arrow
+import logging
+from tconnectsync.domain.bolus import Bolus
+
+from tconnectsync.sync.cgm import find_event_at

 from ..parser.nightscout import (
    BOLUS_EVENTTYPE,
    NightscoutEntry
 )
 from ..parser.tconnect import TConnectEntry
+from ..secret import SKIP_NS_LAST_UPLOADED_CHECK
+
+logger = logging.getLogger(__name__)

 """
 Given bolus data input from the therapy timeline CSV, converts it into a digestable format.
 """
-def process_bolus_events(bolusdata):
+def process_bolus_events(bolusdata, cgmEvents=None, source=""):
    bolusEvents = []

    for b in bolusdata:
-        parsed = TConnectEntry.parse_bolus_entry(b)
-        if parsed["completion"] != "Completed":
-            if parsed["insulin"] and float(parsed["insulin"]) > 0:
+        parsed = None
+        if source == "ciq":
+            parsed = b.to_bolus()
+        else:
+            parsed = TConnectEntry.parse_bolus_entry(b)
+        
+        assert type(parsed) == Bolus
+        if parsed.completion != "Completed":
+            if parsed.insulin and float(parsed.insulin) > 0:
                # Count non-completed bolus if any insulin was delivered (vs. the amount of insulin requested)
-                parsed["description"] += " (%s)" % parsed["completion"]
+                parsed.description += " (%s: requested %s units)" % (parsed.completion, parsed.requested_insulin)
            else:
-                print("Skipping non-completed bolus data:", b, "parsed:", parsed)
+                logger.warning("Skipping non-completed %s bolus data (was a bolus in progress?): %s parsed: %s" % (source, b, parsed))
                continue
+            if parsed.is_extended_bolus:
+                if not parsed.bolex_start_time and not parsed.request_time:
+                    logger.warning("Skipping non-completed %s extended bolus data with no request_time: %s parsed: %s" % (source, b, parsed))
+                elif not parsed.bolex_start_time and parsed.request_time:
+                    logger.warning("Setting bolex_start_time to request_time for non-completed %s extended bolus: %s parsed: %s" % (source, b, parsed))
+                    parsed.bolex_start_time = parsed.request_time
+            logger.debug("process_bolus_events for incomplete bolus: %s parsed: %s" % (b, parsed))
+        elif parsed.is_extended_bolus:
+            logger.debug("process_bolus_events for complete extended bolus: %s parsed: %s" % (b, parsed))
+
+        if parsed.bg and cgmEvents:
+            requested_at = parsed.request_time if not parsed.extended_bolus else parsed.bolex_start_time
+            parsed.bg_type = guess_bolus_bg_type(parsed.bg, requested_at, cgmEvents)
+
        bolusEvents.append(parsed)

-    bolusEvents.sort(key=lambda event: arrow.get(event["completion_time"] if not event["extended_bolus"] else event["bolex_start_time"]))
+    bolusEvents.sort(key=lambda event: arrow.get(event.request_time if not event.is_extended_bolus else event.bolex_start_time))

    return bolusEvents

+"""
+Determine whether the given BG specified in the bolus is identical to the
+most recent CGM reading at that time. If it is, return SENSOR.
+Otherwise, return FINGER.
+"""
+def guess_bolus_bg_type(bg, created_at, cgmEvents):
+    if not cgmEvents:
+        return NightscoutEntry.FINGER
+
+    event = find_event_at(cgmEvents, created_at)
+    if event and str(event["bg"]) == str(bg):
+        return NightscoutEntry.SENSOR
+    
+    return NightscoutEntry.FINGER
+
+
 """
 Given processed bolus data, adds bolus events to Nightscout.
 """
-def ns_write_bolus_events(nightscout, bolusEvents, pretend=False):
-    last_upload = nightscout.last_uploaded_entry(BOLUS_EVENTTYPE)
+def ns_write_bolus_events(nightscout, bolusEvents, pretend=False, include_bg=False, reading_events=None, time_start=None, time_end=None):
+    logger.debug("ns_write_bolus_events: querying for last uploaded entry")
+    last_upload = nightscout.last_uploaded_entry(BOLUS_EVENTTYPE, time_start=time_start, time_end=time_end)
    last_upload_time = None
    if last_upload:
        last_upload_time = arrow.get(last_upload["created_at"])
-    print("Last Nightscout bolus upload:", last_upload_time)
+    logger.info("Last Nightscout bolus upload: %s" % last_upload_time)
+
+    if SKIP_NS_LAST_UPLOADED_CHECK:
+        logger.warning("Overriding last upload check")
+        last_upload = None
+        last_upload_time = None

    add_count = 0
    for event in bolusEvents:
-        if last_upload_time and arrow.get(event["completion_time"]) <= last_upload_time:
+        created_at = event.completion_time if not event.is_extended_bolus else event.bolex_start_time
+        if last_upload_time and arrow.get(created_at) <= last_upload_time:
            if pretend:
-                print("Skipping basal event before last upload time:", event)
+                logger.info("Skipping basal event before last upload time: %s (time range: %s - %s)" % (event, time_start, time_end))
            continue

-        entry = NightscoutEntry.bolus(
-            bolus=event["insulin"],
-            carbs=event["carbs"],
-            created_at=event["completion_time"] if not event["extended_bolus"] else event["bolex_start_time"],
-            notes="{}{}{}".format(event["description"], " (Override)" if event["user_override"] == "1" else "", " (Extended)" if event["extended_bolus"] == "1" else "")
-        )
+        if include_bg and event.bg:
+            entry = NightscoutEntry.bolus(
+                bolus=event.insulin,
+                carbs=event.carbs,
+                created_at=created_at,
+                notes="{}{}{}".format(event.description, " (Override)" if event.user_override == "1" else "", " (Extended)" if event.extended_bolus == "1" else ""),
+                bg=event.bg,
+                bg_type=event.bg_type
+            )
+        else:
+            entry = NightscoutEntry.bolus(
+                bolus=event.insulin,
+                carbs=event.carbs,
+                created_at=created_at,
+                notes="{}{}{}".format(event.description, " (Override)" if event.user_override == "1" else "", " (Extended)" if event.extended_bolus == "1" else "")
+            )

        add_count += 1

-        print("  Processing bolus:", event, "entry:", entry)
+        logger.info("  Processing bolus: %s entry: %s" % (event, entry))
        if not pretend:
            nightscout.upload_entry(entry)

@@ -0,0 +1,69 @@
+import json
+import arrow
+import logging
+
+from ..parser.tconnect import TConnectEntry
+from ..parser.nightscout import NightscoutEntry
+
+logger = logging.getLogger(__name__)
+
+def process_cgm_events(readingData):
+    data = []
+    for r in readingData:
+        data.append(TConnectEntry.parse_reading_entry(r))
+    
+    return data
+
+"""
+Given reading data and a time, finds the BG reading event which would have
+been the current one at that time. e.g., it looks before the given time,
+not after.
+This is a heuristic for checking whether the BG component of a bolus was
+manually entered or inferred based on the pump's CGM.
+"""
+def find_event_at(cgmEvents, find_time):
+    find_t = arrow.get(find_time)
+    events = list(map(lambda x: (arrow.get(x["time"]), x), cgmEvents))
+    events.sort()
+
+    closestReading = None
+    for t, r in events:
+        if t > find_t:
+            break
+        closestReading = r
+        
+    
+    return closestReading
+    
+
+"""
+Given processed CGM data, adds reading entries to Nightscout.
+"""
+def ns_write_cgm_events(nightscout, cgmEvents, pretend=False, time_start=None, time_end=None):
+    logger.debug("ns_write_cgm_events: querying for last uploaded entry")
+    last_upload = nightscout.last_uploaded_bg_entry(time_start=time_start, time_end=time_end)
+    last_upload_time = None
+    if last_upload:
+        last_upload_time = arrow.get(last_upload["dateString"])
+    logger.info("Last Nightscout CGM upload: %s" % last_upload_time)
+
+    add_count = 0
+    for event in cgmEvents:
+        created_at = event["time"]
+        if last_upload_time and arrow.get(created_at) <= last_upload_time:
+            if pretend:
+                logger.info("Skipping CGM event before last upload time: %s (time range: %s - %s)" % (event, time_start, time_end))
+            continue
+
+        entry = NightscoutEntry.entry(
+            sgv=event["bg"],
+            created_at=created_at
+        )
+
+        add_count += 1
+
+        logger.info("  Processing cgm reading: %s entry: %s" % (event, entry))
+        if not pretend:
+            nightscout.upload_entry(entry, entity='entries')
+
+    return add_count
@@ -1,4 +1,5 @@
 import arrow
+import logging

 from ..parser.nightscout import (
    IOB_ACTIVITYTYPE,
@@ -6,6 +7,8 @@ from ..parser.nightscout import (
 )
 from ..parser.tconnect import TConnectEntry

+logger = logging.getLogger(__name__)
+
 """
 Given IOB data input from the therapy timeline CSV, converts it into a digestable format.
 """
@@ -21,20 +24,21 @@ def process_iob_events(iobdata):
 """
 Given processed IOB data, creates a single Nightscout activity definition to store IOB.
 """
-def ns_write_iob_events(nightscout, iobEvents, pretend=False):
-    last_upload = nightscout.last_uploaded_activity(IOB_ACTIVITYTYPE)
+def ns_write_iob_events(nightscout, iobEvents, pretend=False, time_start=None, time_end=None):
+    logger.debug("ns_write_iob_events: querying for last uploaded entry")
+    last_upload = nightscout.last_uploaded_activity(IOB_ACTIVITYTYPE, time_start=time_start, time_end=time_end)
    last_upload_time = None
    if last_upload:
        last_upload_time = arrow.get(last_upload["created_at"])
-    print("Last Nightscout iob upload:", last_upload_time)
+    logger.info("Last Nightscout iob upload: %s" % last_upload_time)

    if not iobEvents or len(iobEvents) == 0:
-        print("No IOB events: skipping")
+        logger.info("No IOB events present from API: skipping")
        return 0

    event = iobEvents[-1]
    if last_upload_time and arrow.get(event["time"]) <= last_upload_time:
-        print("  Skipping already uploaded iob event:", event)
+        logger.info("  Skipping already uploaded iob event: %s" % event)
        return 0

    entry = NightscoutEntry.iob(
@@ -42,13 +46,13 @@ def ns_write_iob_events(nightscout, iobEvents, pretend=False):
        created_at=event["time"]
    )

-    print("  Processing iob:", event, "entry:", entry)
+    logger.info("  Processing iob: %s entry: %s" % (event, entry))
    if not pretend:
        nightscout.upload_entry(entry, entity='activity')

    # Delete the previous activity
    if last_upload and '_id' in last_upload:
-        print("  Deleting old iob entry:", last_upload)
+        logger.info("  Deleting old iob entry: %s" % last_upload)
        if not pretend:
            nightscout.delete_entry('activity/{}'.format(last_upload['_id']))

@@ -0,0 +1,200 @@
+from typing import List, Tuple
+import logging
+import json
+import copy
+import arrow
+
+from ..api import TConnectApi
+from ..domain.device_settings import Profile, DeviceSettings
+from ..parser.nightscout import NightscoutEntry
+from ..nightscout import NightscoutApi
+from ..secret import PUMP_SERIAL_NUMBER, NIGHTSCOUT_PROFILE_UPLOAD_MODE
+
+logger = logging.getLogger(__name__)
+
+def _get_default_serial_number():
+    return PUMP_SERIAL_NUMBER
+
+def _get_default_upload_mode():
+    return NIGHTSCOUT_PROFILE_UPLOAD_MODE
+
+def get_pump_profiles(tconnect: TConnectApi, serial_number: int = None) -> Tuple[List[Profile], DeviceSettings]:
+    all_devices = tconnect.webui.my_devices()
+    if serial_number is None:
+        serial_number = _get_default_serial_number()
+
+    if str(serial_number) not in all_devices:
+        logger.warn("Could not find entry for provided pump serial number in t:connect device list: %s, received: %s", serial_number, all_devices)
+        return [], None
+    
+    device = all_devices[str(serial_number)]
+
+    logger.info("Getting profile settings for %s", device)
+    device_profiles, device_settings = tconnect.webui.device_settings_from_guid(device.guid)
+    logger.debug("device_profiles: %s", device_profiles)
+    logger.debug("device_settings: %s", device_settings)
+
+    logger.info("Found pump profiles: %s", ["%s%s" % (profile.title, " (active)" if profile.active else "") for profile in device_profiles])
+
+    return device_profiles, device_settings
+
+
+"""
+Compare pump device and Nightscout profiles, and return a final dictionary of
+Nightscout profile objects, with the pump profile settings overriding what is
+currently in Nightscout.
+
+ns_profile_obj is the output from NightscoutApi.current_profile() and should be the most
+recent profile object in mongo.
+
+Returns the new Nightscout profile and whether it was changed.
+"""
+def compare_profiles(device_profiles: List[Profile], device_settings: DeviceSettings, ns_profile_obj: dict) -> Tuple[bool, dict]:
+    device = {profile.title: profile for profile in device_profiles}
+    ns = ns_profile_obj.get('store', {})
+
+    logger.info("compare_profiles profile names: device: %s ns: %s", device.keys(), ns.keys())
+
+    new_ns_profile = copy.deepcopy(ns_profile_obj)
+    updated_ns_profile = False
+
+    missing_profiles_in_ns = set(device.keys()) - set(ns.keys())
+    for profile_name in missing_profiles_in_ns:
+        logger.info("Missing %s profile in Nightscout: %s", profile_name, device.get(profile_name))
+        pump_configured_profile = device[profile_name]
+        ns_translated_profile = NightscoutEntry.profile_store(pump_configured_profile, device_settings)
+        logger.info("Will add %s profile to Nightscout: %s", profile_name, ns_translated_profile)
+        new_ns_profile['store'][profile_name] = ns_translated_profile
+        updated_ns_profile = True
+
+    existent_profiles_in_ns = set(device.keys()) & set(ns.keys())
+    for profile_name in existent_profiles_in_ns:
+        logger.debug("Checking for differences for %s profile between pump and nightscout", profile_name)
+        pump_configured_profile = device[profile_name]
+        ns_translated_profile = NightscoutEntry.profile_store(pump_configured_profile, device_settings)
+        ns_configured_profile = ns[profile_name]
+
+        logger.debug("Comparing %s profile from pump: %s to nightscout: %s", profile_name, ns_translated_profile, ns_configured_profile)
+        if nightscout_profiles_identical(ns_configured_profile, ns_translated_profile):
+            logger.info("Profile %s identical between pump and nightscout", profile_name)
+            continue
+
+        logger.info("Profile %s needs update in nightscout: %s", profile_name, ns_translated_profile)
+        new_ns_profile['store'][profile_name] = ns_translated_profile
+        updated_ns_profile = True
+
+    current_pump_profile = None
+    for profile in device_profiles:
+        if profile.active:
+            current_pump_profile = profile.title
+
+    if not current_pump_profile:
+        logger.error('No current pump profile, so skipping profile update: device: %s', device_profiles)
+        return False, ns_profile_obj
+
+    current_ns_profile = ns_profile_obj.get('defaultProfile')
+    if current_pump_profile != current_ns_profile:
+        logger.info("Current profile changed: pump: %s nightscout: %s", current_pump_profile, current_ns_profile)
+        new_ns_profile['defaultProfile'] = current_pump_profile
+        updated_ns_profile = True
+
+    if not updated_ns_profile:
+        logger.info("No Nightscout profile changes")
+        return False, ns_profile_obj
+
+    logger.info("New Nightscout profile object: %s", new_ns_profile)
+    return True, new_ns_profile
+
+def nightscout_profiles_identical(configured: dict, translated: dict) -> bool:
+    if configured == translated:
+        logger.debug("direct dicts equal")
+        return True
+
+    if json.dumps(configured, sort_keys=True, indent=None) == json.dumps(translated, sort_keys=True, indent=None):
+        logger.debug("initial JSON dump identical")
+        return True
+
+    # convert all JSON values into strings
+    def map_nested_dicts_modify(ob, func):
+        for k, v in ob.items():
+            if isinstance(v, dict):
+                map_nested_dicts_modify(v, func)
+            elif isinstance(v, list):
+                map_nested_lists_modify(v, func)
+            else:
+                ob[k] = func(v)
+
+    def map_nested_lists_modify(ob, func):
+        for i in range(len(ob)):
+            v = ob[i]
+            if isinstance(v, dict):
+                map_nested_dicts_modify(v, func)
+            elif isinstance(v, list):
+                map_nested_lists_modify(v, func)
+            else:
+                ob[i] = func(v)
+
+    def to_numeric(x):
+        if type(x) in [int, float]:
+            return '%f' % x
+        try:
+            return '%f' % float(x)
+        except (ValueError, TypeError):
+            return x
+
+
+    convert_func = lambda x: to_numeric(x)
+
+    configured_str = json.loads(json.dumps(configured))
+    map_nested_dicts_modify(configured_str, convert_func)
+    translated_str = json.loads(json.dumps(translated))
+    map_nested_dicts_modify(translated_str, convert_func)
+
+    if json.dumps(configured_str, sort_keys=True, indent=None) == json.dumps(translated_str, sort_keys=True, indent=None):
+        logger.debug("map_nested_dicts JSON dump identical")
+        return True
+
+    logger.debug("profiles not identical")
+    return False
+
+def setup_new_profile(ns_profile: dict) -> dict:
+    if '_id' in ns_profile:
+        del ns_profile['_id']
+    
+    now = arrow.now().isoformat()
+    ns_profile['startDate'] = now
+    ns_profile['created_at'] = now
+
+    return ns_profile
+
+def process_profiles(tconnect: TConnectApi, nightscout: NightscoutApi, pretend: bool = False, upload_mode: str = None) -> bool:
+    if not upload_mode:
+        upload_mode = _get_default_upload_mode()
+
+    logger.debug("Checking for differences between pump and nightscout profiles: %s mode", upload_mode)
+    
+    ns_profile_obj = nightscout.current_profile()
+    pump_profiles, pump_settings = get_pump_profiles(tconnect)
+    diff, ns_profile_new = compare_profiles(pump_profiles, pump_settings, ns_profile_obj)
+
+    if not diff:
+        logger.info("Pump and Nightscout profiles up to date")
+        return False
+    
+    if upload_mode == 'add':
+        profile_to_upload = setup_new_profile(ns_profile_new)
+        logger.info("Adding new Nightscout profiles object: %s", profile_to_upload)
+
+        if not pretend:
+            nightscout.upload_entry(profile_to_upload, entity='profile')
+        return True
+
+    elif upload_mode == 'replace':
+        logger.info("Replacing new Nightscout profiles object: %s", ns_profile_new)
+
+        if not pretend:
+            nightscout.put_entry(ns_profile_new, entity='profile')
+        return True
+
+    else:
+        raise RuntimeError('invalid upload_mode: %s' % upload_mode)
@@ -0,0 +1,218 @@
+import arrow
+import logging
+
+from ..parser.nightscout import (
+    SITECHANGE_EVENTTYPE,
+    BASALSUSPENSION_EVENTTYPE,
+    EXERCISE_EVENTTYPE,
+    SLEEP_EVENTTYPE,
+    ACTIVITY_EVENTTYPE,
+    NightscoutEntry
+)
+from ..parser.tconnect import TConnectEntry
+from ..secret import SKIP_NS_LAST_UPLOADED_CHECK
+
+logger = logging.getLogger(__name__)
+
+"""
+Given a list of "activity events" from the CIQ therapy timeline endpoint,
+process it into our internal events format.
+
+These events contain a duration.
+"""
+def process_ciq_activity_events(data):
+    events = []
+
+    for event in data["events"]:
+        events.append(TConnectEntry.parse_ciq_activity_event(event))
+
+    return events
+
+"""
+Given a list of "basal suspension events" from the basalsuspension WS2 endpoint,
+process it into our internal events format.
+
+These events do NOT contain a duration.
+"""
+def process_basalsuspension_events(data):
+    events = []
+
+    for event in data['BasalSuspension']:
+        parsed = TConnectEntry.parse_basalsuspension_event(event)
+
+        if parsed:
+            events.append(parsed)
+    
+
+    return events
+
+"""
+Given processed pump event data (of various types), write them to Nightscout
+"""
+def ns_write_pump_events(nightscout, pumpEvents, pretend=False, time_start=None, time_end=None):
+    count = 0
+
+    siteChangeEvents = []
+    emptyCartEvents = []
+    userSuspendedEvents = []
+    exerciseEvents = []
+    sleepEvents = []
+    activityEvents = []
+
+    for event in pumpEvents:
+        if event["event_type"] == TConnectEntry.BASALSUSPENSION_EVENTS["site-cart"]:
+            siteChangeEvents.append(event)
+        elif event["event_type"] in TConnectEntry.BASALSUSPENSION_EVENTS["alarm"]:
+            emptyCartEvents.append(event)
+        elif event["event_type"] in TConnectEntry.BASALSUSPENSION_EVENTS["manual"]:
+            userSuspendedEvents.append(event)
+        elif event["event_type"] == "Exercise":
+            exerciseEvents.append(event)
+        elif event["event_type"] == "Sleep":
+            sleepEvents.append(event)
+        elif event["event_type"] in TConnectEntry.ACTIVITY_EVENTS.values():
+            activityEvents.append(event)
+            
+    logger.debug("siteChangeEvents: %s" % siteChangeEvents)
+    logger.debug("emptyCartEvents: %s" % emptyCartEvents)
+    logger.debug("userSuspendedEvents: %s" % userSuspendedEvents)
+    logger.debug("exerciseEvents: %s" % exerciseEvents)
+    logger.debug("sleepEvents: %s" % sleepEvents)
+    logger.debug("activityEvents: %s" % activityEvents)
+    
+    count += ns_write_pump_sitechange_events(nightscout, siteChangeEvents, pretend=pretend, time_start=time_start, time_end=time_end)
+    count += ns_write_empty_cart_events(nightscout, emptyCartEvents, pretend=pretend, time_start=time_start, time_end=time_end)
+    count += ns_write_user_suspended_events(nightscout, userSuspendedEvents, pretend=pretend, time_start=time_start, time_end=time_end)
+
+    count += ns_write_exercise_activity_events(nightscout, exerciseEvents, pretend=pretend, time_start=time_start, time_end=time_end)
+    count += ns_write_sleep_activity_events(nightscout, sleepEvents, pretend=pretend, time_start=time_start, time_end=time_end)
+    count += ns_write_activity_events(nightscout, activityEvents, pretend=pretend, time_start=time_start, time_end=time_end)
+
+    return count
+
+def ns_write_pump_sitechange_events(nightscout, siteChangeEvents, pretend=False, time_start=None, time_end=None):
+    return _ns_write_pump_events(
+        nightscout, 
+        siteChangeEvents, 
+        lambda event: NightscoutEntry.sitechange(
+            created_at=event["time"],
+            reason=event["event_type"]
+        ),
+        SITECHANGE_EVENTTYPE,
+        pretend=pretend,
+        time_start=time_start,
+        time_end=time_end)
+
+def ns_write_empty_cart_events(nightscout, emptyCartEvents, pretend=False, time_start=None, time_end=None):
+    return _ns_write_pump_events(
+        nightscout, 
+        emptyCartEvents, 
+        lambda event: NightscoutEntry.basalsuspension(
+            created_at=event["time"],
+            reason=event["event_type"]
+        ),
+        BASALSUSPENSION_EVENTTYPE,
+        pretend=pretend,
+        time_start=time_start,
+        time_end=time_end)
+
+def ns_write_user_suspended_events(nightscout, userSuspendedEvents, pretend=False, time_start=None, time_end=None):
+    return _ns_write_pump_events(
+        nightscout, 
+        userSuspendedEvents, 
+        lambda event: NightscoutEntry.basalsuspension(
+            created_at=event["time"],
+            reason=event["event_type"]
+        ),
+        BASALSUSPENSION_EVENTTYPE,
+        pretend=pretend,
+        time_start=time_start,
+        time_end=time_end)
+
+def ns_write_exercise_activity_events(nightscout, exerciseEvents, pretend=False, time_start=None, time_end=None):
+    return _ns_write_pump_events(
+        nightscout, 
+        exerciseEvents, 
+        lambda event: NightscoutEntry.activity(
+            created_at=event["time"],
+            reason=event["event_type"],
+            duration=event["duration_mins"],
+            event_type=EXERCISE_EVENTTYPE
+        ),
+        EXERCISE_EVENTTYPE,
+        pretend=pretend,
+        time_start=time_start,
+        time_end=time_end)
+
+def ns_write_sleep_activity_events(nightscout, sleepEvents, pretend=False, time_start=None, time_end=None):
+    return _ns_write_pump_events(
+        nightscout, 
+        sleepEvents, 
+        lambda event: NightscoutEntry.activity(
+            created_at=event["time"],
+            reason=event["event_type"],
+            duration=event["duration_mins"],
+            event_type=SLEEP_EVENTTYPE
+        ),
+        SLEEP_EVENTTYPE,
+        pretend=pretend,
+        time_start=time_start,
+        time_end=time_end)
+
+def ns_write_activity_events(nightscout, activityEvents, pretend=False, time_start=None, time_end=None):
+    return _ns_write_pump_events(
+        nightscout, 
+        activityEvents, 
+        lambda event: NightscoutEntry.activity(
+            created_at=event["time"],
+            reason=event["event_type"],
+            duration=event["duration_mins"]
+        ),
+        ACTIVITY_EVENTTYPE,
+        pretend=pretend,
+        time_start=time_start,
+        time_end=time_end)
+
+def _ns_write_pump_events(nightscout, events, buildNsEventFunc, eventType, pretend=False, time_start=None, time_end=None):
+    if len(events) == 0:
+        logger.debug("No %s events to process" % eventType)
+        return 0
+
+    logger.debug("ns_write_pump_events: querying for last %s" % eventType)
+    last_upload = nightscout.last_uploaded_entry(eventType, time_start=time_start, time_end=time_end)
+    last_upload_time = None
+    if last_upload:
+        last_upload_time = arrow.get(last_upload["created_at"])
+    logger.info("Last Nightscout %s: %s" % (eventType, last_upload_time))
+
+    if SKIP_NS_LAST_UPLOADED_CHECK:
+        logger.warning("Overriding last upload check")
+        last_upload = None
+        last_upload_time = None
+
+    add_count = 0
+    for event in events:
+        created_at = arrow.get(event["time"])
+        if last_upload_time and created_at <= last_upload_time:
+            skip = True
+            if "duration_mins" in event.keys() and "duration" in last_upload.keys():
+                if created_at == arrow.get(last_upload["created_at"]) and float(event["duration_mins"]) > float(last_upload["duration"]):
+                    logger.info("Latest %s event needs updating: duration has increased from %s to %s: %s" % (eventType, last_upload["duration"], event["duration_mins"], event))
+                    logger.info("Deleting previous %s: %s" % (eventType, last_upload))
+                    nightscout.delete_entry('treatments/%s' % last_upload["_id"])
+                    skip = False
+            
+            if skip:
+                if pretend:
+                    logger.info("Skipping %s pump event before last upload time: %s (time range: %s - %s)" % (eventType, event, time_start, time_end))
+                continue
+
+        entry = buildNsEventFunc(event)
+
+        add_count += 1
+
+        logger.info("  Processing %s: %s entry: %s" % (eventType, event, entry))
+        if not pretend:
+            nightscout.upload_entry(entry)
+
+    return add_count
@@ -0,0 +1,170 @@
+import time
+import logging
+import datetime
+import sys
+import arrow
+
+from ...features import DEFAULT_FEATURES
+from .process import ProcessTimeRange
+from .choose_device import ChooseDevice
+
+logger = logging.getLogger(__name__)
+
+class TandemSourceAutoupdate:
+    """Wrap access to secrets for easier testing."""
+    def __init__(self, secret):
+        self.secret = secret
+        self.autoupdate_invocations = 0
+        self.last_max_date_with_events = None
+        self.last_event_time = 0
+        self.last_attempt_time = 0
+        self.time_diffs_between_attempts = []
+        self.time_diffs_between_updates = []
+
+    """
+    Performs the auto-update functionality. Runs indefinitely in a loop
+    until stopped (ctrl+c), or a maximum of AUTOUPDATE_MAX_LOOP_INVOCATIONS times.
+    Stops if AUTOUPDATE_RESTART_ON_FAILURE is set and an error occurs.
+    """
+    def process(self, tconnect, nightscout, time_start, time_end, pretend, features=None):
+        if features is None:
+            features = DEFAULT_FEATURES
+
+        # Read from android api, find exact interval to cut down on API calls
+        # Refresh API token. If failure, die, have wrapper script re-run.
+
+        self.autoupdate_start = time.time()
+
+        while True:
+            logger.debug("autoupdate loop")
+            now = time.time()
+
+            tconnectDevice = ChooseDevice(self.secret, tconnect).choose()
+
+            cur_max_date_with_events = arrow.get(tconnectDevice['maxDateWithEvents'])
+            if not self.last_max_date_with_events or cur_max_date_with_events > self.cur_max_date_with_events:
+                logger.info('New reported tandemsource data. (cur_max_date: %s last_max_date: %s)' % (cur_max_date_with_events, self.last_max_date_with_events))
+
+                if pretend:
+                    logger.info('Would update now if not in pretend mode')
+                else:
+                    added = ProcessTimeRange(tconnect, nightscout, tconnectDevice, pretend, features=features).process(time_start, time_end)
+                    logger.info('Added %d items from ProcessTimeRange' % added)
+
+                # Track the time it took to find a new event between runs,
+                # but skip this calculation the first process cycle (since
+                # we don't know at what exact point the event index changed)
+                if self.last_event_index:
+                    self.time_diffs_between_updates.append(now - self.last_max_date_with_events)
+                    logger.debug('Updating tracking of time since last update: %s' % self.time_diffs_between_updates)
+
+                # Mark the last event index uploaded from the pump and timestamp
+                self.last_max_date_with_events = cur_max_date_with_events
+                self.last_event_time = now
+                self.last_attempt_time = now
+                self.time_diffs_between_attempts = []
+            else:
+                logger.info('No new reported tandemsource data. (cur_max_date: %s)' % cur_max_date_with_events)
+
+                # If we haven't seen the pump event index update in AUTOUPDATE_NO_DATA_FAILURE_MINUTES,
+                # then trigger an error and potentially restart.
+                # The most likely case here is that the pump isn't uploading right now.
+                if self.last_event_time and (now - self.last_event_time) >= 60 * self.secret.AUTOUPDATE_NO_DATA_FAILURE_MINUTES:
+                    logger.error(AutoupdateNoEventIndexesDetectedError(
+                        "%s: No new data event indexes have been detected for %d minutes. " % (datetime.datetime.now(), (now - self.last_event_time)//60) +
+                        "New data might not be uploading."))
+
+                    # TODO: restarting doesn't really help anything here.
+                    # Should we notify the user?
+                    if self.secret.AUTOUPDATE_RESTART_ON_FAILURE:
+                        logger.error("Exiting with error code due to AUTOUPDATE_RESTART_ON_FAILURE")
+                        return 1
+
+                # Similarly, if we HAVE seen pump event indexes update but have not successfully
+                # found any associated data updates from the tconnect API for AUTOUPDATE_NO_DATA_FAILURE_MINUTES,
+                # trigger an error and potentially restart. This could either be a tconnectsync problem,
+                # where we can see the indexes increasing, but it takes us until a period of no index
+                # update to reach our AUTOUPDATE_FAILURE_MINUTES threshold; or, a side effect of the
+                # above no indexes warning.
+                elif self.last_successful_process_time_range and (now - self.last_successful_process_time_range) >= 60 * self.secret.AUTOUPDATE_FAILURE_MINUTES:
+                    logger.error(AutoupdateNoNewDataDetectedError(
+                        "%s: No new data has been detected via the API for %d minutes. " % (datetime.datetime.now(), (now - self.last_successful_process_time_range)//60) +
+                        "tconnectsync might not be functioning properly."))
+
+                    if self.secret.AUTOUPDATE_RESTART_ON_FAILURE:
+                        logger.error("%s: Exiting with error code due to AUTOUPDATE_RESTART_ON_FAILURE" % datetime.datetime.now())
+                        return 1
+
+                # Track how long we've been retrying
+                if self.last_attempt_time:
+                    self.time_diffs_between_attempts.append(now - self.last_attempt_time)
+
+                self.last_attempt_time = now
+
+                # If it's been 3 loops since the last time we found new data,
+                # then we're not in sync with the rate at which pump data is being
+                # uploaded, so
+                if len(self.time_diffs_between_attempts) >= 3:
+                    # The pump hasn't sent us data that, based on previous cadence, we were expecting
+                    logger.warning(AutoupdateNoIndexChangeWarning("Sleeping %d seconds after unexpected no index change based on previous cadence. (New data might be delayed.)" %
+                        int(self.secret.AUTOUPDATE_UNEXPECTED_NO_INDEX_SLEEP_SECONDS)))
+
+                    logger.debug("Last event time: %s, time diffs between attempts: %s" % (self.last_event_time, self.time_diffs_between_attempts))
+
+                    time.sleep(self.secret.AUTOUPDATE_UNEXPECTED_NO_INDEX_SLEEP_SECONDS)
+
+                    # Since we bail early, update the invocations count and potentially exit after sleeping.
+                    self.autoupdate_invocations += 1
+                    if self.secret.AUTOUPDATE_MAX_LOOP_INVOCATIONS > 0 and self.autoupdate_invocations >= self.secret.AUTOUPDATE_MAX_LOOP_INVOCATIONS:
+                        return 0
+
+                    continue
+
+            sleep_secs = self.secret.AUTOUPDATE_DEFAULT_SLEEP_SECONDS
+
+            # Sleep for a rolling average of time between updates
+            if self.secret.AUTOUPDATE_USE_FIXED_SLEEP != 1:
+                logger.debug("Time diffs between updates: %s" % self.time_diffs_between_updates)
+
+                # Only keep the 10 latest time diffs
+                if len(self.time_diffs_between_updates) > 10:
+                    self.time_diffs_between_updates = self.time_diffs_between_updates[1:]
+
+                # If we have less than 3 data points,
+                if len(self.time_diffs_between_updates) > 2:
+                    sleep_secs = sum(self.time_diffs_between_updates) / len(self.time_diffs_between_updates)
+
+                # At minimum, update every AUTOUPDATE_MAX_SLEEP_SECONDS regardless
+                # of how often we're seeing new data appear
+                if sleep_secs > self.secret.AUTOUPDATE_MAX_SLEEP_SECONDS:
+                    sleep_secs = self.secret.AUTOUPDATE_MAX_SLEEP_SECONDS
+
+            logger.info('Sleeping for %0.01f sec' % sleep_secs)
+            time.sleep(sleep_secs)
+
+            self.autoupdate_invocations += 1
+            if self.secret.AUTOUPDATE_MAX_LOOP_INVOCATIONS > 0 and self.autoupdate_invocations >= self.secret.AUTOUPDATE_MAX_LOOP_INVOCATIONS:
+                return 0
+
+
+class AutoupdateError(RuntimeError):
+    def __str__(self):
+        return "%s: %s" % (self.__class__.__name__, super().__str__())
+
+class AutoupdateWarning(RuntimeWarning):
+    def __str__(self):
+        return "%s: %s" % (self.__class__.__name__, super().__str__())
+class AutoupdateFailureError(AutoupdateError):
+    pass
+
+class AutoupdateFailureWarning(AutoupdateWarning):
+    pass
+
+class AutoupdateNoEventIndexesDetectedError(AutoupdateError):
+    pass
+
+class AutoupdateNoNewDataDetectedError(AutoupdateError):
+    pass
+
+class AutoupdateNoIndexChangeWarning(AutoupdateWarning):
+    pass
@@ -0,0 +1,48 @@
+import arrow
+import logging
+
+logger = logging.getLogger(__name__)
+
+class ChooseDevice:
+    def __init__(self, secret, tconnect):
+        self.secret = secret
+        self.tconnect = tconnect
+
+    def choose(self):
+        tconnect = self.tconnect
+
+        pumpEventMetadata = tconnect.tandemsource.pump_event_metadata()
+
+        serialNumberToPump = {p['serialNumber']: p for p in pumpEventMetadata}
+        logger.info(f'Found {len(serialNumberToPump)} pumps: {serialNumberToPump.keys()}')
+
+        tconnectDevice = None
+
+        if self.secret.PUMP_SERIAL_NUMBER and str(self.secret.PUMP_SERIAL_NUMBER) != '11111111':
+            if not str(self.secret.PUMP_SERIAL_NUMBER) in serialNumberToPump.keys():
+                raise InvalidSerialNumber(f'Serial number {self.secret.PUMP_SERIAL_NUMBER} is not present on your account: choose one of {", ".join(serialNumberToPump.keys())}')
+
+            tconnectDevice = serialNumberToPump[str(self.secret.PUMP_SERIAL_NUMBER)]
+
+            logger.info(f'Using pump with serial: {tconnectDevice["serialNumber"]} (tconnectDeviceId: {tconnectDevice["tconnectDeviceId"]}, last seen: {tconnectDevice["maxDateWithEvents"]})')
+        else:
+            maxDateSeen = None
+            for pump in pumpEventMetadata:
+                if not tconnectDevice:
+                    tconnectDevice = pump
+                    maxDateSeen = arrow.get(pump['maxDateWithEvents'])
+                else:
+                    if arrow.get(pump['maxDateWithEvents']) > maxDateSeen:
+                        maxDateSeen = arrow.get(pump['maxDateWithEvents'])
+                        tconnectDevice = pump
+
+            logger.info(f'Using most recent pump (serial: {tconnectDevice["serialNumber"]}, tconnectDeviceId: {tconnectDevice["tconnectDeviceId"]}, last seen: {tconnectDevice["maxDateWithEvents"]})')
+
+
+        return tconnectDevice
+
+
+
+class InvalidSerialNumber(RuntimeError):
+    def __str__(self):
+        return "%s: %s" % (self.__class__.__name__, super().__str__())
@@ -0,0 +1,8 @@
+
+def insulin_float_round(amt):
+    if type(amt) != float:
+        return amt
+    return round(amt, 2)
+
+def insulin_milliunits_to_real(amtMilli):
+    return insulin_float_round(amtMilli / 1000)
@@ -0,0 +1,96 @@
+import logging
+import collections
+
+from ...features import DEFAULT_FEATURES
+from ...eventparser.generic import Events, decode_raw_events, EVENT_LEN
+from ...eventparser import events as eventtypes
+from ...domain.tandemsource.event_class import EventClass
+from .process_basal import ProcessBasal
+from .process_basal_suspension import ProcessBasalSuspension
+from .process_basal_resume import ProcessBasalResume
+from .process_alarm import ProcessAlarm
+from .process_bolus import ProcessBolus
+from .process_cartridge import ProcessCartridge
+from .process_cgm_alert import ProcessCGMAlert
+from .process_cgm_start_join_stop import ProcessCGMStartJoinStop
+from .process_cgm_reading import ProcessCGMReading
+from .process_user_mode import ProcessUserMode
+from .update_profiles import UpdateProfiles
+
+logger = logging.getLogger(__name__)
+
+class ProcessTimeRange:
+    def __init__(self, tconnect, nightscout, tconnectDevice, pretend, features=DEFAULT_FEATURES):
+        self.tconnect = tconnect
+        self.nightscout = nightscout
+        self.tconnect_device_id = tconnectDevice['tconnectDeviceId']
+        self.max_date_with_events = tconnectDevice['maxDateWithEvents']
+        self.pretend = pretend
+        self.features = features
+
+    event_classes = {
+        EventClass.BASAL.name: ProcessBasal,
+        EventClass.BASAL_SUSPENSION.name: ProcessBasalSuspension,
+        EventClass.BASAL_RESUME.name: ProcessBasalResume,
+        EventClass.ALARM.name: ProcessAlarm,
+        EventClass.BOLUS.name: ProcessBolus,
+        EventClass.CARTRIDGE.name: ProcessCartridge,
+        EventClass.CGM_ALERT.name: ProcessCGMAlert,
+        EventClass.CGM_START_JOIN_STOP.name: ProcessCGMStartJoinStop,
+        EventClass.CGM_READING.name: ProcessCGMReading,
+        EventClass.USER_MODE.name: ProcessUserMode,
+    }
+
+    updater_classes = [
+        UpdateProfiles
+    ]
+
+    def process(self, time_start, time_end):
+        logger.info(f"ProcessTimeRange {time_start=} {time_end=} {self.tconnect_device_id=} {self.features=}")
+
+        pump_events_raw = self.tconnect.tandemsource.pump_events_raw(self.tconnect_device_id, time_start, time_end)
+        pump_events_decoded = decode_raw_events(pump_events_raw)
+        logger.info(f"Read {len(pump_events_decoded)=} (est. {len(pump_events_decoded)/EVENT_LEN} events)")
+        events = Events(pump_events_decoded)
+
+        events_first_time = None
+        events_last_time = None
+        for_eventclass = collections.defaultdict(list)
+        for event in events:
+            if not events_first_time:
+                events_first_time = event.eventTimestamp
+            if not events_last_time:
+                events_last_time = event.eventTimestamp
+            events_first_time = min(events_first_time, event.eventTimestamp)
+            events_last_time = max(events_last_time, event.eventTimestamp)
+
+            clazz = EventClass.for_event(event)
+            if clazz:
+                for_eventclass[clazz.name].append(event)
+
+        count_by_eventclass = {k: len(v) for k,v in for_eventclass.items()}
+        logger.info(f"Found events: {count_by_eventclass}")
+
+        processed_count = 0
+        for clazz, events in for_eventclass.items():
+            if clazz in self.event_classes.keys():
+                c = self.event_classes[clazz](self.tconnect, self.nightscout, self.tconnect_device_id, self.pretend, self.features)
+                if c.enabled():
+                    logger.info("%s is enabled from features %s" % (clazz, self.features))
+                    ns_entries = c.process(events, events_first_time, events_last_time)
+                    processed_count += c.write(ns_entries)
+                else:
+                    logger.info("Skipping %s, is not enabled from features %s" % (clazz, self.features))
+
+        for updater_class in self.updater_classes:
+            c = updater_class(self.tconnect, self.nightscout, self.tconnect_device_id, self.pretend, self.features)
+            if c.enabled():
+                logger.info("%s is enabled from features %s" % (updater_class.__name__, self.features))
+                done = c.update(self.pretend)
+                logger.info("%s completed with update required: %s" % (updater_class.__name__, done))
+            else:
+                logger.info("Skipping %s, is not enabled from features %s" % (updater_class.__name__, self.features))
+
+        logger.info("Processed %d events" % processed_count)
+        return processed_count
+
@@ -0,0 +1,73 @@
+import logging
+import arrow
+
+from ...features import DEFAULT_FEATURES
+from ... import features
+from ...eventparser.generic import Events, decode_raw_events, EVENT_LEN
+from ...eventparser.utils import bitmask_to_list
+from ...eventparser import events as eventtypes
+from ...domain.tandemsource.event_class import EventClass
+from ...parser.nightscout import (
+    ALARM_EVENTTYPE,
+    NightscoutEntry
+)
+
+logger = logging.getLogger(__name__)
+
+class ProcessAlarm:
+    def __init__(self, tconnect, nightscout, tconnect_device_id, pretend, features=DEFAULT_FEATURES):
+        self.tconnect = tconnect
+        self.nightscout = nightscout
+        self.tconnect_device_id = tconnect_device_id
+        self.pretend = pretend
+        self.features = features
+
+    def enabled(self):
+        return features.PUMP_EVENTS in self.features
+
+    def process(self, events, time_start, time_end):
+        logger.debug("ProcessAlarm: querying for last uploaded alarm")
+        last_upload = self.nightscout.last_uploaded_entry(ALARM_EVENTTYPE, time_start=time_start, time_end=time_end)
+        last_upload_time = None
+        if last_upload:
+            last_upload_time = arrow.get(last_upload["created_at"])
+        logger.info("Last Nightscout alarm upload: %s" % last_upload_time)
+
+        ns_entries = []
+        for event in sorted(events, key=lambda x: x.eventTimestamp):
+            if last_upload_time and arrow.get(event.eventTimestamp) < last_upload_time:
+                if self.pretend:
+                    logger.info("Skipping Alarm event before last upload time: %s (time range: %s - %s)" % (event, time_start, time_end))
+                continue
+
+            ns_entries.append(self.alarm_to_nsentry(event))
+
+
+        return ns_entries
+
+    def write(self, ns_entries):
+        count = 0
+        for entry in ns_entries:
+            if self.pretend:
+                logger.info("Would upload to Nightscout: %s" % entry)
+            else:
+                logger.info("Uploading to Nightscout: %s" % entry)
+                self.nightscout.upload_entry(entry)
+            count += 1
+
+        return count
+
+
+    def alarm_to_nsentry(self, event):
+        if type(event) == eventtypes.LidAlarmActivated:
+            return NightscoutEntry.alarm(
+                created_at = event.eventTimestamp.format(),
+                reason = "%s" % event.alarmid.name,
+                pump_event_id = "%s" % event.eventId
+            )
+        elif type(event) == eventtypes.LidMalfunctionActivated:
+            return NightscoutEntry.alarm(
+                created_at = event.eventTimestamp.format(),
+                reason = "Malfunction",
+                pump_event_id = "%s" % event.eventId
+            )
@@ -0,0 +1,86 @@
+import logging
+import arrow
+
+from ...features import DEFAULT_FEATURES
+from ... import features
+from ...eventparser.generic import Events, decode_raw_events, EVENT_LEN
+from ...eventparser.utils import bitmask_to_list
+from ...eventparser import events as eventtypes
+from .helpers import insulin_float_round, insulin_milliunits_to_real
+from ...domain.tandemsource.event_class import EventClass
+from ...parser.nightscout import (
+    BASAL_EVENTTYPE,
+    NightscoutEntry
+)
+
+logger = logging.getLogger(__name__)
+
+class ProcessBasal:
+    def __init__(self, tconnect, nightscout, tconnect_device_id, pretend, features=DEFAULT_FEATURES):
+        self.tconnect = tconnect
+        self.nightscout = nightscout
+        self.tconnect_device_id = tconnect_device_id
+        self.pretend = pretend
+        self.features = features
+
+    def enabled(self):
+        return features.BASAL in self.features
+
+    def process(self, events, time_start, time_end):
+        logger.debug("ProcessBasal: querying for last uploaded entry")
+        last_upload = self.nightscout.last_uploaded_entry(BASAL_EVENTTYPE, time_start=time_start, time_end=time_end)
+        last_upload_time = None
+        if last_upload:
+            last_upload_time = arrow.get(last_upload["created_at"])
+        logger.info("Last Nightscout basal upload: %s" % last_upload_time)
+
+        with_duration = []
+        for event in sorted(events, key=lambda x: x.eventTimestamp):
+            if last_upload_time and arrow.get(event.eventTimestamp) < last_upload_time:
+                if self.pretend:
+                    logger.info("Skipping basal event before last upload time: %s (time range: %s - %s)" % (event, time_start, time_end))
+                continue
+
+            with_duration.append([event.eventTimestamp, None, event])
+
+        for i in range(len(with_duration)-1):
+            with_duration[i][1] = with_duration[i+1][0] - with_duration[i][0]
+
+        with_duration[-1][1] = time_end - with_duration[-1][0]
+
+        ns_entries = []
+        for item in with_duration:
+            ns_entries.append(self.basal_to_nsentry(*item))
+
+        return ns_entries
+
+    def write(self, ns_entries):
+        count = 0
+        for entry in ns_entries:
+            if self.pretend:
+                logger.info("Would upload to Nightscout: %s" % entry)
+            else:
+                logger.info("Uploading to Nightscout: %s" % entry)
+                self.nightscout.upload_entry(entry)
+            count += 1
+
+        return count
+
+
+    def basal_to_nsentry(self, start, duration, event):
+        if type(event) == eventtypes.LidBasalRateChange:
+            return NightscoutEntry.basal(
+                value = insulin_float_round(event.commandedbasalrate),
+                duration_mins = duration.seconds / 60,
+                created_at = start.format(),
+                reason = ', '.join(bitmask_to_list(event.changetype)),
+                pump_event_id = "%s" % event.eventId
+            )
+        if type(event) == eventtypes.LidBasalDelivery:
+            return NightscoutEntry.basal(
+                value = insulin_milliunits_to_real(event.commandedRate),
+                duration_mins = duration.seconds / 60,
+                created_at = start.format(),
+                reason = ', '.join(bitmask_to_list(event.commandedRateSource)),
+                pump_event_id = "%s" % event.eventId
+            )
@@ -0,0 +1,66 @@
+import logging
+import arrow
+
+from ...features import DEFAULT_FEATURES
+from ... import features
+from ...eventparser.generic import Events, decode_raw_events, EVENT_LEN
+from ...eventparser.utils import bitmask_to_list
+from ...eventparser import events as eventtypes
+from ...domain.tandemsource.event_class import EventClass
+from ...parser.nightscout import (
+    BASALRESUME_EVENTTYPE,
+    NightscoutEntry
+)
+
+logger = logging.getLogger(__name__)
+
+class ProcessBasalResume:
+    def __init__(self, tconnect, nightscout, tconnect_device_id, pretend, features=DEFAULT_FEATURES):
+        self.tconnect = tconnect
+        self.nightscout = nightscout
+        self.tconnect_device_id = tconnect_device_id
+        self.pretend = pretend
+        self.features = features
+
+    def enabled(self):
+        return features.PUMP_EVENTS in self.features
+
+    def process(self, events, time_start, time_end):
+        logger.debug("ProcessBasalResume: querying for last uploaded resume-suspension")
+        last_upload = self.nightscout.last_uploaded_entry(BASALRESUME_EVENTTYPE, time_start=time_start, time_end=time_end)
+        last_upload_time = None
+        if last_upload:
+            last_upload_time = arrow.get(last_upload["created_at"])
+        logger.info("Last Nightscout BasalResume upload: %s" % last_upload_time)
+
+        ns_entries = []
+        for event in sorted(events, key=lambda x: x.eventTimestamp):
+            if last_upload_time and arrow.get(event.eventTimestamp) < last_upload_time:
+                if self.pretend:
+                    logger.info("Skipping BasalResume event before last upload time: %s (time range: %s - %s)" % (event, time_start, time_end))
+                continue
+
+            ns_entries.append(self.resume_to_nsentry(event))
+
+
+        return ns_entries
+
+    def write(self, ns_entries):
+        count = 0
+        for entry in ns_entries:
+            if self.pretend:
+                logger.info("Would upload to Nightscout: %s" % entry)
+            else:
+                logger.info("Uploading to Nightscout: %s" % entry)
+                self.nightscout.upload_entry(entry)
+            count += 1
+
+        return count
+
+
+    def resume_to_nsentry(self, event):
+        if type(event) == eventtypes.LidPumpingResumed:
+            return NightscoutEntry.basalresume(
+                created_at = event.eventTimestamp.format(),
+                pump_event_id = "%s" % event.eventId
+            )
@@ -0,0 +1,67 @@
+import logging
+import arrow
+
+from ...features import DEFAULT_FEATURES
+from ... import features
+from ...eventparser.generic import Events, decode_raw_events, EVENT_LEN
+from ...eventparser.utils import bitmask_to_list
+from ...eventparser import events as eventtypes
+from ...domain.tandemsource.event_class import EventClass
+from ...parser.nightscout import (
+    BASALSUSPENSION_EVENTTYPE,
+    NightscoutEntry
+)
+
+logger = logging.getLogger(__name__)
+
+class ProcessBasalSuspension:
+    def __init__(self, tconnect, nightscout, tconnect_device_id, pretend, features=DEFAULT_FEATURES):
+        self.tconnect = tconnect
+        self.nightscout = nightscout
+        self.tconnect_device_id = tconnect_device_id
+        self.pretend = pretend
+        self.features = features
+
+    def enabled(self):
+        return features.PUMP_EVENTS in self.features or features.BASAL in self.features
+
+    def process(self, events, time_start, time_end):
+        logger.debug("ProcessBasalSuspension: querying for last uploaded suspension")
+        last_upload = self.nightscout.last_uploaded_entry(BASALSUSPENSION_EVENTTYPE, time_start=time_start, time_end=time_end)
+        last_upload_time = None
+        if last_upload:
+            last_upload_time = arrow.get(last_upload["created_at"])
+        logger.info("Last Nightscout basalsuspension upload: %s" % last_upload_time)
+
+        ns_entries = []
+        for event in sorted(events, key=lambda x: x.eventTimestamp):
+            if last_upload_time and arrow.get(event.eventTimestamp) < last_upload_time:
+                if self.pretend:
+                    logger.info("Skipping basalsuspension event before last upload time: %s (time range: %s - %s)" % (event, time_start, time_end))
+                continue
+
+            ns_entries.append(self.suspension_to_nsentry(event))
+
+
+        return ns_entries
+
+    def write(self, ns_entries):
+        count = 0
+        for entry in ns_entries:
+            if self.pretend:
+                logger.info("Would upload to Nightscout: %s" % entry)
+            else:
+                logger.info("Uploading to Nightscout: %s" % entry)
+                self.nightscout.upload_entry(entry)
+            count += 1
+
+        return count
+
+
+    def suspension_to_nsentry(self, event):
+        if type(event) == eventtypes.LidPumpingSuspended:
+            return NightscoutEntry.basalsuspension(
+                created_at = event.eventTimestamp.format(),
+                reason = ', '.join(bitmask_to_list(event.suspendreason)),
+                pump_event_id = "%s" % event.eventId
+            )
@@ -0,0 +1,112 @@
+import logging
+import arrow
+
+from ...features import DEFAULT_FEATURES
+from ... import features
+from ...eventparser.generic import Events, decode_raw_events, EVENT_LEN
+from ...eventparser.utils import bitmask_to_list
+from ...eventparser import events as eventtypes
+from ...domain.tandemsource.event_class import EventClass
+from .helpers import insulin_float_round
+from ...parser.nightscout import (
+    BOLUS_EVENTTYPE,
+    NightscoutEntry
+)
+
+logger = logging.getLogger(__name__)
+
+class ProcessBolus:
+    def __init__(self, tconnect, nightscout, tconnect_device_id, pretend, features=DEFAULT_FEATURES):
+        self.tconnect = tconnect
+        self.nightscout = nightscout
+        self.tconnect_device_id = tconnect_device_id
+        self.pretend = pretend
+        self.features = features
+
+    def enabled(self):
+        return features.BOLUS in self.features
+
+    def process(self, events, time_start, time_end):
+        logger.debug("ProcessBolus: querying for last uploaded entry")
+        last_upload = self.nightscout.last_uploaded_entry(BOLUS_EVENTTYPE, time_start=time_start, time_end=time_end)
+        last_upload_time = None
+        if last_upload:
+            last_upload_time = arrow.get(last_upload["created_at"])
+        logger.info("Last Nightscout bolus upload: %s" % last_upload_time)
+
+        # TODO EXTENDED BOLUSES
+        bolusCompletedEvents = []
+        bolusEventsForId = {}
+        for event in sorted(events, key=lambda x: x.eventTimestamp):
+            if event.bolusid not in bolusEventsForId.keys():
+                bolusEventsForId[event.bolusid] = {}
+
+            bolusEventsForId[event.bolusid][type(event)] = event
+
+            if type(event) == eventtypes.LidBolusCompleted:
+                if last_upload_time and arrow.get(event.eventTimestamp) < last_upload_time:
+                    if self.pretend:
+                        logger.info("Skipping bolusCompletedEvent before last upload time: %s (time range: %s - %s)" % (event, time_start, time_end))
+                    continue
+
+                bolusCompletedEvents.append(event)
+
+        bolusCompletedEvents.sort(key=lambda e: e.eventTimestamp)
+
+
+
+        ns_entries = []
+        for bolusCompleted in bolusCompletedEvents:
+            m = bolusEventsForId[bolusCompleted.bolusid]
+
+            ns_entries.append(self.bolus_to_nsentry(
+                bolusCompleted,
+                bolusRequested1 = m.get(eventtypes.LidBolusRequestedMsg1),
+                bolusRequested2 = m.get(eventtypes.LidBolusRequestedMsg2),
+                bolusRequested3 = m.get(eventtypes.LidBolusRequestedMsg3),
+            ))
+
+        return ns_entries
+
+    def write(self, ns_entries):
+        count = 0
+        for entry in ns_entries:
+            if self.pretend:
+                logger.info("Would upload to Nightscout: %s" % entry)
+            else:
+                logger.info("Uploading to Nightscout: %s" % entry)
+                self.nightscout.upload_entry(entry)
+            count += 1
+
+        return count
+
+
+    def bolus_to_nsentry(self, bolusCompleted, bolusRequested1, bolusRequested2, bolusRequested3):
+        suffixes = []
+        if bolusRequested2 and bolusRequested2.useroverride == eventtypes.LidBolusRequestedMsg2.UseroverrideEnum.Yes:
+            suffixes.append('(Override)')
+
+        if bolusRequested2 and bolusRequested2.declinedcorrection == eventtypes.LidBolusRequestedMsg2.DeclinedcorrectionEnum.Yes:
+            suffixes.append('(Declined Correction)')
+
+        suffix = (' ' + (' '.join(suffixes))) if suffixes else ''
+
+        event_ids = []
+        for e in [bolusCompleted, bolusRequested1, bolusRequested2, bolusRequested3]:
+            if e:
+                event_ids.append(str(e.eventId))
+
+        notes = ''
+        if bolusRequested2 and str(bolusRequested2.optionsRaw) in eventtypes.LidBolusRequestedMsg2.OptionsMap:
+            notes = eventtypes.LidBolusRequestedMsg2.OptionsMap['%d' % bolusRequested2.optionsRaw]
+
+
+        return NightscoutEntry.bolus(
+            bolus = insulin_float_round(bolusCompleted.insulindelivered),
+            carbs = bolusRequested1.carbamount if bolusRequested1 and bolusRequested1.carbamount>0 else None,
+            created_at = bolusCompleted.eventTimestamp.format(),
+            notes = notes + suffix,
+            bg = bolusRequested1.BG if bolusRequested1 and bolusRequested1.BG > 0 else None,
+            pump_event_id = ",".join(event_ids)
+        )
+
@@ -0,0 +1,100 @@
+import logging
+import arrow
+
+from ...features import DEFAULT_FEATURES
+from ... import features
+from ...eventparser.generic import Events, decode_raw_events, EVENT_LEN
+from ...eventparser.utils import bitmask_to_list
+from ...eventparser import events as eventtypes
+from ...domain.tandemsource.event_class import EventClass
+from ...parser.nightscout import (
+    SITECHANGE_EVENTTYPE,
+    NightscoutEntry
+)
+
+logger = logging.getLogger(__name__)
+
+class ProcessCartridge:
+    def __init__(self, tconnect, nightscout, tconnect_device_id, pretend, features=DEFAULT_FEATURES):
+        self.tconnect = tconnect
+        self.nightscout = nightscout
+        self.tconnect_device_id = tconnect_device_id
+        self.pretend = pretend
+        self.features = features
+
+    def enabled(self):
+        return features.PUMP_EVENTS in self.features
+
+    def process(self, events, time_start, time_end):
+        logger.debug("ProcessCartridge: querying for last uploaded entry")
+        last_upload = self.nightscout.last_uploaded_entry(SITECHANGE_EVENTTYPE, time_start=time_start, time_end=time_end)
+        last_upload_time = None
+        if last_upload:
+            last_upload_time = arrow.get(last_upload["created_at"])
+        logger.info("Last Nightscout sitechange upload: %s" % last_upload_time)
+
+        cartFilledEvents = []
+        cannulaFilledEvents = []
+        tubingFilledEvents = []
+        for event in sorted(events, key=lambda x: x.eventTimestamp):
+            if last_upload_time and arrow.get(event.eventTimestamp) < last_upload_time:
+                if self.pretend:
+                    logger.info("Skipping %s before last upload time: %s (time range: %s - %s)" % (type(event), event, time_start, time_end))
+                continue
+
+            if type(event) == eventtypes.LidCartridgeFilled:
+                cartFilledEvents.append(event)
+            elif type(event) == eventtypes.LidCannulaFilled:
+                cannulaFilledEvents.append(event)
+            elif type(event) == eventtypes.LidTubingFilled:
+                tubingFilledEvents.append(event)
+
+        cartFilledEvents.sort(key=lambda e: e.eventTimestamp)
+        cannulaFilledEvents.sort(key=lambda e: e.eventTimestamp)
+        tubingFilledEvents.sort(key=lambda e: e.eventTimestamp)
+
+        ns_entries = []
+        for cartFilled in cartFilledEvents:
+            ns_entries.append(self.cart_to_nsentry(cartFilled))
+
+        for cannulaFilled in cannulaFilledEvents:
+            ns_entries.append(self.cannula_to_nsentry(cannulaFilled))
+
+        for tubingFilled in tubingFilledEvents:
+            ns_entries.append(self.tubing_to_nsentry(tubingFilled))
+
+
+        return ns_entries
+
+    def write(self, ns_entries):
+        count = 0
+        for entry in ns_entries:
+            if self.pretend:
+                logger.info("Would upload to Nightscout: %s" % entry)
+            else:
+                logger.info("Uploading to Nightscout: %s" % entry)
+                self.nightscout.upload_entry(entry)
+            count += 1
+
+        return count
+
+    def cart_to_nsentry(self, cartFilled):
+        return NightscoutEntry.sitechange(
+            created_at = cartFilled.eventTimestamp.format(),
+            reason = "Cartridge Filled" + (" (%du filled)" % round(cartFilled.v2Volume) if cartFilled.v2Volume else ""),
+            pump_event_id = "%s" % cartFilled.eventId
+        )
+
+    def cannula_to_nsentry(self, cannulaFilled):
+        return NightscoutEntry.sitechange(
+            created_at = cannulaFilled.eventTimestamp.format(),
+            reason = "Cannula Filled" + (" (%du primed)" % round(cannulaFilled.primesize, 2) if cannulaFilled.primesize else ""),
+            pump_event_id = "%s" % cannulaFilled.eventId
+        )
+
+    def tubing_to_nsentry(self, tubingFilled):
+        return NightscoutEntry.sitechange(
+            created_at = tubingFilled.eventTimestamp.format(),
+            reason = "Tubing Filled" + (" (%du primed)" % round(tubingFilled.primesize) if tubingFilled.primesize else ""),
+            pump_event_id = "%s" % tubingFilled.eventId
+        )
@@ -0,0 +1,92 @@
+import logging
+import arrow
+
+from ...features import DEFAULT_FEATURES
+from ... import features
+from ...eventparser.generic import Events, decode_raw_events, EVENT_LEN
+from ...eventparser.utils import bitmask_to_list
+from ...eventparser import events as eventtypes
+from ...domain.tandemsource.event_class import EventClass
+from ...parser.nightscout import (
+    CGM_ALERT_EVENTTYPE,
+    NightscoutEntry
+)
+
+logger = logging.getLogger(__name__)
+
+class ProcessCGMAlert:
+    def __init__(self, tconnect, nightscout, tconnect_device_id, pretend, features=DEFAULT_FEATURES):
+        self.tconnect = tconnect
+        self.nightscout = nightscout
+        self.tconnect_device_id = tconnect_device_id
+        self.pretend = pretend
+        self.features = features
+
+    def enabled(self):
+        return features.CGM_ALERTS in self.features
+
+    def process(self, events, time_start, time_end):
+        logger.debug("ProcessCGMAlert: querying for last uploaded entry")
+        last_upload = self.nightscout.last_uploaded_entry(CGM_ALERT_EVENTTYPE, time_start=time_start, time_end=time_end)
+        last_upload_time = None
+        if last_upload:
+            last_upload_time = arrow.get(last_upload["created_at"])
+        logger.info("Last Nightscout cgmalert upload: %s" % last_upload_time)
+
+        alertEvents = []
+        for event in sorted(events, key=lambda x: x.eventTimestamp):
+            if last_upload_time and arrow.get(event.eventTimestamp) < last_upload_time:
+                if self.pretend:
+                    logger.info("Skipping %s before last upload time: %s (time range: %s - %s)" % (type(event), event, time_start, time_end))
+                continue
+
+            alertEvents.append(event)
+
+        alertEvents.sort(key=lambda e: e.eventTimestamp)
+
+        ns_entries = []
+        for event in alertEvents:
+            e = self.alert_to_nsentry(event)
+            if e:
+                ns_entries.append(e)
+
+        return ns_entries
+
+    def write(self, ns_entries):
+        count = 0
+        for entry in ns_entries:
+            if self.pretend:
+                logger.info("Would upload to Nightscout: %s" % entry)
+            else:
+                logger.info("Uploading to Nightscout: %s" % entry)
+                self.nightscout.upload_entry(entry)
+            count += 1
+
+        return count
+
+    def alert_to_nsentry(self, alert):
+        if not alert.dalertid:
+            logger.info("ProcessCGMAlert: Skipping alert with unknown dalertid %d: %s" % (alert.dalertidRaw, alert))
+            return None
+
+        if type(alert) == eventtypes.LidCgmAlertActivated:
+            return NightscoutEntry.cgm_alert(
+                created_at = alert.eventTimestamp.format(),
+                reason = ("CGM Alert (%s)" % alert.dalertid.name) if alert.dalertid else "CGM Alert (Unknown)",
+                pump_event_id = "%s" % alert.eventId
+            )
+        elif type(alert) == eventtypes.LidCgmAlertActivatedDex:
+            if alert.dalertid == eventtypes.LidCgmAlertActivatedDex.DalertidEnum.CgmOutOfRange:
+                logger.info("ProcessCGMAlert: Skipping alert with CgmOutOfRange dalertid %d: %s" % (alert.dalertidRaw, alert))
+                return None
+            return NightscoutEntry.cgm_alert(
+                created_at = alert.eventTimestamp.format(),
+                reason = ("Dexcom CGM Alert (%s)" % alert.dalertid.name) if alert.dalertid else "Dexcom CGM Alert (Unknown)",
+                pump_event_id = "%s" % alert.eventId
+            )
+        elif type(alert) == eventtypes.LidCgmAlertActivatedFsl2:
+            return NightscoutEntry.cgm_alert(
+                created_at = alert.eventTimestamp.format(),
+                reason = ("Libre CGM Alert (%s)" % alert.dalertid.name) if alert.dalertid else "Libre CGM Alert (Unknown)",
+                pump_event_id = "%s" % alert.eventId
+            )
@@ -0,0 +1,76 @@
+import logging
+import arrow
+
+from ...features import DEFAULT_FEATURES
+from ... import features
+from ...eventparser.generic import Events, decode_raw_events, EVENT_LEN
+from ...eventparser.utils import bitmask_to_list
+from ...eventparser.raw_event import TANDEM_EPOCH
+from ...eventparser import events as eventtypes
+from ...domain.tandemsource.event_class import EventClass
+from ...parser.nightscout import (
+    CGM_START_EVENTTYPE,
+    NightscoutEntry
+)
+
+logger = logging.getLogger(__name__)
+
+class ProcessCGMReading:
+    def __init__(self, tconnect, nightscout, tconnect_device_id, pretend, features=DEFAULT_FEATURES):
+        self.tconnect = tconnect
+        self.nightscout = nightscout
+        self.tconnect_device_id = tconnect_device_id
+        self.pretend = pretend
+        self.features = features
+
+    def enabled(self):
+        return features.CGM in self.features
+
+    def process(self, events, time_start, time_end):
+        logger.debug("ProcessCGMReading: querying for last uploaded entry")
+        last_upload = self.nightscout.last_uploaded_bg_entry(time_start=time_start, time_end=time_end)
+        last_upload_time = None
+        if last_upload and "dateString" in last_upload:
+            last_upload_time = arrow.get(last_upload["dateString"])
+        elif last_upload and "date" in last_upload:
+            last_upload_time = arrow.get(last_upload["date"])
+        logger.info("ProcessCGMReading: Last Nightscout bg upload: %s" % last_upload_time)
+
+        readings = []
+        for event in sorted(events, key=lambda x: self.timestamp_for(x)):
+            if last_upload_time and self.timestamp_for(event) < last_upload_time:
+                if self.pretend:
+                    logger.info("ProcessCGMReading: Skipping %s before last upload time: %s (time range: %s - %s)" % (type(event), event, time_start, time_end))
+                continue
+
+            readings.append(event)
+
+        ns_entries = []
+        for event in readings:
+            ns_entries.append(self.to_nsentry(event))
+
+        return ns_entries
+
+    def write(self, ns_entries):
+        count = 0
+        for entry in ns_entries:
+            if self.pretend:
+                logger.info("Would upload to Nightscout: %s" % entry)
+            else:
+                logger.info("Uploading to Nightscout: %s" % entry)
+                self.nightscout.upload_entry(entry, entity='entries')
+            count += 1
+
+        return count
+
+    def timestamp_for(self, event):
+        # For backfills the time the event was added to the pump's event store
+        # might not be the time it actually occurred, so we use the egvTimestamp
+        return arrow.get(TANDEM_EPOCH + event.egvTimestamp)
+
+    def to_nsentry(self, event):
+        return NightscoutEntry.entry(
+            sgv = event.currentglucosedisplayvalue,
+            created_at = self.timestamp_for(event).format(),
+            pump_event_id = "%s" % event.eventId,
+        )
@@ -0,0 +1,96 @@
+import logging
+import arrow
+
+from ...features import DEFAULT_FEATURES
+from ... import features
+from ...eventparser.generic import Events, decode_raw_events, EVENT_LEN
+from ...eventparser.utils import bitmask_to_list
+from ...eventparser import events as eventtypes
+from ...domain.tandemsource.event_class import EventClass
+from ...parser.nightscout import (
+    CGM_START_EVENTTYPE,
+    CGM_JOIN_EVENTTYPE,
+    CGM_STOP_EVENTTYPE,
+    NightscoutEntry
+)
+
+logger = logging.getLogger(__name__)
+
+class ProcessCGMStartJoinStop:
+    def __init__(self, tconnect, nightscout, tconnect_device_id, pretend, features=DEFAULT_FEATURES):
+        self.tconnect = tconnect
+        self.nightscout = nightscout
+        self.tconnect_device_id = tconnect_device_id
+        self.pretend = pretend
+        self.features = features
+
+    def enabled(self):
+        return features.PUMP_EVENTS in self.features or features.CGM_ALERTS in self.features
+
+    def process(self, events, time_start, time_end):
+        last_upload = None
+        last_upload_time = None
+        for eventtype in [CGM_START_EVENTTYPE, CGM_JOIN_EVENTTYPE, CGM_STOP_EVENTTYPE]:
+            logger.debug("ProcessCGMStartJoinStop: querying for last uploaded entry for %s" % eventtype)
+            _last_upload = self.nightscout.last_uploaded_entry(eventtype, time_start=time_start, time_end=time_end)
+            _last_upload_time = None
+            if _last_upload:
+                _last_upload_time = arrow.get(_last_upload["created_at"])
+
+                if not last_upload_time:
+                    last_upload = _last_upload
+                    last_upload_time = _last_upload_time
+                elif _last_upload_time > last_upload_time:
+                    last_upload = _last_upload
+                    last_upload_time = _last_upload_time
+            logger.info("ProcessCGMStartJoinStop: Last Nightscout %s upload: %s" % (eventtype, _last_upload_time))
+        logger.info("ProcessCGMStartJoinStop: Overall last Nightscout upload: %s %s" % (last_upload_time, last_upload))
+
+        allEvents = []
+        for event in sorted(events, key=lambda x: x.eventTimestamp):
+            if last_upload_time and arrow.get(event.eventTimestamp) < last_upload_time:
+                if self.pretend:
+                    logger.info("ProcessCGMStartJoinStop: Skipping %s before last upload time: %s (time range: %s - %s)" % (type(event), event, time_start, time_end))
+                continue
+
+            allEvents.append(event)
+
+        allEvents.sort(key=lambda e: e.eventTimestamp)
+
+        ns_entries = []
+        for event in allEvents:
+            ns_entries.append(self.to_nsentry(event))
+
+        return ns_entries
+
+    def write(self, ns_entries):
+        count = 0
+        for entry in ns_entries:
+            if self.pretend:
+                logger.info("Would upload to Nightscout: %s" % entry)
+            else:
+                logger.info("Uploading to Nightscout: %s" % entry)
+                self.nightscout.upload_entry(entry)
+            count += 1
+
+        return count
+
+    def to_nsentry(self, event):
+        if type(event) in EventClass._CGM_START:
+            return NightscoutEntry.cgm_start(
+                created_at = event.eventTimestamp.format(),
+                reason = "CGM Session Started",
+                pump_event_id = "%s" % event.eventId
+            )
+        elif type(event) in EventClass._CGM_JOIN:
+            return NightscoutEntry.cgm_join(
+                created_at = event.eventTimestamp.format(),
+                reason = "CGM Session Joined",
+                pump_event_id = "%s" % event.eventId
+            )
+        elif type(event) in EventClass._CGM_STOP:
+            return NightscoutEntry.cgm_stop(
+                created_at = event.eventTimestamp.format(),
+                reason = "CGM Session Stopped",
+                pump_event_id = "%s" % event.eventId
+            )
@@ -0,0 +1,244 @@
+import logging
+import arrow
+
+from ...features import DEFAULT_FEATURES
+from ... import features
+from ...eventparser.generic import Events, decode_raw_events, EVENT_LEN
+from ...eventparser.utils import bitmask_to_list
+from ...eventparser import events as eventtypes
+from ...domain.tandemsource.event_class import EventClass
+from ...parser.nightscout import (
+    EXERCISE_EVENTTYPE,
+    SLEEP_EVENTTYPE,
+    NightscoutEntry
+)
+
+NOT_ENDED = "Not Ended"
+
+logger = logging.getLogger(__name__)
+
+class ProcessUserMode:
+    def __init__(self, tconnect, nightscout, tconnect_device_id, pretend, features=DEFAULT_FEATURES):
+        self.tconnect = tconnect
+        self.nightscout = nightscout
+        self.tconnect_device_id = tconnect_device_id
+        self.pretend = pretend
+        self.features = features
+
+    def enabled(self):
+        return features.PUMP_EVENTS in self.features
+
+    def process(self, events, time_start, time_end):
+        logger.debug("ProcessUserMode: querying for last uploaded exercise entry")
+        exercise_last_upload = self.nightscout.last_uploaded_entry(EXERCISE_EVENTTYPE, time_start=time_start, time_end=time_end)
+        exercise_last_upload_time = None
+        if exercise_last_upload:
+            exercise_last_upload_time = arrow.get(exercise_last_upload["created_at"])
+        logger.info("ProcessUserMode: Last Nightscout exercise upload: %s" % exercise_last_upload_time)
+
+        exercise_not_ended = False
+        if exercise_last_upload and NOT_ENDED in exercise_last_upload.get("reason", ""):
+            exercise_not_ended = True
+            logger.info("ProcessUserMode: Last exercise not ended: %s" % exercise_last_upload)
+
+
+        logger.debug("ProcessUserMode: querying for last uploaded sleep entry")
+        sleep_last_upload = self.nightscout.last_uploaded_entry(SLEEP_EVENTTYPE, time_start=time_start, time_end=time_end)
+        sleep_last_upload_time = None
+        if sleep_last_upload:
+            sleep_last_upload_time = arrow.get(sleep_last_upload["created_at"])
+        logger.info("ProcessUserMode: Last Nightscout sleep upload: %s" % sleep_last_upload_time)
+
+        sleep_not_ended = False
+        if sleep_last_upload and NOT_ENDED in sleep_last_upload.get("reason", ""):
+            sleep_not_ended = True
+            logger.info("ProcessUserMode: Last sleep not ended: %s" % sleep_last_upload)
+
+        last_upload_time = None
+        if exercise_last_upload_time and sleep_last_upload_time:
+            last_upload_time = max(exercise_last_upload_time, sleep_last_upload_time)
+        elif exercise_last_upload_time:
+            last_upload_time = exercise_last_upload_time
+        elif sleep_last_upload_time:
+            last_upload_time = sleep_last_upload_time
+
+        logger.info("ProcessUserMode: Last Nightscout usermode upload: %s" % last_upload_time)
+
+
+        ns_entries = []
+
+        processed_sleep = []
+        processed_exercise = []
+        start_sleep = None
+        start_exercise = None
+        for event in sorted(events, key=lambda x: x.eventTimestamp):
+            if last_upload_time and arrow.get(event.eventTimestamp) < last_upload_time:
+                if self.pretend:
+                    logger.info("ProcessUserMode: Skipping usermode event before last upload time: %s (time range: %s - %s)" % (event, time_start, time_end))
+                continue
+
+            if self.is_start_sleep(event):
+                start_sleep = event
+            elif self.is_stop_sleep(event):
+                if start_sleep:
+                    processed_sleep.append((start_sleep, event))
+                    start_sleep = None
+                else:
+                    if sleep_not_ended:
+                        logger.info("ProcessUserMode: Found StopSleep without StartSleep, with incomplete sleep event in nightscout: %s NS: %s" % (event, sleep_last_upload))
+                        ns_entries.append(self.process_unended_sleep_stop(event, sleep_last_upload))
+                    else:
+                        logger.warning("ProcessUserMode: Found StopSleep without StartSleep, and no active sleep event in nightscout: %s" % event)
+            elif self.is_start_exercise(event):
+                start_exercise = event
+            elif self.is_stop_exercise(event):
+                if start_exercise:
+                    processed_exercise.append((start_exercise, event))
+                    start_exercise = None
+                else:
+                    if exercise_not_ended:
+                        logger.info("ProcessUserMode: Found StopExercise without StartExercise, with incomplete exercise event in nightscout: %s NS: %s" % (event, exercise_last_upload))
+                        ns_entries.append(self.process_unended_exercise_stop(event, exercise_last_upload))
+                    else:
+                        logger.warning("ProcessUserMode: Found StopExercise without StartExercise, and no active exercise event in nightscout: %s" % event)
+            else:
+                logger.warning("ProcessUserMode: not sure how to process event: %s" % event)
+
+        if start_sleep:
+            processed_sleep.append((start_sleep, None))
+            logger.info("ProcessUserMode: sleep is active")
+        if start_exercise:
+            processed_exercise.append((start_exercise, None))
+            logger.info("ProcessUserMode: exercise is active")
+
+        for items in processed_sleep:
+            ns_entries.append(self.sleep_to_nsentry(start=items[0], stop=items[1], time_end=time_end))
+
+        for items in processed_exercise:
+            ns_entries.append(self.exercise_to_nsentry(start=items[0], stop=items[1], time_end=time_end))
+
+        return ns_entries
+
+    def write(self, ns_entries):
+        count = 0
+        for entry in ns_entries:
+            if self.pretend:
+                logger.info("Would upload to Nightscout: %s" % entry)
+            else:
+                logger.info("Uploading to Nightscout: %s" % entry)
+                self.nightscout.upload_entry(entry)
+            count += 1
+
+        return count
+
+    def is_start_sleep(self, event):
+        return event.requestedaction == eventtypes.LidAaUserModeChange.RequestedactionEnum.StartSleep
+    def is_stop_sleep(self, event):
+        return event.requestedaction == eventtypes.LidAaUserModeChange.RequestedactionEnum.StopSleep or \
+               event.requestedaction == eventtypes.LidAaUserModeChange.RequestedactionEnum.StopAll
+    def is_start_exercise(self, event):
+        return event.requestedaction == eventtypes.LidAaUserModeChange.RequestedactionEnum.StartExercise
+    def is_stop_exercise(self, event):
+        return event.requestedaction == eventtypes.LidAaUserModeChange.RequestedactionEnum.StopExercise or \
+               event.requestedaction == eventtypes.LidAaUserModeChange.RequestedactionEnum.StopAll
+
+
+    def sleep_to_nsentry(self, start, stop=None, time_end=None):
+        if start and stop:
+            reason = None
+            if start.sleepstartedbygui == eventtypes.LidAaUserModeChange.SleepstartedbyguiEnum.TrueVal:
+                reason = "Sleep (Manual)"
+            elif start.activesleepschedule:
+                reason = "Sleep (Scheduled)"
+
+            duration_mins = (stop.eventTimestamp - start.eventTimestamp).seconds / 60
+            return NightscoutEntry.activity(
+                created_at=start.eventTimestamp.format(),
+                reason=reason,
+                duration=duration_mins,
+                event_type=SLEEP_EVENTTYPE,
+                pump_event_id = "%s,%s" % (start.eventId, stop.eventId)
+            )
+        elif start:
+            reason = None
+            if start.sleepstartedbygui == eventtypes.LidAaUserModeChange.SleepstartedbyguiEnum.TrueVal:
+                reason = "Sleep (Manual)"
+            elif start.activesleepscheduleRaw:
+                reason = "Sleep (Scheduled)"
+
+            duration_mins = (time_end - start.eventTimestamp).seconds / 60
+            return NightscoutEntry.activity(
+                created_at=start.eventTimestamp.format(),
+                reason=reason + " - " + NOT_ENDED if reason else NOT_ENDED,
+                duration=duration_mins,
+                event_type=SLEEP_EVENTTYPE,
+                pump_event_id = "%s" % start.eventId
+            )
+
+
+    def exercise_to_nsentry(self, start, stop=None, time_end=None):
+        if start and stop:
+            reason = "Exercise"
+            if start.exercisechoice == eventtypes.LidAaUserModeChange.ExercisechoiceEnum.Timed:
+                reason = "Exercise (Timed)"
+
+            if stop.exercisestoppedbytimer == eventtypes.LidAaUserModeChange.ExercisestoppedbytimerEnum.TrueVal:
+                reason += " (Stopped by timer)"
+
+            duration_mins = (stop.eventTimestamp - start.eventTimestamp).seconds / 60
+            return NightscoutEntry.activity(
+                created_at=start.eventTimestamp.format(),
+                reason=reason,
+                duration=duration_mins,
+                event_type=EXERCISE_EVENTTYPE,
+                pump_event_id = "%s,%s" % (start.eventId, stop.eventId)
+            )
+        elif start:
+            reason = "Exercise"
+            if start.exercisechoice == eventtypes.LidAaUserModeChange.ExercisechoiceEnum.Timed:
+                reason = "Exercise (Timed)"
+
+            duration_mins = (time_end.eventTimestamp - start.eventTimestamp).seconds / 60
+            return NightscoutEntry.activity(
+                created_at=start.eventTimestamp.format(),
+                reason=reason + " - " + NOT_ENDED,
+                duration=duration_mins,
+                event_type=EXERCISE_EVENTTYPE,
+                pump_event_id = "%s,%s" % (start.eventId, stop.eventId)
+            )
+
+    def process_unended_sleep_stop(self, event, sleep_last_upload):
+        logger.info("ProcessUserMode: Deleting old sleep event treatment before pushing update (delete treatments/%s)" % sleep_last_upload["_id"])
+        if self.pretend:
+            logger.info("ProcessUserMode: Skipping delete in pretend mode")
+        else:
+            self.nightscout.delete_entry('treatments/%s' % sleep_last_upload["_id"])
+
+        duration_mins = (event.eventTimestamp - arrow.get(sleep_last_upload["created_at"])).seconds / 60
+        return NightscoutEntry.activity(
+            created_at=sleep_last_upload["created_at"],
+            reason=sleep_last_upload["reason"].replace(" - %s" % NOT_ENDED, ""),
+            duration=duration_mins,
+            event_type=SLEEP_EVENTTYPE,
+            pump_event_id="%s,%s" % (sleep_last_upload.get("pump_event_id",""), event.eventId)
+        )
+
+    def process_unended_exercise_stop(self, event, exercise_last_upload):
+        logger.info("ProcessUserMode: Deleting old exercise event treatment before pushing update (delete treatments/%s)" % exercise_last_upload["_id"])
+        if self.pretend:
+            logger.info("ProcessUserMode: Skipping delete in pretend mode")
+        else:
+            self.nightscout.delete_entry('treatments/%s' % exercise_last_upload["_id"])
+
+        reason = exercise_last_upload["reason"].replace(" - %s" % NOT_ENDED, "")
+        if event.exercisestoppedbytimer == eventtypes.LidAaUserModeChange.ExercisestoppedbytimerEnum.TrueVal:
+            reason += " (Stopped by timer)"
+
+        duration_mins = (event.eventTimestamp - arrow.get(exercise_last_upload["created_at"])).seconds / 60
+        return NightscoutEntry.activity(
+            created_at=exercise_last_upload["created_at"],
+            reason=reason,
+            duration=duration_mins,
+            event_type=EXERCISE_EVENTTYPE,
+            pump_event_id="%s,%s" % (exercise_last_upload.get("pump_event_id",""), event.eventId)
+        )
@@ -0,0 +1,210 @@
+import logging
+import arrow
+import copy
+import json
+from typing import Tuple
+
+from ...features import DEFAULT_FEATURES
+from ... import features
+from ...domain.tandemsource.pump_settings import PumpSettings
+from ...parser.nightscout import (
+    NightscoutEntry
+)
+from ...secret import NIGHTSCOUT_PROFILE_UPLOAD_MODE
+
+logger = logging.getLogger(__name__)
+
+def _get_default_upload_mode():
+    return NIGHTSCOUT_PROFILE_UPLOAD_MODE
+
+class UpdateProfiles:
+    def __init__(self, tconnect, nightscout, tconnect_device_id, pretend, features=DEFAULT_FEATURES):
+        self.tconnect = tconnect
+        self.nightscout = nightscout
+        self.tconnect_device_id = tconnect_device_id
+        self.pretend = pretend
+        self.features = features
+
+    def enabled(self):
+        return features.PROFILES in self.features
+
+    def update(self, pretend):
+        upload_mode = _get_default_upload_mode()
+        logger.debug("UpdateProfiles: getting Tandem Source profile data")
+
+        all_metadata = self.tconnect.tandemsource.pump_event_metadata()
+        pump_meta = None
+        for m in all_metadata:
+            if m['tconnectDeviceId'] == self.tconnect_device_id:
+                pump_meta = m
+
+        if not pump_meta:
+            return False
+
+        raw_settings = pump_meta.get("lastUpload", {}).get("settings")
+        if not raw_settings:
+            return False
+
+        pump_settings = PumpSettings.from_dict(raw_settings)
+        logger.info("Current pump settings: %s" % pump_settings)
+
+        ns_profile_obj = self.nightscout.current_profile()
+        logger.info("Current Nightscout profile: %s" % ns_profile_obj)
+        if ns_profile_obj is None:
+            ns_profile_obj = {}
+
+        diff, ns_profile_new = self.compare_profiles(pump_settings, ns_profile_obj)
+        if not diff:
+            logger.info("Pump and Nightscout profiles up to date")
+            return False
+
+        if upload_mode == 'add':
+            profile_to_upload = self.setup_new_profile(ns_profile_new)
+            logger.info("Adding new Nightscout profiles object: %s", profile_to_upload)
+
+            if not pretend:
+                self.nightscout.upload_entry(profile_to_upload, entity='profile')
+            return True
+
+        elif upload_mode == 'replace':
+            logger.info("Replacing new Nightscout profiles object: %s", ns_profile_new)
+
+            if not pretend:
+                self.nightscout.put_entry(ns_profile_new, entity='profile')
+            return True
+
+        else:
+            raise RuntimeError('invalid upload_mode: %s' % upload_mode)
+
+
+    """
+    Compare pump device and Nightscout profiles, and return a final dictionary of
+    Nightscout profile objects, with the pump profile settings overriding what is
+    currently in Nightscout.
+
+    ns_profile_obj is the output from NightscoutApi.current_profile() and should be the most
+    recent profile object in mongo.
+
+    Returns the new Nightscout profile and whether it was changed.
+    """
+    def compare_profiles(self, pump_settings: PumpSettings, ns_profile_obj: dict) -> Tuple[bool, dict]:
+        device = {profile.name: profile for profile in pump_settings.profiles.profile}
+        activeIdp = pump_settings.profiles.activeIdp
+
+        ns = ns_profile_obj.get('store', {})
+
+        logger.info("compare_profiles profile names: device: %s ns: %s", device.keys(), ns.keys())
+
+        new_ns_profile = copy.deepcopy(ns_profile_obj)
+        if not 'store' in new_ns_profile:
+            new_ns_profile['store'] = {}
+        updated_ns_profile = False
+
+        missing_profiles_in_ns = set(device.keys()) - set(ns.keys())
+        for profile_name in missing_profiles_in_ns:
+            logger.info("Missing %s profile in Nightscout: %s", profile_name, device.get(profile_name))
+            pump_configured_profile = device[profile_name]
+            ns_translated_profile = NightscoutEntry.tandemsource_profile_store(pump_configured_profile, pump_settings)
+            logger.info("Will add %s profile to Nightscout: %s", profile_name, ns_translated_profile)
+            new_ns_profile['store'][profile_name] = ns_translated_profile
+            updated_ns_profile = True
+
+        existent_profiles_in_ns = set(device.keys()) & set(ns.keys())
+        for profile_name in existent_profiles_in_ns:
+            logger.debug("Checking for differences for %s profile between pump and nightscout", profile_name)
+            pump_configured_profile = device[profile_name]
+            ns_translated_profile = NightscoutEntry.tandemsource_profile_store(pump_configured_profile, pump_settings)
+            ns_configured_profile = ns[profile_name]
+
+            logger.debug("Comparing %s profile from pump: %s to nightscout: %s", profile_name, ns_translated_profile, ns_configured_profile)
+            if self.nightscout_profiles_identical(ns_configured_profile, ns_translated_profile):
+                logger.info("Profile %s identical between pump and nightscout", profile_name)
+                continue
+
+            logger.info("Profile %s needs update in nightscout: %s", profile_name, ns_translated_profile)
+            new_ns_profile['store'][profile_name] = ns_translated_profile
+            updated_ns_profile = True
+
+        current_pump_profile = None
+        for profile in pump_settings.profiles.profile:
+            if profile.idp == activeIdp:
+                current_pump_profile = profile.name
+
+        if not current_pump_profile:
+            logger.error('No current pump profile, so skipping profile update')
+            return False, ns_profile_obj
+
+        current_ns_profile = ns_profile_obj.get('defaultProfile')
+        if current_pump_profile != current_ns_profile:
+            logger.info("Current profile changed: pump: %s nightscout: %s", current_pump_profile, current_ns_profile)
+            new_ns_profile['defaultProfile'] = current_pump_profile
+            updated_ns_profile = True
+
+        if not updated_ns_profile:
+            logger.info("No Nightscout profile changes")
+            return False, ns_profile_obj
+
+        logger.info("New Nightscout profile object: %s", new_ns_profile)
+        return True, new_ns_profile
+
+    def nightscout_profiles_identical(self, configured: dict, translated: dict) -> bool:
+        if configured == translated:
+            logger.debug("direct dicts equal")
+            return True
+
+        if json.dumps(configured, sort_keys=True, indent=None) == json.dumps(translated, sort_keys=True, indent=None):
+            logger.debug("initial JSON dump identical")
+            return True
+
+        # convert all JSON values into strings
+        def map_nested_dicts_modify(ob, func):
+            for k, v in ob.items():
+                if isinstance(v, dict):
+                    map_nested_dicts_modify(v, func)
+                elif isinstance(v, list):
+                    map_nested_lists_modify(v, func)
+                else:
+                    ob[k] = func(v)
+
+        def map_nested_lists_modify(ob, func):
+            for i in range(len(ob)):
+                v = ob[i]
+                if isinstance(v, dict):
+                    map_nested_dicts_modify(v, func)
+                elif isinstance(v, list):
+                    map_nested_lists_modify(v, func)
+                else:
+                    ob[i] = func(v)
+
+        def to_numeric(x):
+            if type(x) in [int, float]:
+                return '%f' % x
+            try:
+                return '%f' % float(x)
+            except (ValueError, TypeError):
+                return x
+
+
+        convert_func = lambda x: to_numeric(x)
+
+        configured_str = json.loads(json.dumps(configured))
+        map_nested_dicts_modify(configured_str, convert_func)
+        translated_str = json.loads(json.dumps(translated))
+        map_nested_dicts_modify(translated_str, convert_func)
+
+        if json.dumps(configured_str, sort_keys=True, indent=None) == json.dumps(translated_str, sort_keys=True, indent=None):
+            logger.debug("map_nested_dicts JSON dump identical")
+            return True
+
+        logger.debug("profiles not identical")
+        return False
+
+    def setup_new_profile(self, ns_profile: dict) -> dict:
+        if '_id' in ns_profile:
+            del ns_profile['_id']
+
+        now = arrow.now().isoformat()
+        ns_profile['startDate'] = now
+        ns_profile['created_at'] = now
+
+        return ns_profile
@@ -0,0 +1,36 @@
+import arrow
+
+from . import cli
+from . import constants
+
+def timeago(timestamp):
+    seconds = (arrow.get() - arrow.get(timestamp)).total_seconds()
+    fmt = '%s ago' if seconds >= 0 else 'in %s'
+    seconds = abs(seconds)
+
+    ret = ''
+    if seconds//86400 > 0:
+        ret += '%d days, ' % (seconds//86400)
+        seconds = seconds % 86400
+    if seconds//3600 > 0:
+        ret += '%d hours, ' % (seconds//3600)
+        seconds = seconds % 3600
+    ret += '%d minutes' % (seconds//60)
+
+    return fmt % ret
+
+# String methods only available in python 3.9+
+def removesuffix(input_string, suffix):
+    if suffix and input_string.endswith(suffix):
+        return input_string[:-len(suffix)]
+    return input_string
+
+def removeprefix(input_string, prefix):
+    if prefix and input_string.startswith(prefix):
+        return input_string[len(prefix):]
+    return input_string
+
+def cap_length(text, maxlen):
+    if not text or len(text) <= maxlen:
+        return text
+    return '%s[...]%s' % (text[:maxlen//2], text[maxlen//-2:])
@@ -0,0 +1,20 @@
+import logging
+
+"""
+Enables logging at the specified level for all loggers
+inside the tconnectsync package, and sets up a basicConfig
+to print those log messages to stderr.
+"""
+def enable_logging(level=logging.DEBUG):
+    logging.basicConfig()
+    for logger in logging.root.manager.loggerDict:
+        if logger.startswith('tconnectsync'):
+            logging.getLogger(logger).setLevel(level)
+
+"""
+Returns a TConnectApi object with default secret parameters.
+"""
+def get_api():
+    from ..api import TConnectApi
+    from ..secret import TCONNECT_EMAIL, TCONNECT_PASSWORD
+    return TConnectApi(TCONNECT_EMAIL, TCONNECT_PASSWORD)
@@ -0,0 +1,4 @@
+
+# http://www.soc-bdr.org/rds/authors/unit_tables_conversions_and_genetic_dictionaries/conversion_glucose_mg_dl_to_mmol_l/index_en.html
+MMOLL_TO_MGDL = 18.0182
+MGDL_TO_MMOLL = 0.0555
@@ -0,0 +1,10 @@
+# Hack to enable debug-level logging when running tests
+# with `python3 -m unittest discover`
+
+import sys
+if 'unittest' in sys.modules:
+    import logging
+    logging.basicConfig(
+        level=logging.DEBUG,
+        format='%(asctime)s %(levelname)-8s %(message)s',
+        datefmt='%Y-%m-%d %H:%M:%S')
@@ -1,9 +1,11 @@
 import tconnectsync.api
+import requests

 class ControlIQApi(tconnectsync.api.controliq.ControlIQApi):
    def __init__(self):
        self.BASE_URL = 'invalid://'
        self.LOGIN_URL = 'invalid://'
+        self.session = requests.Session() # mocked in tests

    def login(self, email, password):
        raise NotImplementedError
@@ -11,14 +13,15 @@ class ControlIQApi(tconnectsync.api.controliq.ControlIQApi):
    def needs_relogin(self):
        return False

-    def get(self, endpoint, query):
+    def _get(self, endpoint, query):
        raise NotImplementedError

 class WS2Api(tconnectsync.api.ws2.WS2Api):
    def __init__(self):
        self.BASE_URL = 'invalid://'
+        self.SLEEP_SECONDS_INCREMENT = 0.01

-    def get(self, endpoint, query):
+    def get(self, endpoint):
        raise NotImplementedError

    def get_jsonp(self, endpoint):
@@ -34,13 +37,27 @@ class AndroidApi(tconnectsync.api.android.AndroidApi):
    def needs_relogin(self):
        return False

-    def get(self, endpoint, query={}, **kwargs):
+    def _get(self, endpoint, query={}, **kwargs):
+        raise NotImplementedError
+
+class WebUIScraper(tconnectsync.api.webui.WebUIScraper):
+    def __init__(self, controliq):
+        self.controliq = controliq
+
+    def my_devices(self):
+        raise NotImplementedError
+    
+    def device_settings(self, pump_guid):
        raise NotImplementedError

 class TConnectApi(tconnectsync.api.TConnectApi):
-    def __init__(self):
-        pass
+    def __init__(self, email=None, password=None):
+        if email is not None and password is not None:
+            self.with_credentials = True
+        else:
+            self.with_credentials = False

    _ciq = ControlIQApi()
    _ws2 = WS2Api()
    _android = AndroidApi()
+    _webui = WebUIScraper(_ciq)
@@ -0,0 +1,90 @@
+#!/usr/bin/env python3
+
+import unittest
+import itertools
+import datetime
+
+from .fake import AndroidApi
+
+from tconnectsync.api.common import ApiException
+
+class TestAndroidApi(unittest.TestCase):
+    def fake_get_with_http_code(self, http_code, expected_endpoint, num_times):
+        tries = 0
+        def fake_get(endpoint, query):
+            nonlocal http_code, expected_endpoint, num_times, tries
+            if endpoint.endswith(expected_endpoint):
+                if tries < num_times:
+                    tries += 1
+                    raise ApiException(http_code, "fake HTTP %d" % http_code)
+
+                return {"faked_json": True}
+
+            raise NotImplementedError
+
+        return fake_get
+
+    def test_last_event_uploaded_works_after_single_http_500(self):
+        android = AndroidApi()
+
+        android._get = self.fake_get_with_http_code(500, "cloud/upload/getlasteventuploaded?sn=1111111", 1)
+
+        self.assertEqual(
+            android.last_event_uploaded(1111111),
+            {
+                "faked_json": True
+            })
+
+    def test_last_event_uploaded_fails_after_two_http_500s(self):
+        android = AndroidApi()
+
+        android._get = self.fake_get_with_http_code(500, "cloud/upload/getlasteventuploaded?sn=1111111", 2)
+
+        self.assertRaises(ApiException, android.last_event_uploaded, 1111111)
+
+    def test_last_event_uploaded_triggers_relogin_after_single_http_401(self):
+        android = AndroidApi()
+        android._email = 'email'
+        android._password = 'password'
+
+        hit_login = []
+        def stub_login(email, password):
+            nonlocal hit_login
+            hit_login.append((email, password))
+
+        android.login = stub_login
+
+        android._get = self.fake_get_with_http_code(401, "cloud/upload/getlasteventuploaded?sn=1111111", 1)
+
+        self.assertEqual(
+            android.last_event_uploaded(1111111),
+            {
+                "faked_json": True
+            })
+
+        self.assertListEqual(hit_login, [
+            ('email', 'password')
+        ])
+
+    def test_last_event_uploaded_fails_after_two_http_401s(self):
+        android = AndroidApi()
+        android._email = 'email'
+        android._password = 'password'
+
+        hit_login = []
+        def stub_login(email, password):
+            nonlocal hit_login
+            hit_login.append((email, password))
+
+        android.login = stub_login
+
+        android._get = self.fake_get_with_http_code(401, "cloud/upload/getlasteventuploaded?sn=1111111", 2)
+
+        self.assertRaises(ApiException, android.last_event_uploaded, 1111111)
+
+        self.assertListEqual(hit_login, [
+            ('email', 'password')
+        ])
+
+if __name__ == '__main__':
+    unittest.main()
@@ -0,0 +1,44 @@
+import unittest
+
+from unittest.mock import patch
+
+from tconnectsync.api.common import base_session
+
+class TestRequestsProxy(unittest.TestCase):
+    def test_proxy_used_in_base_session(self):
+        with patch("tconnectsync.api.common.secret") as mock_secret, \
+             patch("requests.Session.request") as mock_request:
+
+            s = base_session()
+            s.request('sentinel')
+
+            mock_request.assert_called_once_with('sentinel', proxies={
+                'http': mock_secret.REQUESTS_PROXY,
+                'https': mock_secret.REQUESTS_PROXY
+            })
+
+    def test_proxy_used_in_base_session_with_two_args(self):
+        with patch("tconnectsync.api.common.secret") as mock_secret, \
+             patch("requests.Session.request") as mock_request:
+
+            s = base_session()
+            s.request('GET', 'sentinel')
+
+            mock_request.assert_called_once_with('GET', 'sentinel', proxies={
+                'http': mock_secret.REQUESTS_PROXY,
+                'https': mock_secret.REQUESTS_PROXY
+            })
+
+    def test_proxy_used_in_base_session_with_kwargs(self):
+        with patch("tconnectsync.api.common.secret") as mock_secret, \
+             patch("requests.Session.request") as mock_request:
+
+            s = base_session()
+            s.request('GET', 'sentinel', foo={'bar': 'baz'})
+
+            mock_request.assert_called_once_with('GET', 'sentinel', foo={'bar': 'baz'}, proxies={
+                'http': mock_secret.REQUESTS_PROXY,
+                'https': mock_secret.REQUESTS_PROXY
+            })
+
+            
@@ -0,0 +1,293 @@
+#!/usr/bin/env python3
+
+import unittest
+import itertools
+import datetime
+import json
+import requests_mock
+
+from bs4 import BeautifulSoup
+
+from .fake import ControlIQApi
+
+from tconnectsync.api.controliq import ControlIQApi as RealControlIQApi
+from tconnectsync.api.common import ApiException, ApiLoginException, base_headers
+
+class TestControlIQApi(unittest.TestCase):
+    LOGIN_HTML = """
+<html>
+<body>
+    <form method="post" action="./login.aspx?ReturnUrl=%2f" onsubmit="javascript:return WebForm_OnSubmit();" id="form1">
+        <div class="aspNetHidden">
+            <input type="hidden" name="__LASTFOCUS" id="__LASTFOCUS" value="" />
+            <input type="hidden" name="__EVENTTARGET" id="__EVENTTARGET" value="" />
+            <input type="hidden" name="__EVENTARGUMENT" id="__EVENTARGUMENT" value="" />
+            <input type="hidden" name="__VIEWSTATE" id="__VIEWSTATE" value="AAAAA" />
+        </div>
+        <div class="aspNetHidden">
+            <input type="hidden" name="__VIEWSTATEGENERATOR" id="__VIEWSTATEGENERATOR" value="BBBBB" />
+            <input type="hidden" name="__EVENTVALIDATION" id="__EVENTVALIDATION" value="CCCCC" />
+        </div>
+    </form>
+</body>
+</html>
+    """
+
+    LOGIN_POST_DATA = {
+        "__LASTFOCUS": "",
+        "__EVENTTARGET": "ctl00$ContentBody$LoginControl$linkLogin",
+        "__EVENTARGUMENT": "",
+        "__VIEWSTATE": "AAAAA",
+        "__VIEWSTATEGENERATOR": "BBBBB",
+        "__EVENTVALIDATION": "CCCCC",
+        "ctl00$ContentBody$LoginControl$txtLoginEmailAddress": "email@email.com",
+        "txtLoginEmailAddress_ClientState": '{"enabled":true,"emptyMessage":"","validationText":"%s","valueAsString":"%s","lastSetTextBoxValue":"%s"}' % ("email@email.com", "email@email.com", "email@email.com"),
+        "ctl00$ContentBody$LoginControl$txtLoginPassword": "password",
+        "txtLoginPassword_ClientState": '{"enabled":true,"emptyMessage":"","validationText":"%s","valueAsString":"%s","lastSetTextBoxValue":"%s"}' % ("password", "password", "password")
+    }
+
+    def test_build_login_data(self):
+        ciq = ControlIQApi()
+        soup = BeautifulSoup(self.LOGIN_HTML, features='lxml')
+
+        self.assertDictEqual(
+            ciq._build_login_data('email@email.com', 'password', soup),
+            self.LOGIN_POST_DATA)
+
+    def test_login_successful(self):
+        ciq = ControlIQApi()
+        ciq.LOGIN_URL = RealControlIQApi.LOGIN_URL
+        ciq.login = lambda email, password: RealControlIQApi.login(ciq, email, password)
+
+        with requests_mock.Mocker() as m:
+            m.get('https://tconnect.tandemdiabetes.com/login.aspx?ReturnUrl=%2f',
+                request_headers=base_headers(),
+
+                text=self.LOGIN_HTML)
+
+            def post_callback(request, context):
+                context.status_code = 302
+                context.headers['Location'] = '/newlocation'
+                context.cookies['UserGUID'] = 'user_guid'
+                context.cookies['accessToken'] = 'access_tok'
+                context.cookies['accessTokenExpiresAt'] = '2021-05-04T11:18:08.381Z'
+                return ''
+
+            m.post('https://tconnect.tandemdiabetes.com/login.aspx?ReturnUrl=%2f',
+                request_headers={'Referer': ciq.LOGIN_URL, **base_headers()},
+
+                text=post_callback)
+
+            m.post('https://tconnect.tandemdiabetes.com/newlocation',
+                cookies={'cookie': 'value'},
+                headers=base_headers(),
+
+                status_code=200)
+
+            self.assertTrue(ciq.login('email@email.com', 'password'))
+
+            self.assertEqual(ciq.userGuid, 'user_guid')
+            self.assertEqual(ciq.accessToken, 'access_tok')
+            self.assertEqual(ciq.accessTokenExpiresAt, '2021-05-04T11:18:08.381Z')
+
+
+    def test_login_invalid_credentials(self):
+        ciq = ControlIQApi()
+        ciq.LOGIN_URL = RealControlIQApi.LOGIN_URL
+        ciq.login = lambda email, password: RealControlIQApi.login(ciq, email, password)
+
+        with requests_mock.Mocker() as m:
+            m.get('https://tconnect.tandemdiabetes.com/login.aspx?ReturnUrl=%2f',
+                request_headers=base_headers(),
+
+                text=self.LOGIN_HTML)
+
+            def post_callback(request, context):
+                context.status_code = 200
+                return '<html><body>...</body></html>'
+
+            m.post('https://tconnect.tandemdiabetes.com/login.aspx?ReturnUrl=%2f',
+                request_headers={'Referer': ciq.LOGIN_URL, **base_headers()},
+
+                text=post_callback)
+
+            self.assertRaisesRegex(ApiLoginException, 'Error logging in to t:connect: Check your login credentials.', ciq.login, 'email@email.com', 'password')
+
+            self.assertIsNone(ciq.userGuid)
+            self.assertIsNone(ciq.accessToken)
+            self.assertIsNone(ciq.accessTokenExpiresAt)
+
+    def test_login_invalid_credentials_parsed_message(self):
+        ciq = ControlIQApi()
+        ciq.LOGIN_URL = RealControlIQApi.LOGIN_URL
+        ciq.login = lambda email, password: RealControlIQApi.login(ciq, email, password)
+
+        with requests_mock.Mocker() as m:
+            m.get('https://tconnect.tandemdiabetes.com/login.aspx?ReturnUrl=%2f',
+                request_headers=base_headers(),
+
+                text=self.LOGIN_HTML)
+
+            def post_callback(request, context):
+                context.status_code = 200
+                return '<html><body><div class="notice_error" id="literalMessage" style="">The email address or password you entered is invalid. Please re-enter and try again.</div></body></html>'
+
+            m.post('https://tconnect.tandemdiabetes.com/login.aspx?ReturnUrl=%2f',
+                request_headers={'Referer': ciq.LOGIN_URL, **base_headers()},
+
+                text=post_callback)
+
+            self.assertRaisesRegex(ApiLoginException, 'Error logging in to t:connect: The email address or password you entered is invalid. Please re-enter and try again.', ciq.login, 'email@email.com', 'password')
+
+            self.assertIsNone(ciq.userGuid)
+            self.assertIsNone(ciq.accessToken)
+            self.assertIsNone(ciq.accessTokenExpiresAt)
+
+    def test_login_unexpected_http_code(self):
+        ciq = ControlIQApi()
+        ciq.LOGIN_URL = RealControlIQApi.LOGIN_URL
+        ciq.login = lambda email, password: RealControlIQApi.login(ciq, email, password)
+
+        with requests_mock.Mocker() as m:
+            m.get('https://tconnect.tandemdiabetes.com/login.aspx?ReturnUrl=%2f',
+                request_headers=base_headers(),
+
+                text=self.LOGIN_HTML)
+
+            def post_callback(request, context):
+                context.status_code = 500
+                return '<html><body>...</body></html>'
+
+            m.post('https://tconnect.tandemdiabetes.com/login.aspx?ReturnUrl=%2f',
+                request_headers={'Referer': ciq.LOGIN_URL, **base_headers()},
+
+                text=post_callback)
+
+            self.assertRaisesRegex(ApiLoginException, 'Error logging in to t:connect \(HTTP 500\)', ciq.login, 'email@email.com', 'password')
+
+            self.assertIsNone(ciq.userGuid)
+            self.assertIsNone(ciq.accessToken)
+            self.assertIsNone(ciq.accessTokenExpiresAt)
+
+
+    def fake_get_with_http_code(self, http_code, expected_endpoint, num_times):
+        tries = 0
+        def fake_get(endpoint, query):
+            nonlocal http_code, expected_endpoint, num_times, tries
+            if endpoint.split("?")[0].endswith(expected_endpoint):
+                if tries < num_times:
+                    tries += 1
+                    raise ApiException(http_code, "fake HTTP %d" % http_code)
+
+                return {"faked_json": True}
+
+            raise NotImplementedError
+
+        return fake_get
+
+    def test_therapy_timeline_works_after_single_http_500(self):
+        ciq = ControlIQApi()
+        ciq.userGuid = 'aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee'
+
+        ciq._get = self.fake_get_with_http_code(500, "therapytimeline/users/aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee", 1)
+
+        self.assertEqual(
+            ciq.therapy_timeline('2021-04-01', '2021-04-02'),
+            {
+                "faked_json": True
+            })
+
+    def test_therapy_timeline_fails_after_two_http_500s(self):
+        ciq = ControlIQApi()
+        ciq.userGuid = 'aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee'
+
+        ciq._get = self.fake_get_with_http_code(500, "therapytimeline/users/aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee", 2)
+
+        self.assertRaises(ApiException, ciq.therapy_timeline, '2021-04-01', '2021-04-02')
+
+    def test_therapy_timeline_triggers_relogin_after_single_http_401(self):
+        ciq = ControlIQApi()
+        ciq.userGuid = 'aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee'
+        ciq._email = 'email'
+        ciq._password = 'password'
+
+        hit_login = []
+        def stub_login(email, password):
+            nonlocal hit_login
+            hit_login.append((email, password))
+
+        ciq.login = stub_login
+
+        ciq._get = self.fake_get_with_http_code(401, "therapytimeline/users/aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee", 1)
+
+        self.assertEqual(
+            ciq.therapy_timeline('2021-04-01', '2021-04-02'),
+            {
+                "faked_json": True
+            })
+
+        self.assertListEqual(hit_login, [
+            ('email', 'password')
+        ])
+
+    def test_therapy_timeline_fails_after_two_http_401s(self):
+        ciq = ControlIQApi()
+        ciq.userGuid = 'aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee'
+        ciq._email = 'email'
+        ciq._password = 'password'
+
+        hit_login = []
+        def stub_login(email, password):
+            nonlocal hit_login
+            hit_login.append((email, password))
+
+        ciq.login = stub_login
+
+        ciq._get = self.fake_get_with_http_code(401, "therapytimeline/users/aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee", 2)
+
+        self.assertRaises(ApiException, ciq.therapy_timeline, '2021-04-01', '2021-04-02')
+
+        self.assertListEqual(hit_login, [
+            ('email', 'password')
+        ])
+
+    def test_therapy_timeline_parses_date(self):
+        ciq = ControlIQApi()
+        ciq.userGuid = 'aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee'
+
+        def fake_get(raw_endpoint, ignored_query):
+            endpoint, query = raw_endpoint.split("?")
+            self.assertTrue(endpoint.endswith("therapytimeline/users/aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee"))
+            self.assertEqual(query, "startDate=04-01-2021&endDate=04-02-2021")
+
+            return {"faked_json": True}
+
+        ciq._get = fake_get
+
+        self.assertEqual(
+            ciq.therapy_timeline(datetime.date(2021, 4, 1), datetime.date(2021, 4, 2)),
+            {
+                "faked_json": True
+            })
+
+    def test_dashboard_summary_parses_date(self):
+        ciq = ControlIQApi()
+        ciq.userGuid = 'aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee'
+
+        def fake_get(raw_endpoint, ignored_query):
+            endpoint, query = raw_endpoint.split("?")
+            self.assertTrue(endpoint.endswith("summary/users/aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee"))
+            self.assertEqual(query, "startDate=04-01-2021&endDate=04-02-2021")
+
+            return {"faked_json": True}
+
+        ciq._get = fake_get
+
+        self.assertEqual(
+            ciq.dashboard_summary(datetime.date(2021, 4, 1), datetime.date(2021, 4, 2)),
+            {
+                "faked_json": True
+            })
+
+if __name__ == '__main__':
+    unittest.main()
@@ -0,0 +1,179 @@
+#!/usr/bin/env python3
+
+import unittest
+import itertools
+import copy
+
+from .fake import WS2Api
+
+from tconnectsync.api.common import ApiException
+
+class TestWS2Api(unittest.TestCase):
+    def fake_get_with_http_500(self, num_times):
+        tries = 0
+        def fake_get(endpoint, **kwargs):
+            nonlocal tries, num_times
+            if "therapytimeline2csv" in endpoint:
+                if tries < num_times:
+                    tries += 1
+                    raise ApiException(500, "fake HTTP 500")
+
+                return ""
+            raise NotImplementedError
+
+        return fake_get
+
+    def test_therapy_timeline_csv_works_after_two_retries(self):
+        ws2 = WS2Api()
+
+        ws2.get = self.fake_get_with_http_500(2)
+
+        self.assertEqual(
+            ws2.therapy_timeline_csv('04-01-2021', '04-02-2021'),
+            {
+                "readingData": [],
+                "iobData": [],
+                "basalData": [],
+                "bolusData": []
+            })
+
+    def test_therapy_timeline_csv_fails_after_three_retries(self):
+        ws2 = WS2Api()
+
+        ws2.get = self.fake_get_with_http_500(3)
+
+        self.assertRaises(ApiException, ws2.therapy_timeline_csv, '04-01-2021', '04-02-2021')
+
+    RAW_DATA_HEADER = """Tandem Diabetes Care Inc.
+t:connect Therapy Timeline Data Export
+Patient Name, Sample Name
+Patient DOB, 1/1/1990
+Report Generated On, 4/24/2021 7:50:04 PM
+"""
+    RAW_DATA_CGM = """DeviceType,SerialNumber,Description,EventDateTime,Readings (CGM / BGM)
+"t:slim X2 Insulin Pump","11111111","EGV","2021-04-01T00:01:33","235",
+"t:slim X2 Insulin Pump","11111111","EGV","2021-04-01T00:06:33","230",
+"t:slim X2 Insulin Pump","11111111","EGV","2021-04-02T23:31:36","181",
+"""
+    RAW_DATA_IOB = """Type,EventID,EventDateTime,IOB
+"IOB","81","2021-04-01T00:00:19","13.24"
+"IOB","9","2021-04-01T00:03:12","12.80"
+"IOB","81","2021-04-02T23:58:19","4.25"
+"""
+    RAW_DATA_BOLUS = """Type,Description,BG,IOB,BolusRequestID,BolusCompletionID,CompletionDateTime,InsulinDelivered,FoodDelivered,CorrectionDelivered,CompletionStatusID,CompletionStatusDesc,BolusIsComplete,BolexCompletionID,BolexSize,BolexStartDateTime,BolexCompletionDateTime,BolexInsulinDelivered,BolexIOB,BolexCompletionStatusID,BolexCompletionStatusDesc,ExtendedBolusIsComplete,EventDateTime,RequestDateTime,BolusType,BolusRequestOptions,StandardPercent,Duration,CarbSize,UserOverride,TargetBG,CorrectionFactor,FoodBolusSize,CorrectionBolusSize,ActualTotalBolusRequested,IsQuickBolus,EventHistoryReportEventDesc,EventHistoryReportDetails,NoteID,IndexID,Note
+"Bolus","Standard/Correction","141",,"7001.000","7001.000","2021-04-01T12:58:26","13.53","12.50","1.03","3","Completed","1",,,,,,,,,,"2021-04-01T12:53:36","2021-04-01T12:53:36","Carb","Standard/Correction","100.00","0","75","0","110","30.00","12.50","1.03","13.53","0","0","Correction & Food Bolus","CF 1:30 - Carb Ratio 1:6 - Target BG 110","0","1181649","",
+"Bolus","Standard","131","0.71","7003.000","7003.000","2021-04-01T16:03:25","1.50","0.00","0.00","3","Completed","1",,,,,,,,,,"2021-04-01T16:02:04","2021-04-01T16:02:04","Carb","Standard","100.00","0","0","1","110","30.00","0.00","0.00","1.50","0","0","Food Bolus","CF 1:30 - Carb Ratio 1:6 - Target BG 110 | Override: Pump calculated Bolus = 0.0 units","0","1182026","",
+"Bolus","Standard/Correction","168","1.71","7004.000","7004.000","2021-04-01T16:24:08","2.00","0.00","0.00","3","Completed","1",,,,,,,,,,"2021-04-01T16:22:21","2021-04-01T16:22:21","Carb","Standard/Correction","100.00","0","0","1","110","30.00","0.00","0.22","2.00","0","0","Correction & Food Bolus","CF 1:30 - Carb Ratio 1:6 - Target BG 110 | Override: Pump calculated Bolus = 0.2 units","0","1182082","",
+"Bolus","Standard","220","3.98","7032.000","7032.000","2021-04-02T23:16:24","2.50","0.00","0.00","3","Completed","1",,,,,,,,,,"2021-04-02T23:14:33","2021-04-02T23:14:33","Carb","Standard","100.00","0","0","1","110","30.00","0.00","0.00","2.50","0","0","Food Bolus","CF 1:30 - Carb Ratio 1:6 - Target BG 110 | Override: Pump calculated Bolus = 0.0 units","0","1185846","",
+"""
+
+    RAW_DATA_FULL = RAW_DATA_HEADER + "\n" + RAW_DATA_CGM + "\n" + RAW_DATA_IOB + "\n" + RAW_DATA_BOLUS
+
+    PARSED_DATA = {
+        'readingData': [
+            {"DeviceType": "t:slim X2 Insulin Pump", "SerialNumber": "11111111", "Description": "EGV", "EventDateTime": "2021-04-01T00:01:33", "Readings (CGM / BGM)": "235"},
+            {"DeviceType": "t:slim X2 Insulin Pump", "SerialNumber": "11111111", "Description": "EGV", "EventDateTime": "2021-04-01T00:06:33", "Readings (CGM / BGM)": "230"},
+            {"DeviceType": "t:slim X2 Insulin Pump", "SerialNumber": "11111111", "Description": "EGV", "EventDateTime": "2021-04-02T23:31:36", "Readings (CGM / BGM)": "181"}
+        ],
+        'iobData': [
+            {"Type": "IOB", "EventID": "81", "EventDateTime": "2021-04-01T00:00:19", "IOB": "13.24"},
+            {"Type": "IOB", "EventID": "9", "EventDateTime": "2021-04-01T00:03:12", "IOB": "12.80"},
+            {"Type": "IOB", "EventID": "81", "EventDateTime": "2021-04-02T23:58:19", "IOB": "4.25"},
+        ],
+        'basalData': [],
+        'bolusData': [
+            {"Type": "Bolus", "Description": "Standard/Correction", "BG": "141", "IOB": "", "BolusRequestID": "7001.000", "BolusCompletionID": "7001.000", "CompletionDateTime": "2021-04-01T12:58:26", "InsulinDelivered": "13.53", "FoodDelivered": "12.50", "CorrectionDelivered": "1.03", "CompletionStatusID": "3", "CompletionStatusDesc": "Completed", "BolusIsComplete": "1", "BolexCompletionID": "", "BolexSize": "", "BolexStartDateTime": "", "BolexCompletionDateTime": "", "BolexInsulinDelivered": "", "BolexIOB": "", "BolexCompletionStatusID": "", "BolexCompletionStatusDesc": "", "ExtendedBolusIsComplete": "", "EventDateTime": "2021-04-01T12:53:36", "RequestDateTime": "2021-04-01T12:53:36", "BolusType": "Carb", "BolusRequestOptions": "Standard/Correction", "StandardPercent": "100.00", "Duration": "0", "CarbSize": "75", "UserOverride": "0", "TargetBG": "110", "CorrectionFactor": "30.00", "FoodBolusSize": "12.50", "CorrectionBolusSize": "1.03", "ActualTotalBolusRequested": "13.53", "IsQuickBolus": "0", "EventHistoryReportEventDesc": "0", "EventHistoryReportDetails": "Correction & Food Bolus", "NoteID": "CF 1:30 - Carb Ratio 1:6 - Target BG 110", "IndexID": "0", "Note": "1181649"},
+            {"Type": "Bolus", "Description": "Standard", "BG": "131", "IOB": "0.71", "BolusRequestID": "7003.000", "BolusCompletionID": "7003.000", "CompletionDateTime": "2021-04-01T16:03:25", "InsulinDelivered": "1.50", "FoodDelivered": "0.00", "CorrectionDelivered": "0.00", "CompletionStatusID": "3", "CompletionStatusDesc": "Completed", "BolusIsComplete": "1", "BolexCompletionID": "", "BolexSize": "", "BolexStartDateTime": "", "BolexCompletionDateTime": "", "BolexInsulinDelivered": "", "BolexIOB": "", "BolexCompletionStatusID": "", "BolexCompletionStatusDesc": "", "ExtendedBolusIsComplete": "", "EventDateTime": "2021-04-01T16:02:04", "RequestDateTime": "2021-04-01T16:02:04", "BolusType": "Carb", "BolusRequestOptions": "Standard", "StandardPercent": "100.00", "Duration": "0", "CarbSize": "0", "UserOverride": "1", "TargetBG": "110", "CorrectionFactor": "30.00", "FoodBolusSize": "0.00", "CorrectionBolusSize": "0.00", "ActualTotalBolusRequested": "1.50", "IsQuickBolus": "0", "EventHistoryReportEventDesc": "0", "EventHistoryReportDetails": "Food Bolus", "NoteID": "CF 1:30 - Carb Ratio 1:6 - Target BG 110 | Override: Pump calculated Bolus = 0.0 units", "IndexID": "0", "Note": "1182026"},
+            {"Type": "Bolus", "Description": "Standard/Correction", "BG": "168", "IOB": "1.71", "BolusRequestID": "7004.000", "BolusCompletionID": "7004.000", "CompletionDateTime": "2021-04-01T16:24:08", "InsulinDelivered": "2.00", "FoodDelivered": "0.00", "CorrectionDelivered": "0.00", "CompletionStatusID": "3", "CompletionStatusDesc": "Completed", "BolusIsComplete": "1", "BolexCompletionID": "", "BolexSize": "", "BolexStartDateTime": "", "BolexCompletionDateTime": "", "BolexInsulinDelivered": "", "BolexIOB": "", "BolexCompletionStatusID": "", "BolexCompletionStatusDesc": "", "ExtendedBolusIsComplete": "", "EventDateTime": "2021-04-01T16:22:21", "RequestDateTime": "2021-04-01T16:22:21", "BolusType": "Carb", "BolusRequestOptions": "Standard/Correction", "StandardPercent": "100.00", "Duration": "0", "CarbSize": "0", "UserOverride": "1", "TargetBG": "110", "CorrectionFactor": "30.00", "FoodBolusSize": "0.00", "CorrectionBolusSize": "0.22", "ActualTotalBolusRequested": "2.00", "IsQuickBolus": "0", "EventHistoryReportEventDesc": "0", "EventHistoryReportDetails": "Correction & Food Bolus", "NoteID": "CF 1:30 - Carb Ratio 1:6 - Target BG 110 | Override: Pump calculated Bolus = 0.2 units", "IndexID": "0", "Note": "1182082"},
+            {"Type": "Bolus", "Description": "Standard", "BG": "220", "IOB": "3.98", "BolusRequestID": "7032.000", "BolusCompletionID": "7032.000", "CompletionDateTime": "2021-04-02T23:16:24", "InsulinDelivered": "2.50", "FoodDelivered": "0.00", "CorrectionDelivered": "0.00", "CompletionStatusID": "3", "CompletionStatusDesc": "Completed", "BolusIsComplete": "1", "BolexCompletionID": "", "BolexSize": "", "BolexStartDateTime": "", "BolexCompletionDateTime": "", "BolexInsulinDelivered": "", "BolexIOB": "", "BolexCompletionStatusID": "", "BolexCompletionStatusDesc": "", "ExtendedBolusIsComplete": "", "EventDateTime": "2021-04-02T23:14:33", "RequestDateTime": "2021-04-02T23:14:33", "BolusType": "Carb", "BolusRequestOptions": "Standard", "StandardPercent": "100.00", "Duration": "0", "CarbSize": "0", "UserOverride": "1", "TargetBG": "110", "CorrectionFactor": "30.00", "FoodBolusSize": "0.00", "CorrectionBolusSize": "0.00", "ActualTotalBolusRequested": "2.50", "IsQuickBolus": "0", "EventHistoryReportEventDesc": "0", "EventHistoryReportDetails": "Food Bolus", "NoteID": "CF 1:30 - Carb Ratio 1:6 - Target BG 110 | Override: Pump calculated Bolus = 0.0 units", "IndexID": "0", "Note": "1185846"}
+        ]
+    }
+
+    def test_therapy_timeline_csv_parses_full(self):
+        ws2 = WS2Api()
+        ws2.userGuid = 'aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee'
+
+        rawData = self.RAW_DATA_FULL
+
+        def fake_get(endpoint, **kwargs):
+            nonlocal rawData
+            if endpoint == 'therapytimeline2csv/aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee/04-01-2021/04-02-2021?format=csv':
+                return rawData
+
+        ws2.get = fake_get
+
+        tt = ws2.therapy_timeline_csv('04-01-2021', '04-02-2021')
+
+        self.assertDictEqual(tt, self.PARSED_DATA)
+
+    def test_therapy_timeline_csv_parses_random_order(self):
+        ws2 = WS2Api()
+        ws2.userGuid = 'aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee'
+
+        rawData = ""
+
+        def fake_get(endpoint, **kwargs):
+            nonlocal rawData
+            if endpoint == 'therapytimeline2csv/aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee/04-01-2021/04-02-2021?format=csv':
+                return rawData
+
+        ws2.get = fake_get
+
+        # Randomize the order of all sections
+        for i in itertools.permutations([self.RAW_DATA_HEADER, self.RAW_DATA_CGM, self.RAW_DATA_IOB, self.RAW_DATA_BOLUS], 4):
+            rawData = "\n".join(i)
+
+            tt = ws2.therapy_timeline_csv('04-01-2021', '04-02-2021')
+            self.assertDictEqual(tt, self.PARSED_DATA)
+    
+    def test_therapy_timeline_csv_split_past_max_days(self):
+        ws2 = WS2Api()
+        ws2.userGuid = 'aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee'
+
+
+        def replace_str(raw, one, two):
+            return raw.replace('04-01-2021', one).replace('04-02-2021', two)
+        rawData1 = self.RAW_DATA_FULL
+        rawData2 = replace_str(self.RAW_DATA_FULL, '04-03-2021', '04-04-2021')
+        rawData3 = replace_str(self.RAW_DATA_FULL, '04-05-2021', '04-06-2021')
+        rawData4 = replace_str(self.RAW_DATA_FULL, '04-07-2021', '04-07-2021')
+
+        def replace_parsed(one, two):
+            parsedData = copy.deepcopy(self.PARSED_DATA)
+            for typ in parsedData.keys():
+                for i in range(len(parsedData[typ])):
+                    for f in parsedData[typ][i].keys():
+                        if 'datetime' in f.lower():
+                            parsedData[typ][i][f] = replace_str(parsedData[typ][i][f], one, two)
+            return parsedData
+
+        parsedData1 = self.PARSED_DATA
+        parsedData2 = replace_parsed('04-03-2021', '04-04-2021')
+        parsedData3 = replace_parsed('04-05-2021', '04-06-2021')
+        parsedData4 = replace_parsed('04-07-2021', '04-07-2021')
+
+        fullParsedData = parsedData1
+        for d in [parsedData2, parsedData3, parsedData4]:
+            for typ in d.keys():
+                fullParsedData[typ] += d[typ]
+
+        def fake_get(endpoint, **kwargs):
+            nonlocal rawData1, rawData2, rawData3, rawData4
+            print('fake_get call %s' % endpoint)
+            if endpoint == 'therapytimeline2csv/aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee/04-01-2021/04-02-2021?format=csv':
+                return rawData1
+            elif endpoint == 'therapytimeline2csv/aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee/04-03-2021/04-04-2021?format=csv':
+                return rawData2
+            elif endpoint == 'therapytimeline2csv/aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee/04-05-2021/04-06-2021?format=csv':
+                return rawData3
+            elif endpoint == 'therapytimeline2csv/aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee/04-07-2021/04-07-2021?format=csv':
+                return rawData4
+
+        ws2.get = fake_get
+
+        tt = ws2.therapy_timeline_csv('04-01-2021', '04-07-2021')
+
+        self.assertDictEqual(tt, fullParsedData)
+
+if __name__ == '__main__':
+    unittest.main()
@@ -0,0 +1,367 @@
+import dataclasses
+import unittest
+from tconnectsync.domain.bolus import Bolus
+
+from tconnectsync.domain.therapy_event import BolusTherapyEvent, CGMTherapyEvent
+
+class TestCGMTherapyEvent(unittest.TestCase):
+    maxDiff = None
+    sampleJson = {
+        "eventDateTime": "2022-07-21T00:00:08",
+        "eventID": 256,
+        "requestDateTime": "0001-01-01T00:00:00",
+        "type": "CGM",
+        "description": "EGV",
+        "sourceRecId": 0,
+        "eventTypeId": 0,
+        "deviceType": "t:slim X2 Insulin Pump",
+        "serialNumber": "xxx",
+        "indexId": 0,
+        "uploadId": 0,
+        "interactive": 0,
+        "tempRateId": 0,
+        "tempRateCompleted": 0,
+        "tempRateActivated": 0,
+        "egv": {
+            "estimatedGlucoseValue": 174,
+            "hypo": 0,
+            "belowTarget": 0,
+            "withinTarget": 1,
+            "aboveTarget": 0,
+            "hyper": 0
+        }
+    }
+
+    def test_parse_cgm(self):
+        e = CGMTherapyEvent.parse(self.sampleJson)
+        self.assertEqual(e.type, "CGM")
+        self.assertEqual(e.eventDateTime, "2022-07-21T00:00:08")
+        self.assertEqual(e.sourceRecId, 0)
+        self.assertEqual(e.eventID, 256)
+        self.assertEqual(e.egv, 174)
+
+class TestBolusTherapyEvent(unittest.TestCase):
+    maxDiff = None
+    standardJson = {
+        "actualTotalBolusRequested": 4.17,
+        "bolusRequestOptions": "Standard",
+        "bolusType": "Carb",
+        "carbSize": 25,
+        "correctionBolusSize": 0,
+        "correctionFactor": 30,
+        "declinedCorrection": 0,
+        "duration": 0,
+        "eventDateTime": "2022-07-21T12:27:36",
+        "eventHistoryReportDetails": "CF 1:30 - Carb Ratio 1:6 - Target BG 110",
+        "eventHistoryReportEventDesc": "Food Bolus",
+        "foodBolusSize": 4.17,
+        "iob": 2.62,
+        "isQuickBolus": 0,
+        "note": {
+            "id": 0,
+            "indexId": "573042",
+            "eventTypeId": 64,
+            "sourceRecordId": 0,
+            "eventId": 0,
+            "active": False
+        },
+        "requestDateTime": "2022-07-21T12:27:36",
+        "standard": {
+            "insulinDelivered": {
+                "completionDateTime": "2022-07-21T12:29:21",
+                "value": 4.17
+            },
+            "foodDelivered": 4.17,
+            "correctionDelivered": 0,
+            "insulinRequested": 4.17,
+            "completionStatusId": 3,
+            "completionStatusDesc": "Completed",
+            "bolusIsComplete": 1,
+            "bolusRequestId": 3362,
+            "bolusCompletionId": 3362
+        },
+        "standardPercent": 100,
+        "targetBG": 110,
+        "userOverride": 0,
+        "type": "Bolus",
+        "description": "Standard",
+        "sourceRecId": 1171853319,
+        "eventTypeId": 0,
+        "indexId": 0,
+        "uploadId": 0,
+        "interactive": 0,
+        "tempRateId": 0,
+        "tempRateCompleted": 0,
+        "tempRateActivated": 0
+    }
+
+    def test_standard_to_bolus(self):
+        e = BolusTherapyEvent.parse(self.standardJson)
+        self.assertIsNotNone(e)
+        b = e.to_bolus()
+        self.assertEqual(dataclasses.asdict(b), dataclasses.asdict(Bolus(
+            description="Standard",
+            complete="1",
+            completion="Completed",
+            request_time="2022-07-21 12:27:36-04:00",
+            completion_time="2022-07-21 12:29:21-04:00",
+            insulin="4.17",
+            requested_insulin="4.17",
+            carbs="25",
+            bg="",
+            user_override="0",
+            extended_bolus="0",
+            bolex_completion_time="",
+            bolex_start_time=""
+        )))
+
+    correctionJson = {
+        "actualTotalBolusRequested": 2.9,
+        "bg": 254,
+        "bolusRequestOptions": "Automatic Bolus/Correction",
+        "bolusType": "Automatic Correction",
+        "carbSize": 0,
+        "correctionBolusSize": 2.9,
+        "correctionFactor": 30,
+        "declinedCorrection": 0,
+        "duration": 0,
+        "eventDateTime": "2022-07-21T11:53:08",
+        "eventHistoryReportDetails": "CF 1:30 - Carb Ratio 1:0 - Target BG 110",
+        "eventHistoryReportEventDesc": "Correction Bolus",
+        "foodBolusSize": 0,
+        "isQuickBolus": 0,
+        "note": {
+            "id": 0,
+            "indexId": "572946",
+            "eventTypeId": 64,
+            "sourceRecordId": 0,
+            "eventId": 0,
+            "active": False
+        },
+        "requestDateTime": "2022-07-21T11:53:08",
+        "standard": {
+            "insulinDelivered": {
+                "completionDateTime": "2022-07-21T11:55:24",
+                "value": 2.9
+            },
+            "foodDelivered": 0,
+            "correctionDelivered": 2.9,
+            "insulinRequested": 2.9,
+            "completionStatusId": 3,
+            "completionStatusDesc": "Completed",
+            "bolusIsComplete": 1,
+            "bolusRequestId": 3361,
+            "bolusCompletionId": 3361
+        },
+        "standardPercent": 100,
+        "targetBG": 110,
+        "userOverride": 0,
+        "type": "Bolus",
+        "description": "Automatic Bolus/Correction",
+        "sourceRecId": 1171791787,
+        "eventTypeId": 0,
+        "indexId": 0,
+        "uploadId": 0,
+        "interactive": 0,
+        "tempRateId": 0,
+        "tempRateCompleted": 0,
+        "tempRateActivated": 0
+    }
+
+    def test_correction_to_bolus(self):
+        e = BolusTherapyEvent.parse(self.correctionJson)
+        self.assertIsNotNone(e)
+        b = e.to_bolus()
+        self.assertEqual(dataclasses.asdict(b), dataclasses.asdict(Bolus(
+            description="Automatic Bolus/Correction",
+            complete="1",
+            completion="Completed",
+            request_time="2022-07-21 11:53:08-04:00",
+            completion_time="2022-07-21 11:55:24-04:00",
+            insulin="2.9",
+            requested_insulin="2.9",
+            carbs="0",
+            bg="254",
+            user_override="0",
+            extended_bolus="0",
+            bolex_completion_time="",
+            bolex_start_time=""
+        )))
+    
+    extendedBolusIncompleteJson = {
+        "actualTotalBolusRequested": 0.4,
+        "bg": 131,
+        "bolex": {
+            "size": 0.2,
+            "bolexStartDateTime": "2022-08-09T23:20:04",
+            "iob": 0,
+            "completionStatusId": 0,
+            "extendedBolusIsComplete": 0,
+            "insulinRequested": 0,
+            "bolexCompletionId": 0
+        },
+        "bolusRequestOptions": "Extended",
+        "bolusType": "Carb",
+        "carbSize": 0,
+        "correctionBolusSize": 0.0,
+        "correctionFactor": 30.0,
+        "declinedCorrection": 0,
+        "duration": 15,
+        "eventDateTime": "2022-08-09T23:19:15",
+        "eventHistoryReportDetails": "CF 1:30 - Carb Ratio 1:6 - Target BG 110<br/>Override: Pump calculated Bolus = 0.0 units",
+        "eventHistoryReportEventDesc": "Food Bolus: 50&#37; Extended 15 mins",
+        "foodBolusSize": 0.0,
+        "iob": 5.87,
+        "isQuickBolus": 0,
+        "note": {
+            "id": 0,
+            "indexId": "631597",
+            "eventTypeId": 64,
+            "sourceRecordId": 0,
+            "eventId": 0,
+            "active": False
+        },
+        "requestDateTime": "2022-08-09T23:19:15",
+        "standard": {
+            "insulinDelivered": {
+                "completionDateTime": "2022-08-09T23:20:04",
+                "value": 0.2
+            },
+            "foodDelivered": 0.0,
+            "correctionDelivered": 0.0,
+            "insulinRequested": 0.2,
+            "completionStatusId": 3,
+            "completionStatusDesc": "Completed",
+            "bolusIsComplete": 1,
+            "bolusRequestId": 3636.0,
+            "bolusCompletionId": 3636.0
+        },
+        "standardPercent": 50.0,
+        "targetBG": 110,
+        "userOverride": 1,
+        "type": "Bolus",
+        "description": "Extended 50.00%/0.00",
+        "sourceRecId": 1209631944,
+        "eventTypeId": 0,
+        "indexId": 0,
+        "uploadId": 0,
+        "interactive": 0,
+        "tempRateId": 0,
+        "tempRateCompleted": 0,
+        "tempRateActivated": 0
+    }
+
+    def test_extended_bolus_incomplete_to_bolus(self):
+        e = BolusTherapyEvent.parse(self.extendedBolusIncompleteJson)
+        self.assertIsNotNone(e)
+        b = e.to_bolus()
+        self.assertEqual(dataclasses.asdict(b), dataclasses.asdict(Bolus(
+            description="Extended 50.00%/0.00",
+            complete="0",
+            completion="",
+            request_time="2022-08-09 23:19:15-04:00",
+            completion_time="2022-08-09 23:20:04-04:00",
+            insulin="0.2",
+            requested_insulin="0.2",
+            carbs="0",
+            bg="131",
+            user_override="1",
+            extended_bolus="1",
+            bolex_completion_time="",
+            bolex_start_time="2022-08-09 23:20:04-04:00"
+        )))
+    
+    extendedBolusJson = {
+        "actualTotalBolusRequested": 0.4,
+        "bg": 131,
+        "bolex": {
+            "size": 0.2,
+            "bolexStartDateTime": "2022-08-09T23:20:04",
+            "insulinDelivered": {
+                "completionDateTime": "2022-08-09T23:35:03",
+                "value": 0.2
+            },
+            "iob": 5.7,
+            "completionStatusId": 3.0,
+            "completionStatusDesc": "Completed",
+            "extendedBolusIsComplete": 1,
+            "insulinRequested": 0.2,
+            "bolexCompletionId": 16757133
+        },
+        "bolusRequestOptions": "Extended",
+        "bolusType": "Carb",
+        "carbSize": 0,
+        "correctionBolusSize": 0.0,
+        "correctionFactor": 30.0,
+        "declinedCorrection": 0,
+        "duration": 15,
+        "eventDateTime": "2022-08-09T23:19:15",
+        "eventHistoryReportDetails": "CF 1:30 - Carb Ratio 1:6 - Target BG 110<br/>Override: Pump calculated Bolus = 0.0 units",
+        "eventHistoryReportEventDesc": "Food Bolus: 50&#37; Extended 15 mins",
+        "foodBolusSize": 0.0,
+        "iob": 5.87,
+        "isQuickBolus": 0,
+        "note": {
+            "id": 0,
+            "indexId": "631597",
+            "eventTypeId": 64,
+            "sourceRecordId": 0,
+            "eventId": 0,
+            "active": False
+        },
+        "requestDateTime": "2022-08-09T23:19:15",
+        "standard": {
+            "insulinDelivered": {
+                "completionDateTime": "2022-08-09T23:20:04",
+                "value": 0.2
+            },
+            "foodDelivered": 0.0,
+            "correctionDelivered": 0.0,
+            "insulinRequested": 0.2,
+            "completionStatusId": 3,
+            "completionStatusDesc": "Completed",
+            "bolusIsComplete": 1,
+            "bolusRequestId": 3636.0,
+            "bolusCompletionId": 3636.0
+        },
+        "standardPercent": 50.0,
+        "targetBG": 110,
+        "userOverride": 1,
+        "type": "Bolus",
+        "description": "Extended 50.00%/0.00",
+        "sourceRecId": 1209631944,
+        "eventTypeId": 0,
+        "indexId": 0,
+        "uploadId": 0,
+        "interactive": 0,
+        "tempRateId": 0,
+        "tempRateCompleted": 0,
+        "tempRateActivated": 0
+    }
+
+    def test_extended_bolus_complete_to_bolus(self):
+        e = BolusTherapyEvent.parse(self.extendedBolusJson)
+        self.assertIsNotNone(e)
+        b = e.to_bolus()
+        self.assertEqual(dataclasses.asdict(b), dataclasses.asdict(Bolus(
+            description="Extended 50.00%/0.00",
+            complete="1",
+            completion="Completed",
+            request_time="2022-08-09 23:19:15-04:00",
+            completion_time="2022-08-09 23:20:04-04:00",
+            insulin="0.2",
+            requested_insulin="0.2",
+            carbs="0",
+            bg="131",
+            user_override="1",
+            extended_bolus="1",
+            bolex_completion_time="2022-08-09 23:35:03-04:00",
+            bolex_start_time="2022-08-09 23:20:04-04:00"
+        )))
+
+
+BOLUS_FULL_EXAMPLES = [
+    TestBolusTherapyEvent.standardJson,
+    TestBolusTherapyEvent.correctionJson,
+    TestBolusTherapyEvent.extendedBolusJson
+]
@@ -8,19 +8,19 @@ class NightscoutApi(tconnectsync.nightscout.NightscoutApi):
        self.secret = 'invalid'

        self.uploaded_entries = collections.defaultdict(list)
-        self.deleted_entries = collections.defaultdict(list)
+        self.deleted_entries = []
        self.put_entries = collections.defaultdict(list)

    def upload_entry(self, ns_format, entity='treatments'):
        self.uploaded_entries[entity].append(ns_format)

-    def delete_entry(self, ns_format, entity):
-        self.deleted_entries[entity].append(ns_format)
+    def delete_entry(self, ns_path):
+        self.deleted_entries.append(ns_path)

    def put_entry(self, ns_format, entity):
        self.put_entries[entity].append(ns_format)

-    def last_uploaded_entry(self, eventType):
+    def last_uploaded_entry(self, eventType, time_start=None, time_end=None):
        raise NotImplementedError

    def last_uploaded_activity(self, activityType):
@@ -1,9 +1,12 @@
 #!/usr/bin/env python3

 import unittest
-from tconnectsync.parser.nightscout import NightscoutEntry
+from tconnectsync.parser.nightscout import NightscoutEntry, InvalidBolusTypeException, tandem_to_ns_time, tandem_to_ns_time_seconds
+from tconnectsync.domain.device_settings import Profile, ProfileSegment, DeviceSettings

+from ..sync.test_profile import DEVICE_PROFILE_A, DEVICE_SETTINGS, NS_PROFILE_A
 class TestNightscoutEntry(unittest.TestCase):
+    maxDiff = None
    def test_basal(self):
        self.assertEqual(
            NightscoutEntry.basal(
@@ -15,10 +18,12 @@ class TestNightscoutEntry(unittest.TestCase):
                "reason": "",
                "duration": 30,
                "absolute": 1.05,
+                "rate": 1.05,
                "created_at": "2021-03-16 00:25:21-04:00",
                "carbs": None,
                "insulin": None,
-                "enteredBy": "Pump (tconnectsync)"
+                "enteredBy": "Pump (tconnectsync)",
+                "pump_event_id": ""
            }
        )

@@ -33,10 +38,12 @@ class TestNightscoutEntry(unittest.TestCase):
                "reason": "Correction",
                "duration": 5,
                "absolute": 0.95,
+                "rate": 0.95,
                "created_at": "2021-03-16 12:25:21-04:00",
                "carbs": None,
                "insulin": None,
-                "enteredBy": "Pump (tconnectsync)"
+                "enteredBy": "Pump (tconnectsync)",
+                "pump_event_id": ""
            }
        )

@@ -52,7 +59,8 @@ class TestNightscoutEntry(unittest.TestCase):
                "carbs": 45,
                "insulin": 7.5,
                "notes": "",
-                "enteredBy": "Pump (tconnectsync)"
+                "enteredBy": "Pump (tconnectsync)",
+                "pump_event_id": ""
            }
        )

@@ -67,10 +75,61 @@ class TestNightscoutEntry(unittest.TestCase):
                "carbs": 5,
                "insulin": 0.5,
                "notes": "",
-                "enteredBy": "Pump (tconnectsync)"
+                "enteredBy": "Pump (tconnectsync)",
+                "pump_event_id": ""
            }
        )

+    def test_bolus_with_bg(self):
+        self.assertEqual(
+            NightscoutEntry.bolus(
+                bolus=7.5,
+                carbs=45,
+                created_at="2021-03-16 00:25:21-04:00",
+                bg="123",
+                bg_type=NightscoutEntry.SENSOR),
+            {
+                "eventType": "Combo Bolus",
+                "created_at": "2021-03-16 00:25:21-04:00",
+                "carbs": 45,
+                "insulin": 7.5,
+                "notes": "",
+                "enteredBy": "Pump (tconnectsync)",
+                "glucose": "123",
+                "glucoseType": "Sensor",
+                "pump_event_id": ""
+            }
+        )
+
+        self.assertEqual(
+            NightscoutEntry.bolus(
+                bolus=0.5,
+                carbs=5,
+                created_at="2021-03-16 12:25:21-04:00",
+                bg="150",
+                bg_type=NightscoutEntry.FINGER),
+            {
+                "eventType": "Combo Bolus",
+                "created_at": "2021-03-16 12:25:21-04:00",
+                "carbs": 5,
+                "insulin": 0.5,
+                "notes": "",
+                "enteredBy": "Pump (tconnectsync)",
+                "glucose": "150",
+                "glucoseType": "Finger",
+                "pump_event_id": ""
+            }
+        )
+
+    def test_bolus_with_bg_invalid_type(self):
+        self.assertRaises(InvalidBolusTypeException,
+            NightscoutEntry.bolus,
+            bolus=0.5,
+            carbs=5,
+            created_at="2021-03-16 12:25:21-04:00",
+            bg="150",
+            bg_type="unknown")
+
    def test_iob(self):
        self.assertEqual(
            NightscoutEntry.iob(
@@ -84,6 +143,84 @@ class TestNightscoutEntry(unittest.TestCase):
            }
        )

+    def test_entry(self):
+        self.assertEqual(
+            NightscoutEntry.entry(
+                sgv=152,
+                created_at="2021-10-23 22:17:14-04:00"),
+            {
+                "type": "sgv",
+                "sgv": 152,
+                "date": 1635041834000,
+                "dateString": "2021-10-23T22:17:14-0400",
+                "device": "Pump (tconnectsync)",
+                "pump_event_id": ""
+            }
+        )
+
+    def test_sitechange(self):
+        self.assertEqual(
+            NightscoutEntry.sitechange(
+                created_at="2021-12-05T00:16:35.058Z",
+                reason="reason"),
+            {
+                "eventType": "Site Change",
+                "reason": "reason",
+                "notes": "reason",
+                "created_at": "2021-12-05T00:16:35.058Z",
+                "enteredBy": "Pump (tconnectsync)",
+                "pump_event_id": ""
+            }
+        )
+
+    def test_basalsuspension(self):
+        self.assertEqual(
+            NightscoutEntry.basalsuspension(
+                created_at="2021-12-05T00:16:35.058Z",
+                reason="reason"),
+            {
+                "eventType": "Basal Suspension",
+                "reason": "reason",
+                "notes": "reason",
+                "created_at": "2021-12-05T00:16:35.058Z",
+                "enteredBy": "Pump (tconnectsync)",
+                "pump_event_id": ""
+            }
+        )
+
+
+    def test_profile_store(self):
+        self.assertEqual(
+            NightscoutEntry.profile_store(
+                profile=DEVICE_PROFILE_A,
+                device_settings=DEVICE_SETTINGS
+            ),
+            NS_PROFILE_A
+        )
+
+
+class TestTandemNightscoutTime(unittest.TestCase):
+    def test_tandem_to_ns_time(self):
+        self.assertEqual(tandem_to_ns_time('12:00 AM'), '00:00')
+        self.assertEqual(tandem_to_ns_time('12:30 AM'), '00:30')
+        self.assertEqual(tandem_to_ns_time('6:00 AM'), '06:00')
+        self.assertEqual(tandem_to_ns_time('6:30 AM'), '06:30')
+        self.assertEqual(tandem_to_ns_time('11:30 AM'), '11:30')
+        self.assertEqual(tandem_to_ns_time('12:00 PM'), '12:00')
+        self.assertEqual(tandem_to_ns_time('12:30 PM'), '12:30')
+        self.assertEqual(tandem_to_ns_time('06:30 PM'), '18:30')
+        self.assertEqual(tandem_to_ns_time('11:30 PM'), '23:30')
+
+    def test_tandem_to_ns_time_seconds(self):
+        self.assertEqual(tandem_to_ns_time_seconds('12:00 AM'), 0)
+        self.assertEqual(tandem_to_ns_time_seconds('12:30 AM'), 30*60)
+        self.assertEqual(tandem_to_ns_time_seconds('6:00 AM'), 6*60*60)
+        self.assertEqual(tandem_to_ns_time_seconds('6:30 AM'), 6*60*60 + 30*60)
+        self.assertEqual(tandem_to_ns_time_seconds('11:30 AM'), 11*60*60 + 30*60)
+        self.assertEqual(tandem_to_ns_time_seconds('12:00 PM'), 12*60*60)
+        self.assertEqual(tandem_to_ns_time_seconds('12:30 PM'), 12*60*60 + 30*60)
+        self.assertEqual(tandem_to_ns_time_seconds('06:30 PM'), 12*60*60 + 6*60*60 + 30*60)
+        self.assertEqual(tandem_to_ns_time_seconds('11:30 PM'), 12*60*60 + 11*60*60 + 30*60)

 if __name__ == '__main__':
    unittest.main()
@@ -1,7 +1,8 @@
 #!/usr/bin/env python3

 import unittest
-from tconnectsync.parser.tconnect import TConnectEntry
+from tconnectsync.domain.bolus import Bolus
+from tconnectsync.parser.tconnect import TConnectEntry, UnknownBasalSuspensionEventException, UnknownCIQActivityEventException

 class TestTConnectEntryBasal(unittest.TestCase):
    def test_parse_ciq_basal_entry(self):
@@ -33,6 +34,103 @@ class TestTConnectEntryBasal(unittest.TestCase):
            }
        )

+class TestTConnectEntrySuspension(unittest.TestCase):
+    def test_parse_suspension_entry(self):
+        self.assertEqual(
+            TConnectEntry.parse_suspension_entry({
+                "suspendReason": "control-iq",
+                "continuation": None,
+                "x": 1615879821
+            }),
+            {
+                "time": "2021-03-16 00:30:21-04:00",
+                "continuation": None,
+                "suspendReason": "control-iq"
+            }
+        )
+        self.assertEqual(
+            TConnectEntry.parse_suspension_entry({
+                "suspendReason": "control-iq",
+                "continuation": "previous",
+                "x": 1634022000
+            }),
+            {
+                "time": "2021-10-12 00:00:00-04:00",
+                "continuation": "previous",
+                "suspendReason": "control-iq"
+            }
+        )
+
+class TestTConnectEntrySuspensionToBasal(unittest.TestCase):
+    def test_manual_suspension_to_basal_entry(self):
+        suspension = {
+            "time": "2021-03-16 00:30:21-04:00",
+            "continuation": None,
+            "suspendReason": "manual"
+        }
+
+        self.assertEqual(
+            TConnectEntry.manual_suspension_to_basal_entry(
+                suspension,
+                seconds=300
+            ), {
+                "time": "2021-03-16 00:30:21-04:00",
+                "delivery_type": "manual suspension",
+                "duration_mins": 5.0,
+                "basal_rate": 0.0
+            }
+        )
+
+class TestTConnectEntryCGM(unittest.TestCase):
+    def test_parse_cgm_entry(self):
+        self.assertEqual(
+            TConnectEntry.parse_cgm_entry({
+                "DeviceType": "t:slim X2 Insulin Pump",
+                "SerialNumber": "11111111",
+                "Description": "EGV",
+                "EventDateTime": "2021-10-12T00:01:12",
+                "Readings (CGM / BGM)": "131"
+            }),
+            {
+                "time": "2021-10-12 00:01:12-04:00",
+                "reading": "131",
+                "reading_type": "EGV"
+            }
+        )
+
+class TestTConnectEntryIOB(unittest.TestCase):
+    entry1 = {
+        "Type": "IOB",
+        "EventID": "81",
+        "EventDateTime": "2021-10-12T00:00:30",
+        "IOB": "6.91"
+    }
+    def test_parse_iob_entry1(self):
+        self.assertEqual(
+            TConnectEntry.parse_iob_entry(self.entry1),
+            {
+                "time": "2021-10-12 00:00:30-04:00",
+                "iob": "6.91",
+                "event_id": "81"
+            }
+        )
+
+    entry2 = {
+        "Type": "IOB",
+        "EventID": "9",
+        "EventDateTime": "2021-10-12T00:10:30",
+        "IOB": "6.80"
+    }
+    def test_parse_iob_entry2(self):
+        self.assertEqual(
+            TConnectEntry.parse_iob_entry(self.entry2),
+            {
+                "time": "2021-10-12 00:10:30-04:00",
+                "iob": "6.80",
+                "event_id": "9"
+            }
+        )
+
 class TestTConnectEntryBolus(unittest.TestCase):
    entryStdCorrection = {
        "Type": "Bolus",
@@ -80,19 +178,21 @@ class TestTConnectEntryBolus(unittest.TestCase):
    def test_parse_bolus_entry_std_correction(self):
        self.assertEqual(
            TConnectEntry.parse_bolus_entry(self.entryStdCorrection),
-            {
+            Bolus(**{
                "description": "Standard/Correction",
                "complete": "1",
                "completion": "Completed",
                "request_time": "2021-04-01 12:53:36-04:00",
                "completion_time": "2021-04-01 12:58:26-04:00",
                "insulin": "13.53",
+                "requested_insulin": "13.53",
                "carbs": "75",
+                "bg": "141",
                "user_override": "0",
                "extended_bolus": "",
                "bolex_completion_time": None,
                "bolex_start_time": None
-        })
+        }))
    
    entryStd = {
        "Type": "Bolus",
@@ -140,19 +240,21 @@ class TestTConnectEntryBolus(unittest.TestCase):
    def test_parse_bolus_entry_std(self):
        self.assertEqual(
            TConnectEntry.parse_bolus_entry(self.entryStd),
-            {
+            Bolus(**{
                "description": "Standard",
                "complete": "1",
                "completion": "Completed",
                "request_time": "2021-04-01 23:21:58-04:00",
                "completion_time": "2021-04-01 23:23:17-04:00",
                "insulin": "1.25",
+                "requested_insulin": "1.25",
                "carbs": "0",
+                "bg": "159",
                "user_override": "1",
                "extended_bolus": "",
                "bolex_completion_time": None,
                "bolex_start_time": None
-        })
+        }))
    
    entryStdAutomatic = {
        "Type": "Bolus",
@@ -200,21 +302,403 @@ class TestTConnectEntryBolus(unittest.TestCase):
    def test_parse_bolus_entry_std_automatic(self):
        self.assertEqual(
            TConnectEntry.parse_bolus_entry(self.entryStdAutomatic),
-            {
+            Bolus(**{
                "description": "Automatic Bolus/Correction",
                "complete": "1",
                "completion": "Completed",
                "request_time": "2021-04-02 00:59:13-04:00",
                "completion_time": "2021-04-02 01:00:47-04:00",
                "insulin": "1.70",
+                "requested_insulin": "1.70",
                "carbs": "0",
+                "bg": "",
                "user_override": "0",
                "extended_bolus": "",
                "bolex_completion_time": None,
                "bolex_start_time": None
-        })
+        }))
+    
+    entryStdIncompleteZero = {
+        "Type": "Bolus",
+        "Description": "Standard",
+        "BG": "144",
+        "IOB": "1.20",
+        "BolusRequestID": "9694.000",
+        "BolusCompletionID": "9694.000",
+        "CompletionDateTime": "2021-10-08T15:47:02",
+        "InsulinDelivered": "0.00",
+        "FoodDelivered": "0.00",
+        "CorrectionDelivered": "0.00",
+        "CompletionStatusID": "0",
+        "CompletionStatusDesc": "User Aborted",
+        "BolusIsComplete": "0",
+        "BolexCompletionID": "",
+        "BolexSize": "",
+        "BolexStartDateTime": "",
+        "BolexCompletionDateTime": "",
+        "BolexInsulinDelivered": "",
+        "BolexIOB": "",
+        "BolexCompletionStatusID": "",
+        "BolexCompletionStatusDesc": "",
+        "ExtendedBolusIsComplete": "",
+        "EventDateTime": "2021-10-08T15:46:56",
+        "RequestDateTime": "2021-10-08T15:46:56",
+        "BolusType": "Carb",
+        "BolusRequestOptions": "Standard",
+        "StandardPercent": "100.00",
+        "Duration": "0",
+        "CarbSize": "0",
+        "UserOverride": "1",
+        "TargetBG": "110",
+        "CorrectionFactor": "30.00",
+        "FoodBolusSize": "0.00",
+        "CorrectionBolusSize": "0.00",
+        "ActualTotalBolusRequested": "0.50",
+        "IsQuickBolus": "0",
+        "EventHistoryReportEventDesc": "0",
+        "EventHistoryReportDetails": "Food Bolus",
+        "NoteID": "CF 1:30 - Carb Ratio 1:6 - Target BG 110 | Override: Pump calculated Bolus = 0.0 units",
+        "IndexID": "0",
+        "Note": "1669328"
+    }
+    def test_parse_bolus_entry_std_incomplete_zero(self):
+        self.assertEqual(
+            TConnectEntry.parse_bolus_entry(self.entryStdIncompleteZero),
+            Bolus(**{
+                "description": "Standard",
+                "complete": "",
+                "completion": "User Aborted",
+                "request_time": "2021-10-08 15:46:56-04:00",
+                "completion_time": "2021-10-08 15:47:02-04:00",
+                "insulin": "0.00",
+                "requested_insulin": "0.50",
+                "carbs": "0",
+                "bg": "144",
+                "user_override": "1",
+                "extended_bolus": "",
+                "bolex_completion_time": None,
+                "bolex_start_time": None
+            }))
+    
+    entryStdIncompletePartial = {
+        "Type": "Bolus",
+        "Description": "Standard/Correction",
+        "BG": "189",
+        "IOB": "",
+        "BolusRequestID": "9261.000",
+        "BolusCompletionID": "9261.000",
+        "CompletionDateTime": "2021-09-06T12:24:47",
+        "InsulinDelivered": "1.82",
+        "FoodDelivered": "0.00",
+        "CorrectionDelivered": "1.82",
+        "CompletionStatusID": "1",
+        "CompletionStatusDesc": "Terminated by Alarm",
+        "BolusIsComplete": "0",
+        "BolexCompletionID": "",
+        "BolexSize": "",
+        "BolexStartDateTime": "",
+        "BolexCompletionDateTime": "",
+        "BolexInsulinDelivered": "",
+        "BolexIOB": "",
+        "BolexCompletionStatusID": "",
+        "BolexCompletionStatusDesc": "",
+        "ExtendedBolusIsComplete": "",
+        "EventDateTime": "2021-09-06T12:23:23",
+        "RequestDateTime": "2021-09-06T12:23:23",
+        "BolusType": "Carb",
+        "BolusRequestOptions": "Standard/Correction",
+        "StandardPercent": "100.00",
+        "Duration": "0",
+        "CarbSize": "0",
+        "UserOverride": "0",
+        "TargetBG": "110",
+        "CorrectionFactor": "30.00",
+        "FoodBolusSize": "0.00",
+        "CorrectionBolusSize": "2.63",
+        "ActualTotalBolusRequested": "2.63",
+        "IsQuickBolus": "0",
+        "EventHistoryReportEventDesc": "0",
+        "EventHistoryReportDetails": "Correction & Food Bolus",
+        "NoteID": "CF 1:30 - Carb Ratio 1:6 - Target BG 110",
+        "IndexID": "0",
+        "Note": "1589227"
+    }
+    def test_parse_bolus_entry_std_incomplete_partial(self):
+        self.assertEqual(
+            TConnectEntry.parse_bolus_entry(self.entryStdIncompletePartial),
+            Bolus(**{
+                "description": "Standard/Correction",
+                "complete": "",
+                "completion": "Terminated by Alarm",
+                "request_time": "2021-09-06 12:23:23-04:00",
+                "completion_time": "2021-09-06 12:24:47-04:00",
+                "insulin": "1.82",
+                "requested_insulin": "2.63",
+                "carbs": "0",
+                "bg": "189",
+                "user_override": "0",
+                "extended_bolus": "",
+                "bolex_completion_time": None,
+                "bolex_start_time": None
+            }))


+    entryExtendedComplete = {
+        "Type": "Bolus",
+        "Description": "Extended 50.00%/0.00",
+        "BG": "131",
+        "IOB": "5.87",
+        "BolusRequestID": "3636.000",
+        "BolusCompletionID": "3636.000",
+        "CompletionDateTime": "2022-08-09T23:20:04",
+        "InsulinDelivered": "0.20",
+        "FoodDelivered": "0.00",
+        "CorrectionDelivered": "0.00",
+        "CompletionStatusID": "3",
+        "CompletionStatusDesc": "Completed",
+        "BolusIsComplete": "1",
+        "BolexCompletionID": "16757133",
+        "BolexSize": "0.20",
+        "BolexStartDateTime": "2022-08-09T23:20:04",
+        "BolexCompletionDateTime": "2022-08-09T23:35:03",
+        "BolexInsulinDelivered": "0.20",
+        "BolexIOB": "5.7",
+        "BolexCompletionStatusID": "3.00",
+        "BolexCompletionStatusDesc": "Completed",
+        "ExtendedBolusIsComplete": "1",
+        "EventDateTime": "2022-08-09T23:19:15",
+        "RequestDateTime": "2022-08-09T23:19:15",
+        "BolusType": "Carb",
+        "BolusRequestOptions": "Extended",
+        "StandardPercent": "50.00",
+        "Duration": "15",
+        "CarbSize": "0",
+        "UserOverride": "1",
+        "TargetBG": "110",
+        "CorrectionFactor": "30.00",
+        "FoodBolusSize": "0.00",
+        "CorrectionBolusSize": "0.00",
+        "ActualTotalBolusRequested": "0.40",
+        "IsQuickBolus": "0",
+        "EventHistoryReportEventDesc": "0",
+        "EventHistoryReportDetails": "Food Bolus: 50% Extended 15 mins",
+        "NoteID": "CF 1:30 - Carb Ratio 1:6 - Target BG 110 | Override: Pump calculated Bolus = 0.0 units",
+        "IndexID": "0",
+        "Note": "631597"
+    }
+    def test_parse_bolus_entry_extended_complete(self):
+        self.assertEqual(
+            TConnectEntry.parse_bolus_entry(self.entryExtendedComplete),
+            Bolus(**{
+                "description": "Extended 50.00%/0.00",
+                "complete": "1",
+                "completion": "Completed",
+                "request_time": None,
+                "completion_time": None,
+                "insulin": "0.20",
+                "requested_insulin": "0.40",
+                "carbs": "0",
+                "bg": "131",
+                "user_override": "1",
+                "extended_bolus": "1",
+                "bolex_completion_time": "2022-08-09 23:35:03-04:00",
+                "bolex_start_time": "2022-08-09 23:20:04-04:00"
+            }))
+
+
+
+class TestTConnectEntryReading(unittest.TestCase):
+    entry1 = {
+        "DeviceType": "t:slim X2 Insulin Pump",
+        "SerialNumber": "90556643",
+        "Description": "EGV",
+        "EventDateTime": "2021-10-23T12:55:53",
+        "Readings (CGM / BGM)": "135"
+    }
+    def test_parse_reading_entry1(self):
+        self.assertEqual(
+            TConnectEntry.parse_reading_entry(self.entry1),
+            {
+                "time": "2021-10-23 12:55:53-04:00",
+                "bg": "135",
+                "type": "EGV"
+            }
+        )
+
+    entry2 = {
+        "DeviceType": "t:slim X2 Insulin Pump",
+        "SerialNumber": "90556643",
+        "Description": "EGV",
+        "EventDateTime": "2021-10-23T16:15:52",
+        "Readings (CGM / BGM)": "93"
+    }
+    def test_parse_reading_entry2(self):
+        self.assertEqual(
+            TConnectEntry.parse_reading_entry(self.entry2),
+            {
+                "time": "2021-10-23 16:15:52-04:00",
+                "bg": "93",
+                "type": "EGV"
+            }
+        )
+
+    entry3 = {
+        "DeviceType": "t:slim X2 Insulin Pump",
+        "SerialNumber": "90556643",
+        "Description": "EGV",
+        "EventDateTime": "2021-10-23T16:20:52",
+        "Readings (CGM / BGM)": "100"
+    }
+    def test_parse_reading_entry3(self):
+        self.assertEqual(
+            TConnectEntry.parse_reading_entry(self.entry3),
+            {
+                "time": "2021-10-23 16:20:52-04:00",
+                "bg": "100",
+                "type": "EGV"
+            }
+        )
+
+    entry4 = {
+        "DeviceType": "t:slim X2 Insulin Pump",
+        "SerialNumber": "90556643",
+        "Description": "EGV",
+        "EventDateTime": "2021-10-23T16:25:52",
+        "Readings (CGM / BGM)": "107"
+    }
+    def test_parse_reading_entry4(self):
+        self.assertEqual(
+            TConnectEntry.parse_reading_entry(self.entry4),
+            {
+                "time": "2021-10-23 16:25:52-04:00",
+                "bg": "107",
+                "type": "EGV"
+            }
+        )
+
+
+class TestTConnectEntryCIQEvent(unittest.TestCase):
+    def test_parse_ciq_activity_event_sleep(self):
+        self.assertEqual(
+            TConnectEntry.parse_ciq_activity_event({
+                "continuation": None,
+                "duration": 30661,
+                "eventType": 1,
+                "timeZoneId": "America/Los_Angeles",
+                "x": 1638091836
+            }),
+            {
+                "time": "2021-11-28 01:30:36-05:00",
+                "duration_mins": (30661 / 60),
+                "event_type": "Sleep"
+            }
+        )
+
+    def test_parse_ciq_activity_event_exercise(self):
+        self.assertEqual(
+            TConnectEntry.parse_ciq_activity_event({
+                "duration": 1200,
+                "eventType": 2,
+                "continuation": None, 
+                "timeZoneId": "America/Los_Angeles",
+                "x": 1619901912
+            }),
+            {
+                "time": "2021-05-01 13:45:12-04:00",
+                "duration_mins": 20,
+                "event_type": "Exercise"
+            }
+        )
+    
+    def test_parse_ciq_activity_event_unknown_id(self):
+        self.assertRaises(
+            UnknownCIQActivityEventException, 
+            TConnectEntry.parse_ciq_activity_event,
+            {
+                "duration": 1200,
+                "eventType": 5,
+                "continuation": None, 
+                "timeZoneId": "America/Los_Angeles",
+                "x": 1619901912
+            }
+        )
+
+class TestTConnectEntryBasalSuspensionEvent(unittest.TestCase):
+    def test_parse_basalsuspension_event_sitecart(self):
+        self.assertEqual(
+            TConnectEntry.parse_basalsuspension_event({
+                'EventDateTime': '/Date(1638663490000-0000)/',
+                'SuspendReason': 'site-cart'
+            }),
+            {
+                "time": "2021-12-04 16:18:10-05:00",
+                "event_type": "Site/Cartridge Change"
+            }
+        )
+
+    def test_parse_basalsuspension_event_alarm(self):
+        self.assertEqual(
+            TConnectEntry.parse_basalsuspension_event({
+                'EventDateTime': '/Date(1637863616000-0000)/',
+                'SuspendReason': 'alarm'
+            }),
+            {
+                "time": "2021-11-25 10:06:56-05:00",
+                "event_type": "Empty Cartridge/Pump Shutdown"
+            }
+        )
+
+    def test_parse_basalsuspension_event_manual(self):
+        self.assertEqual(
+            TConnectEntry.parse_basalsuspension_event({
+                'EventDateTime': '/Date(1638662852000-0000)/',
+                'SuspendReason': 'manual'
+            }),
+            {
+                "time": "2021-12-04 16:07:32-05:00",
+                "event_type": "User Suspended"
+            }
+        )
+
+    def test_parse_basalsuspension_event_tempprofile(self):
+        self.assertEqual(
+            TConnectEntry.parse_basalsuspension_event({
+                'EventDateTime': '/Date(1640541521000-0000)/',
+                'SuspendReason': 'temp-profile'
+            }),
+            {
+                "time": "2021-12-26 09:58:41-05:00",
+                "event_type": "Basal Rate Change"
+            }
+        )
+
+    def test_parse_basalsuspension_event_basalprofile_skipped(self):
+        self.assertIsNone(
+            TConnectEntry.parse_basalsuspension_event({
+                'EventDateTime': '/Date(1638659343000-0000)/',
+                'SuspendReason': 'basal-profile',
+            })
+        )
+
+    def test_parse_basalsuspension_event_previous_skipped(self):
+        self.assertIsNone(
+            TConnectEntry.parse_basalsuspension_event({
+                'Continuation': 'continuation',
+                'EventDateTime': '/Date(1638604800000-0000)/',
+                'SuspendReason': 'previous',
+            })
+        )
+    
+    def test_parse_basalsuspension_event_unknown_suspendreason(self):
+        self.assertRaises(
+            UnknownBasalSuspensionEventException, 
+            TConnectEntry.parse_basalsuspension_event,
+            {
+                'EventDateTime': '/Date(1638604800000-0000)/',
+                'SuspendReason': 'unknown',
+            }
+        )
+

 if __name__ == '__main__':
    unittest.main()
@@ -0,0 +1,15 @@
+import importlib
+
+def build_secrets(**kwargs):
+    secret = importlib.reload(importlib.import_module("tconnectsync.secret"))
+    class FakeSecret(object):
+        pass
+
+    fake = FakeSecret()
+    for k in dir(secret):
+        setattr(fake, k, getattr(secret, k))
+
+    for k, v in kwargs.items():
+        setattr(fake, k, v)
+    
+    return fake
@@ -1,10 +1,14 @@
 #!/usr/bin/env python3

 import unittest
+import copy
+
 from tconnectsync.sync.basal import process_ciq_basal_events
 from tconnectsync.parser.tconnect import TConnectEntry

 class TestBasalSync(unittest.TestCase):
+    maxDiff = None
+
    base = {
        "basal": {
            "profileRates": [],
@@ -20,31 +24,31 @@ class TestBasalSync(unittest.TestCase):

    @staticmethod
    def get_example_ciq_basal_events():
-        data = TestBasalSync.base.copy()
+        data = copy.deepcopy(TestBasalSync.base)
        data["basal"]["tempDeliveryEvents"] = [
            {
                "y": 0.8,
                "duration": 1221,
-                "x": 1615878000
+                "x": 1615878000 # 12:00:00
            }
        ]
        data["basal"]["algorithmDeliveryEvents"] = [
            {
                "y": 0.797,
                "duration": 300,
-                "x": 1615879521
+                "x": 1615879521 # 12:25:21
            },
            {
                "y": 0,
                "duration": 2693,
-                "x": 1615879821
+                "x": 1615879821 # 12:30:21
            },
        ]
        data["basal"]["profileDeliveryEvents"] = [
            {
                "y": 0.799,
                "duration": 300,
-                "x": 1615879221
+                "x": 1615879221 # 12:20:21
            }
        ]

@@ -52,7 +56,7 @@ class TestBasalSync(unittest.TestCase):
            {
                "suspendReason": "control-iq",
                "continuation": None,
-                "x": 1615879821
+                "x": 1615879821 # 12:30:21
            },
        ]

@@ -73,12 +77,68 @@ class TestBasalSync(unittest.TestCase):
        self.assertEqual(basalEvents[2], TConnectEntry.parse_ciq_basal_entry(
            data["basal"]["algorithmDeliveryEvents"][0], delivery_type="algorithmDelivery"))

-        self.assertEqual(basalEvents[3], {
-            "suspendReason": "control-iq",
-            **TConnectEntry.parse_ciq_basal_entry(
+        self.assertEqual(basalEvents[3], TConnectEntry.parse_ciq_basal_entry(
                data["basal"]["algorithmDeliveryEvents"][1],
-                delivery_type="algorithmDelivery")
-        })
+                delivery_type="algorithmDelivery (control-iq suspension)")
+        )
+    
+
+    @staticmethod
+    def get_example_ciq_basal_events_with_manual_suspension():
+        data = copy.deepcopy(TestBasalSync.base)
+        data["basal"]["tempDeliveryEvents"] = []
+        data["basal"]["algorithmDeliveryEvents"] = [
+            {
+                "y": 1.14,
+                "duration": 300,
+                "x": 1635187357 # 11:42:37
+            },
+            {
+                "y": 0.8,
+                "duration": 1198,
+                "x": 1635187657 # 11:47:37
+            },
+            {
+                "y": 0.8,
+                "duration": 599,
+                "x": 1635190967 # 12:42:47
+            }
+        ]
+        data["basal"]["profileDeliveryEvents"] = []
+        data["suspensionDeliveryEvents"] = [
+            {
+                "suspendReason": "manual",
+                "continuation": None,
+                "x": 1635188855 # 12:07:35
+            },
+            {
+                "suspendReason": "manual",
+                "continuation": None,
+                "x": 1635191566 # 12:52:46
+            },
+        ]
+
+        return data
+
+    def test_process_ciq_basal_events_with_manual_suspension(self):
+        data = TestBasalSync.get_example_ciq_basal_events_with_manual_suspension()
+        
+        basalEvents = process_ciq_basal_events(data)
+        self.assertEqual(len(basalEvents), 4)
+
+        self.assertEqual(basalEvents[0], TConnectEntry.parse_ciq_basal_entry(
+            data["basal"]["algorithmDeliveryEvents"][0], delivery_type="algorithmDelivery"))
+
+        self.assertEqual(basalEvents[1], TConnectEntry.parse_ciq_basal_entry(
+            data["basal"]["algorithmDeliveryEvents"][1], delivery_type="algorithmDelivery"))
+
+        self.assertEqual(basalEvents[2], TConnectEntry.manual_suspension_to_basal_entry(
+            TConnectEntry.parse_suspension_entry(data["suspensionDeliveryEvents"][0]),
+            seconds=2112, # 2112 seconds between 12:07:35 and 12:42:47
+        ))
+
+        self.assertEqual(basalEvents[3], TConnectEntry.parse_ciq_basal_entry(
+            data["basal"]["algorithmDeliveryEvents"][2], delivery_type="algorithmDelivery"))


 if __name__ == '__main__':
@@ -1,34 +1,194 @@
 #!/usr/bin/env python3

 import unittest
+import random
+

 from tconnectsync.sync.bolus import process_bolus_events
 from tconnectsync.parser.tconnect import TConnectEntry
+from tconnectsync.parser.nightscout import NightscoutEntry

-from ..parser.test_tconnect import TestTConnectEntryBolus
+from ..parser.test_tconnect import TestTConnectEntryBolus, TestTConnectEntryCGM, TestTConnectEntryReading

 class TestBolusSync(unittest.TestCase):

    @staticmethod
    def get_example_csv_bolus_events():
        return [
+            TestTConnectEntryBolus.entryStdCorrection,
+            TestTConnectEntryBolus.entryStd,
+            TestTConnectEntryBolus.entryStdAutomatic,
+            TestTConnectEntryBolus.entryStdIncompletePartial
+        ]
+
+    def test_process_bolus_events_standard(self):
+        bolusData = [
            TestTConnectEntryBolus.entryStdCorrection,
            TestTConnectEntryBolus.entryStd,
            TestTConnectEntryBolus.entryStdAutomatic
        ]

-    def test_process_bolus_events(self):
-        bolusData = TestBolusSync.get_example_csv_bolus_events()
-
        bolusEvents = process_bolus_events(bolusData)
-        self.assertEqual(len(bolusEvents), 3)
+        self.assertEqual(len(bolusEvents), len(bolusData))

        self.assertListEqual(bolusEvents, [
-            TConnectEntry.parse_bolus_entry(bolusData[0]),
-            TConnectEntry.parse_bolus_entry(bolusData[1]),
-            TConnectEntry.parse_bolus_entry(bolusData[2])
+            TConnectEntry.parse_bolus_entry(d) for d in bolusData
        ])

+    def test_process_bolus_events_cgmevents_not_matching(self):
+        bolusData = [
+            TestTConnectEntryBolus.entryStdCorrection,
+            TestTConnectEntryBolus.entryStd,
+            TestTConnectEntryBolus.entryStdAutomatic
+        ]
+
+        cgmEvents = [
+            TConnectEntry.parse_reading_entry(TestTConnectEntryReading.entry1),
+            TConnectEntry.parse_reading_entry(TestTConnectEntryReading.entry2),
+            TConnectEntry.parse_reading_entry(TestTConnectEntryReading.entry3)
+        ]
+
+        bolusEvents = process_bolus_events(bolusData, cgmEvents=cgmEvents)
+        self.assertEqual(len(bolusEvents), len(bolusData))
+
+        def set_bg_type(entry, type):
+            entry.bg_type = type
+            return entry
+
+        # Expect FINGER for bolus entries with a BG because there's no matching event with the same BG
+        expected = [
+            set_bg_type(TConnectEntry.parse_bolus_entry(bolusData[0]), NightscoutEntry.FINGER),
+            set_bg_type(TConnectEntry.parse_bolus_entry(bolusData[1]), NightscoutEntry.FINGER),
+            # No BG specified for the automatic bolus
+            TConnectEntry.parse_bolus_entry(bolusData[2])
+        ]
+
+        self.assertListEqual(bolusEvents, expected)
+
+    def test_process_bolus_events_cgmevents_matches(self):
+        bolusData = [
+            TestTConnectEntryBolus.entryStdCorrection,
+            TestTConnectEntryBolus.entryStd,
+            TestTConnectEntryBolus.entryStdAutomatic
+        ]
+
+        cgmEvents = [
+            {
+                "time": "2021-04-01 12:45:30-04:00",
+                "bg": "100",
+                "type": "EGV"
+            },
+            # Matches entryStdCorrection time but with wrong BG
+            {
+                "time": "2021-04-01 12:50:30-04:00",
+                "bg": "105",
+                "type": "EGV"
+            },
+            {
+                "time": "2021-04-01 13:00:30-04:00",
+                "bg": "110",
+                "type": "EGV"
+            },
+            {
+                "time": "2021-04-01 23:15:30-04:00",
+                "bg": "150",
+                "type": "EGV"
+            },
+            # Matches entryStd time with correct BG
+            {
+                "time": "2021-04-01 23:20:30-04:00",
+                "bg": "159",
+                "type": "EGV"
+            },
+            {
+                "time": "2021-04-01 23:25:30-04:00",
+                "bg": "160",
+                "type": "EGV"
+            },
+        ]
+
+        bolusEvents = process_bolus_events(bolusData, cgmEvents=cgmEvents)
+        self.assertEqual(len(bolusEvents), len(bolusData))
+
+        def set_bg_type(entry, type):
+            entry.bg_type = type
+            return entry
+
+        expected = [
+            # Time found but BG doesn't match
+            set_bg_type(TConnectEntry.parse_bolus_entry(bolusData[0]), NightscoutEntry.FINGER),
+            # Time found and BG matches
+            set_bg_type(TConnectEntry.parse_bolus_entry(bolusData[1]), NightscoutEntry.SENSOR),
+            # No BG specified for the automatic bolus
+            TConnectEntry.parse_bolus_entry(bolusData[2])
+        ]
+
+        self.assertListEqual(bolusEvents, expected)
+
+    def test_process_bolus_events_update_partial_description(self):
+        stdData = [
+            TestTConnectEntryBolus.entryStdCorrection,
+            TestTConnectEntryBolus.entryStd,
+            TestTConnectEntryBolus.entryStdAutomatic
+        ]
+        partialData = [
+            TestTConnectEntryBolus.entryStdIncompletePartial
+        ]
+
+        bolusData = stdData + partialData
+
+        bolusEvents = process_bolus_events(bolusData)
+        self.assertEqual(len(bolusEvents), len(bolusData))
+
+        partialEntries = [
+            TConnectEntry.parse_bolus_entry(e) for e in partialData
+        ]
+
+        for e in partialEntries:
+            e.description += " (%s: requested %s units)" % (e.completion, e.requested_insulin)
+
+        self.assertListEqual(bolusEvents, [
+            TConnectEntry.parse_bolus_entry(d) for d in stdData
+        ] + partialEntries)
+
+    def test_process_bolus_events_skip_zero(self):
+        stdData = [
+            TestTConnectEntryBolus.entryStdCorrection,
+            TestTConnectEntryBolus.entryStd,
+            TestTConnectEntryBolus.entryStdAutomatic
+        ]
+        zeroData = [
+            TestTConnectEntryBolus.entryStdIncompleteZero
+        ]
+        bolusData = stdData + zeroData
+
+        bolusEvents = process_bolus_events(bolusData)
+        self.assertEqual(len(bolusEvents), len(stdData))
+
+        self.assertListEqual(bolusEvents, [
+            TConnectEntry.parse_bolus_entry(d) for d in stdData
+        ])
+
+        for d in zeroData:
+            self.assertNotIn(TConnectEntry.parse_bolus_entry(d), bolusEvents)
+
+    def test_process_bolus_events_ciq_extended_bolus(self):
+        stdData = [
+            TestTConnectEntryBolus.entryExtendedComplete,
+        ]
+        zeroData = [
+        ]
+        bolusData = stdData + zeroData
+
+        bolusEvents = process_bolus_events(bolusData)
+        self.assertEqual(len(bolusEvents), len(stdData))
+
+        self.assertListEqual(bolusEvents, [
+            TConnectEntry.parse_bolus_entry(d) for d in stdData
+        ])
+
+        for d in zeroData:
+            self.assertNotIn(TConnectEntry.parse_bolus_entry(d), bolusEvents)

 if __name__ == '__main__':
    unittest.main()
@@ -0,0 +1,51 @@
+#!/usr/bin/env python3
+
+import unittest
+
+from tconnectsync.sync.cgm import find_event_at, process_cgm_events
+from tconnectsync.parser.tconnect import TConnectEntry
+
+from ..parser.test_tconnect import TestTConnectEntryReading
+
+class TestProcessCGMEvents(unittest.TestCase):
+    def test_process_cgm_events(self):
+        rawReadings = [
+            TestTConnectEntryReading.entry1,
+            TestTConnectEntryReading.entry2,
+            TestTConnectEntryReading.entry3,
+            TestTConnectEntryReading.entry4
+        ]
+        self.assertListEqual(
+            process_cgm_events(rawReadings),
+            [TConnectEntry.parse_reading_entry(r) for r in rawReadings]
+        )
+
+class TestFindEventAt(unittest.TestCase):
+    readingData = [
+        TConnectEntry.parse_reading_entry(TestTConnectEntryReading.entry1),
+        TConnectEntry.parse_reading_entry(TestTConnectEntryReading.entry2),
+        TConnectEntry.parse_reading_entry(TestTConnectEntryReading.entry3),
+        TConnectEntry.parse_reading_entry(TestTConnectEntryReading.entry4)
+    ]
+
+    def test_find_event_at_exact(self):
+        for r in self.readingData:
+            self.assertEqual(find_event_at(self.readingData, r["time"]), r)
+
+    def test_find_event_at_before_not_found(self):
+        self.assertEqual(find_event_at(self.readingData, "2021-10-22 10:30:00-04:00"), None)
+
+    def test_find_event_at_large_gap(self):
+        self.assertEqual(find_event_at(self.readingData, "2021-10-23 13:30:00-04:00"), self.readingData[0])
+
+    def test_find_event_at_between_close(self):
+        self.assertEqual(find_event_at(self.readingData, "2021-10-23 16:17:52-04:00"), self.readingData[1])
+        self.assertEqual(find_event_at(self.readingData, "2021-10-23 16:21:52-04:00"), self.readingData[2])
+        self.assertEqual(find_event_at(self.readingData, "2021-10-23 16:25:59-04:00"), self.readingData[3])
+
+    def test_find_event_at_most_recent(self):
+        self.assertEqual(find_event_at(self.readingData, "2021-10-23 18:00:00-04:00"), self.readingData[3])
+        
+
+if __name__ == '__main__':
+    unittest.main()
@@ -0,0 +1,30 @@
+#!/usr/bin/env python3
+
+import unittest
+
+from tconnectsync.sync.iob import process_iob_events
+from tconnectsync.parser.tconnect import TConnectEntry
+
+from ..parser.test_tconnect import TestTConnectEntryIOB
+
+class TestIOBSync(unittest.TestCase):
+
+    @staticmethod
+    def get_example_csv_iob_events():
+        return [
+            TestTConnectEntryIOB.entry1,
+            TestTConnectEntryIOB.entry2,
+        ]
+
+    def test_process_iob_events(self):
+        iobData = TestIOBSync.get_example_csv_iob_events()
+
+        iobEvents = process_iob_events(iobData)
+        self.assertEqual(len(iobEvents), len(iobData))
+
+        self.assertListEqual(iobEvents, [
+            TConnectEntry.parse_iob_entry(d) for d in iobData
+        ])
+
+if __name__ == '__main__':
+    unittest.main()
@@ -0,0 +1,524 @@
+#!/usr/bin/env python3
+
+import json
+import unittest
+from typing import Dict
+import copy
+
+from tconnectsync.sync.profile import get_pump_profiles, compare_profiles, nightscout_profiles_identical
+from tconnectsync.domain.device_settings import Profile, ProfileSegment, DeviceSettings
+from tconnectsync.secret import NIGHTSCOUT_PROFILE_CARBS_HR_VALUE, NIGHTSCOUT_PROFILE_DELAY_VALUE, TIMEZONE_NAME
+
+from ..parser.test_tconnect import TestTConnectEntryReading
+
+DEVICE_PROFILE_A = Profile(
+    title='A', 
+    active=False, 
+    segments=[
+        ProfileSegment(
+            display_time='Midnight', 
+            time='12:00 AM', 
+            basal_rate=0.8, 
+            correction_factor=30.0, 
+            carb_ratio=6.0, 
+            target_bg_mgdl=110.0), 
+        ProfileSegment(
+            display_time='6:00 AM', 
+            time='6:00 AM', 
+            basal_rate=1.25, 
+            correction_factor=30.0, 
+            carb_ratio=6.0, 
+            target_bg_mgdl=110.0), 
+        ProfileSegment(
+            display_time='11:00 AM', 
+            time='11:00 AM', 
+            basal_rate=1.0, 
+            correction_factor=30.0, 
+            carb_ratio=6.0, 
+            target_bg_mgdl=110.0), 
+        ProfileSegment(
+            display_time='Noon', 
+            time='12:00 PM', 
+            basal_rate=0.8, 
+            correction_factor=30.0, 
+            carb_ratio=6.0, 
+            target_bg_mgdl=110.0)
+    ],
+    calculated_total_daily_basal=21.65, 
+    insulin_duration_min=300, 
+    carbs_enabled=True
+)
+
+DEVICE_PROFILE_B = Profile(
+    title='B', 
+    active=False, 
+    segments=[
+        ProfileSegment(
+            display_time='Midnight', 
+            time='12:00 AM', 
+            basal_rate=0.8, 
+            correction_factor=30.0, 
+            carb_ratio=12.0, 
+            target_bg_mgdl=110.0), 
+        ProfileSegment(
+            display_time='6:00 AM', 
+            time='6:00 AM', 
+            basal_rate=1.25, 
+            correction_factor=30.0, 
+            carb_ratio=12.0, 
+            target_bg_mgdl=110.0), 
+        ProfileSegment(
+            display_time='11:00 AM', 
+            time='11:00 AM', 
+            basal_rate=1.0, 
+            correction_factor=30.0, 
+            carb_ratio=12.0, 
+            target_bg_mgdl=110.0), 
+        ProfileSegment(
+            display_time='Noon', 
+            time='12:00 PM', 
+            basal_rate=0.9, 
+            correction_factor=30.0, 
+            carb_ratio=12.0, 
+            target_bg_mgdl=110.0)
+    ],
+    calculated_total_daily_basal=22.85, 
+    insulin_duration_min=300, 
+    carbs_enabled=True
+)
+
+DEVICE_SETTINGS = DeviceSettings(
+    low_bg_threshold=80,
+    high_bg_threshold=200,
+    raw_settings={}
+)
+
+NS_PROFILE_A = {
+    "dia": "5.0",
+    "carbratio": [
+        {
+            "time": "00:00",
+            "timeAsSeconds": 0,
+            "value": 6.0
+        },
+        {
+            "time": "06:00",
+            "timeAsSeconds": 6*60*60,
+            "value": 6.0
+        },
+        {
+            "time": "11:00",
+            "timeAsSeconds": 11*60*60,
+            "value": 6.0
+        },
+        {
+            "time": "12:00",
+            "timeAsSeconds": 12*60*60,
+            "value": 6.0
+        }
+    ],
+
+    "carbs_hr": NIGHTSCOUT_PROFILE_CARBS_HR_VALUE,
+    "delay": NIGHTSCOUT_PROFILE_DELAY_VALUE,
+    "sens": [
+        {
+            "time": "00:00",
+            "timeAsSeconds": 0,
+            "value": 30.0
+        },
+        {
+            "time": "06:00",
+            "timeAsSeconds": 6*60*60,
+            "value": 30.0
+        },
+        {
+            "time": "11:00",
+            "timeAsSeconds": 11*60*60,
+            "value": 30.0
+        },
+        {
+            "time": "12:00",
+            "timeAsSeconds": 12*60*60,
+            "value": 30.0
+        }
+    ],
+    "basal": [
+        {
+            "time": "00:00",
+            "timeAsSeconds": 0,
+            "value": 0.8
+        },
+        {
+            "time": "06:00",
+            "timeAsSeconds": 6*60*60,
+            "value": 1.25
+        },
+        {
+            "time": "11:00",
+            "timeAsSeconds": 11*60*60,
+            "value": 1.0
+        },
+        {
+            "time": "12:00",
+            "timeAsSeconds": 12*60*60,
+            "value": 0.8
+        }
+    ],
+    "target_low": [
+        {
+            "time": "00:00",
+            "timeAsSeconds": 0,
+            "value": 80
+        }
+    ],
+    "target_high": [
+        {
+            "time": "00:00",
+            "timeAsSeconds": 0,
+            "value": 200
+        }
+    ],
+    "timezone": TIMEZONE_NAME,
+    "startDate": "1970-01-01T00:00:00.000Z",
+    "units": "mg/dl"
+}
+
+NS_PROFILE_B = {
+    "dia": "5.0",
+    "carbratio": [
+        {
+            "time": "00:00",
+            "timeAsSeconds": 0,
+            "value": 12.0
+        },
+        {
+            "time": "06:00",
+            "timeAsSeconds": 6*60*60,
+            "value": 12.0
+        },
+        {
+            "time": "11:00",
+            "timeAsSeconds": 11*60*60,
+            "value": 12.0
+        },
+        {
+            "time": "12:00",
+            "timeAsSeconds": 12*60*60,
+            "value": 12.0
+        }
+    ],
+
+    "carbs_hr": NIGHTSCOUT_PROFILE_CARBS_HR_VALUE,
+    "delay": NIGHTSCOUT_PROFILE_DELAY_VALUE,
+    "sens": [
+        {
+            "time": "00:00",
+            "timeAsSeconds": 0,
+            "value": 30.0
+        },
+        {
+            "time": "06:00",
+            "timeAsSeconds": 6*60*60,
+            "value": 30.0
+        },
+        {
+            "time": "11:00",
+            "timeAsSeconds": 11*60*60,
+            "value": 30.0
+        },
+        {
+            "time": "12:00",
+            "timeAsSeconds": 12*60*60,
+            "value": 30.0
+        }
+    ],
+    "basal": [
+        {
+            "time": "00:00",
+            "timeAsSeconds": 0,
+            "value": 0.8
+        },
+        {
+            "time": "06:00",
+            "timeAsSeconds": 6*60*60,
+            "value": 1.25
+        },
+        {
+            "time": "11:00",
+            "timeAsSeconds": 11*60*60,
+            "value": 1.0
+        },
+        {
+            "time": "12:00",
+            "timeAsSeconds": 12*60*60,
+            "value": 0.9
+        }
+    ],
+    "target_low": [
+        {
+            "time": "00:00",
+            "timeAsSeconds": 0,
+            "value": 80
+        }
+    ],
+    "target_high": [
+        {
+            "time": "00:00",
+            "timeAsSeconds": 0,
+            "value": 200
+        }
+    ],
+    "timezone": TIMEZONE_NAME,
+    "startDate": "1970-01-01T00:00:00.000Z",
+    "units": "mg/dl"
+}
+
+NS_PROFILE_STORE = {
+    'A': NS_PROFILE_A,
+    'B': NS_PROFILE_B
+}
+
+def build_ns_profile(profiles: Dict[str, dict], current_profile: str) -> dict:
+    return copy.deepcopy({
+        "store": profiles,
+        "defaultProfile": current_profile,
+        "startDate": "1970-01-01T00:00:00.000Z",
+        "mills": 0,
+        "units": "mg/dl",
+    })
+
+class TestCompareProfiles(unittest.TestCase):
+    maxDiff = None
+    def test_compare_profiles_identical_a(self):
+        pump_profiles = [DEVICE_PROFILE_A.activeProfile()]
+        ns_profile_obj = build_ns_profile({'A': NS_PROFILE_A}, 'A')
+
+        changed, new_profiles = compare_profiles(
+            pump_profiles,
+            DEVICE_SETTINGS,
+            ns_profile_obj
+        )
+
+        self.assertFalse(changed)
+        self.assertDictEqual(ns_profile_obj, new_profiles)
+
+        self.ensure_stabilized(pump_profiles, new_profiles)
+
+    def test_compare_profiles_identical_b(self):
+        pump_profiles = [DEVICE_PROFILE_B.activeProfile()]
+        ns_profile_obj = build_ns_profile({'B': NS_PROFILE_B}, 'B')
+
+        changed, new_profiles = compare_profiles(
+            pump_profiles,
+            DEVICE_SETTINGS,
+            ns_profile_obj
+        )
+
+        self.assertFalse(changed)
+        self.assertDictEqual(ns_profile_obj, new_profiles)
+
+        self.ensure_stabilized(pump_profiles, new_profiles)
+
+    def test_compare_profiles_extra_profile_in_nightscout_ignored(self):
+        pump_profiles = [DEVICE_PROFILE_A.activeProfile()]
+        ns_profile_obj = build_ns_profile({'A': NS_PROFILE_A, 'B': NS_PROFILE_B}, 'A')
+
+        changed, new_profiles = compare_profiles(
+            pump_profiles,
+            DEVICE_SETTINGS,
+            ns_profile_obj
+        )
+
+        self.assertFalse(changed)
+        self.assertDictEqual(ns_profile_obj, new_profiles)
+
+        self.ensure_stabilized(pump_profiles, new_profiles)
+
+    def test_compare_profiles_current_nightscout_profile_changed(self):
+        pump_profiles = [DEVICE_PROFILE_A.activeProfile()]
+        ns_profile_obj = build_ns_profile({'A': NS_PROFILE_A, 'B': NS_PROFILE_B}, 'B')
+
+        changed, new_profiles = compare_profiles(
+            pump_profiles,
+            DEVICE_SETTINGS,
+            ns_profile_obj
+        )
+
+        self.assertTrue(changed)
+        self.assertNotEqual(ns_profile_obj, new_profiles)
+
+        ns_profile_obj['defaultProfile'] = 'A'
+        self.assertDictEqual(ns_profile_obj, new_profiles)
+        
+        self.ensure_stabilized(pump_profiles, new_profiles)
+
+    def test_compare_profiles_new_pump_profile_added(self):
+        pump_profiles = [DEVICE_PROFILE_A.activeProfile(), DEVICE_PROFILE_B]
+        ns_profile_obj = build_ns_profile({'A': NS_PROFILE_A}, 'A')
+
+        changed, new_profiles = compare_profiles(
+            pump_profiles,
+            DEVICE_SETTINGS,
+            ns_profile_obj
+        )
+        
+        self.assertTrue(changed)
+        self.assertNotEqual(ns_profile_obj, new_profiles)
+        
+        ns_profile_obj['store']['B'] = new_profiles['store']['B']
+        self.assertDictEqual(ns_profile_obj, new_profiles)
+
+        self.ensure_stabilized(pump_profiles, new_profiles)
+
+    def test_compare_profiles_new_pump_profile_added_and_active(self):
+        pump_profiles = [DEVICE_PROFILE_A, DEVICE_PROFILE_B.activeProfile()]
+        ns_profile_obj = build_ns_profile({'A': NS_PROFILE_A}, 'A')
+
+        changed, new_profiles = compare_profiles(
+            pump_profiles,
+            DEVICE_SETTINGS,
+            ns_profile_obj
+        )
+        
+        self.assertTrue(changed)
+        self.assertNotEqual(ns_profile_obj, new_profiles)
+        
+        ns_profile_obj['store']['B'] = new_profiles['store']['B']
+        ns_profile_obj['defaultProfile'] = 'B'
+        self.assertDictEqual(ns_profile_obj, new_profiles)
+        
+        self.ensure_stabilized(pump_profiles, new_profiles)
+
+    def test_compare_profiles_existing_profile_edited_basal(self):
+        pump_profiles = [DEVICE_PROFILE_A.activeProfile()]
+        pump_profiles[0].segments[0].basal_rate = 0.1
+
+        ns_profile_obj = build_ns_profile({'A': NS_PROFILE_A}, 'A')
+
+        changed, new_profiles = compare_profiles(
+            pump_profiles,
+            DEVICE_SETTINGS,
+            ns_profile_obj
+        )
+        
+        self.assertTrue(changed)
+        self.assertNotEqual(ns_profile_obj, new_profiles)
+        
+        ns_profile_obj['store']['A']['basal'][0]['value'] = 0.1
+        self.assertDictEqual(ns_profile_obj, new_profiles)
+        
+        self.ensure_stabilized(pump_profiles, new_profiles)
+
+    def test_compare_profiles_existing_profile_edited_new_chunk(self):
+        pump_profiles = [DEVICE_PROFILE_A.activeProfile()]
+        pump_profiles[0].segments.append(ProfileSegment(
+            display_time='06:00 PM', 
+            time='06:00 PM', 
+            basal_rate=0.7, 
+            correction_factor=30.0, 
+            carb_ratio=6.0,
+            target_bg_mgdl=110.0)
+        )
+
+        ns_profile_obj = build_ns_profile({'A': NS_PROFILE_A}, 'A')
+
+        changed, new_profiles = compare_profiles(
+            pump_profiles,
+            DEVICE_SETTINGS,
+            ns_profile_obj
+        )
+        
+        self.assertTrue(changed)
+        self.assertNotEqual(ns_profile_obj, new_profiles)
+        
+        ns_profile_obj['store']['A']['basal'].append({'time': '18:00', 'timeAsSeconds': 18*60*60, 'value': 0.7})
+        ns_profile_obj['store']['A']['carbratio'].append({'time': '18:00', 'timeAsSeconds': 18*60*60, 'value': 6})
+        ns_profile_obj['store']['A']['sens'].append({'time': '18:00', 'timeAsSeconds': 18*60*60, 'value': 30})
+        self.assertDictEqual(ns_profile_obj, new_profiles)
+        
+        self.ensure_stabilized(pump_profiles, new_profiles)
+
+    def test_compare_profiles_existing_profile_edited_removed_chunk(self):
+        pump_profiles = [DEVICE_PROFILE_A.activeProfile()]
+        pump_profiles[0].segments.pop()
+
+        ns_profile_obj = build_ns_profile({'A': NS_PROFILE_A}, 'A')
+
+        changed, new_profiles = compare_profiles(
+            pump_profiles,
+            DEVICE_SETTINGS,
+            ns_profile_obj
+        )
+        
+        self.assertTrue(changed)
+        self.assertNotEqual(ns_profile_obj, new_profiles)
+        
+        ns_profile_obj['store']['A']['basal'].pop()
+        ns_profile_obj['store']['A']['carbratio'].pop()
+        ns_profile_obj['store']['A']['sens'].pop()
+        self.assertDictEqual(ns_profile_obj, new_profiles)
+        
+        self.ensure_stabilized(pump_profiles, new_profiles)
+    
+    def ensure_stabilized(self, pump_profiles, new_profiles):
+        changed, _ = compare_profiles(
+            pump_profiles,
+            DEVICE_SETTINGS,
+            new_profiles
+        )
+        self.assertFalse(changed, 'did not stabilize')
+
+class TestNightscoutProfilesIdentical(unittest.TestCase):
+    def test_same_dict(self):
+        self.assertTrue(nightscout_profiles_identical(NS_PROFILE_A, NS_PROFILE_A))
+
+    def test_different_dict(self):
+        self.assertFalse(nightscout_profiles_identical(NS_PROFILE_A, NS_PROFILE_B))
+
+    def test_same_re_jsoned(self):
+        self.assertTrue(nightscout_profiles_identical(NS_PROFILE_A, json.loads(json.dumps(NS_PROFILE_A))))
+
+    def test_same_different_number_types(self):
+        a = b = json.loads(json.dumps(NS_PROFILE_A))
+        a['dia'] = 5
+        b = json.loads(json.dumps(NS_PROFILE_A))
+        b['dia'] = 5.0
+        self.assertTrue(nightscout_profiles_identical(a, b))
+
+    def test_same_different_number_strings_1(self):
+        a = b = json.loads(json.dumps(NS_PROFILE_A))
+        a['dia'] = 5
+        b = json.loads(json.dumps(NS_PROFILE_A))
+        b['dia'] = '5.0'
+        self.assertTrue(nightscout_profiles_identical(a, b))
+
+    def test_same_different_number_strings_2(self):
+        a = b = json.loads(json.dumps(NS_PROFILE_A))
+        a['dia'] = '5'
+        b = json.loads(json.dumps(NS_PROFILE_A))
+        b['dia'] = 5.0
+        self.assertTrue(nightscout_profiles_identical(a, b))
+
+    def test_same_different_number_strings_3(self):
+        a = b = json.loads(json.dumps(NS_PROFILE_A))
+        a['dia'] = '5'
+        b = json.loads(json.dumps(NS_PROFILE_A))
+        b['dia'] = '5.000'
+        self.assertTrue(nightscout_profiles_identical(a, b))
+
+    def test_different_numbers(self):
+        a = b = json.loads(json.dumps(NS_PROFILE_A))
+        a['dia'] = 5
+        b = json.loads(json.dumps(NS_PROFILE_A))
+        b['dia'] = 5.1
+        self.assertFalse(nightscout_profiles_identical(a, b))
+
+    def test_different_numbers_strings(self):
+        a = b = json.loads(json.dumps(NS_PROFILE_A))
+        a['dia'] = '5'
+        b = json.loads(json.dumps(NS_PROFILE_A))
+        b['dia'] = '5.01'
+        self.assertFalse(nightscout_profiles_identical(a, b))
+
+if __name__ == '__main__':
+    unittest.main()
@@ -0,0 +1,149 @@
+#!/usr/bin/env python3
+
+import json
+import unittest
+from typing import Dict
+import copy
+
+from tconnectsync.sync.pump_events import ns_write_pump_events
+
+from ..nightscout_fake import NightscoutApi
+
+
+def _stub_last_uploaded_entry(eventType, time_start=None, time_end=None):
+    return None
+
+class TestNsWritePumpEvents(unittest.TestCase):
+
+    SITE_CHANGE_EVENT = {'time': '2024-02-04 16:27:50-05:00', 'event_type': 'Site/Cartridge Change'}
+    SITE_CHANGE_NS = {'created_at': '2024-02-04 16:27:50-05:00', 'enteredBy': 'Pump (tconnectsync)', 'eventType': 'Site Change', 'notes': 'Site/Cartridge Change','reason': 'Site/Cartridge Change', 'pump_event_id': ''}
+    def test_write_single_sitechange_event(self):
+        nightscout = NightscoutApi()
+        nightscout.last_uploaded_entry = _stub_last_uploaded_entry
+        ns_write_pump_events(nightscout, [
+            self.SITE_CHANGE_EVENT
+        ])
+
+        self.assertDictEqual({
+            'treatments': [
+                self.SITE_CHANGE_NS
+            ]
+        }, dict(nightscout.uploaded_entries))
+
+    EMPTY_CART_EVENT = {'time': '2024-05-14 09:01:59-04:00', 'event_type': 'Empty Cartridge/Pump Shutdown'}
+    EMPTY_CART_NS = {'created_at': '2024-05-14 09:01:59-04:00', 'enteredBy': 'Pump (tconnectsync)', 'eventType': 'Basal Suspension', 'notes': 'Empty Cartridge/Pump Shutdown', 'reason': 'Empty Cartridge/Pump Shutdown', 'pump_event_id': ''}
+    def test_write_single_emptycart_event(self):
+        nightscout = NightscoutApi()
+        nightscout.last_uploaded_entry = _stub_last_uploaded_entry
+        ns_write_pump_events(nightscout, [
+            self.EMPTY_CART_EVENT
+        ])
+
+        self.assertDictEqual({
+            'treatments': [
+                self.EMPTY_CART_NS
+            ]
+        }, dict(nightscout.uploaded_entries))
+
+    USER_SUSPENDED_EVENT = {'time': '2024-02-05 09:48:22-05:00', 'event_type': 'User Suspended'}
+    USER_SUSPENDED_NS = {'created_at': '2024-02-05 09:48:22-05:00', 'enteredBy': 'Pump (tconnectsync)', 'eventType': 'Basal Suspension', 'notes': 'User Suspended', 'reason': 'User Suspended', 'pump_event_id': ''}
+    def test_write_single_usersuspended_event(self):
+        nightscout = NightscoutApi()
+        nightscout.last_uploaded_entry = _stub_last_uploaded_entry
+        ns_write_pump_events(nightscout, [
+            self.USER_SUSPENDED_EVENT
+        ])
+
+        self.assertDictEqual({
+            'treatments': [
+                self.USER_SUSPENDED_NS
+            ]
+        }, dict(nightscout.uploaded_entries))
+
+    EXERCISE_EVENT = {'time': '2024-03-10 08:53:20-04:00', 'duration_mins': 269.3833333333333, 'event_type': 'Exercise'}
+    EXERCISE_NS = {'created_at': '2024-03-10 08:53:20-04:00', 'duration': 269.3833333333333, 'enteredBy': 'Pump (tconnectsync)', 'eventType': 'Exercise', 'notes': 'Exercise', 'reason': 'Exercise', 'pump_event_id': ''}
+    EXERCISE_EXTENDED_EVENT = {'time': '2024-03-10 08:53:20-04:00', 'duration_mins': 585.8833333333333, 'event_type': 'Exercise'}
+    EXERCISE_EXTENDED_NS = {'created_at': '2024-03-10 08:53:20-04:00', 'duration': 585.8833333333333, 'enteredBy': 'Pump (tconnectsync)', 'eventType': 'Exercise', 'notes': 'Exercise', 'reason': 'Exercise', 'pump_event_id': ''}
+    def test_write_exercise_events(self):
+        nightscout = NightscoutApi()
+        nightscout.last_uploaded_entry = _stub_last_uploaded_entry
+        ns_write_pump_events(nightscout, [
+            self.EXERCISE_EVENT
+        ])
+
+        self.assertDictEqual({
+            'treatments': [
+                self.EXERCISE_NS
+            ]
+        }, dict(nightscout.uploaded_entries))
+
+        _id = 'exercise_id'
+        def _last_uploaded_entry(eventType, time_start=None, time_end=None):
+            if eventType == 'Exercise':
+                return {
+                    '_id': _id,
+                    **self.EXERCISE_NS
+                }
+
+        nightscout.last_uploaded_entry = _last_uploaded_entry
+
+        ns_write_pump_events(nightscout, [
+            self.EXERCISE_EXTENDED_EVENT
+        ])
+
+        self.assertListEqual([
+            'treatments/%s' % _id
+        ], nightscout.deleted_entries)
+
+        self.assertDictEqual({
+            'treatments': [
+                self.EXERCISE_NS,
+                self.EXERCISE_EXTENDED_NS
+            ]
+        }, dict(nightscout.uploaded_entries))
+
+    SLEEP_EVENT = {'time': '2024-02-07 00:00:19-05:00', 'duration_mins': 13.916666666666666, 'event_type': 'Sleep'}
+    SLEEP_NS = {'created_at': '2024-02-07 00:00:19-05:00', 'duration': 13.916666666666666, 'enteredBy': 'Pump (tconnectsync)', 'eventType': 'Sleep', 'notes': 'Sleep', 'reason': 'Sleep', 'pump_event_id': ''}
+    SLEEP_EXTENDED_EVENT = {'time': '2024-02-07 00:00:19-05:00', 'duration_mins': 74.0, 'event_type': 'Sleep'}
+    SLEEP_EXTENDED_NS = {'created_at': '2024-02-07 00:00:19-05:00', 'duration': 74.0, 'enteredBy': 'Pump (tconnectsync)', 'eventType': 'Sleep', 'notes': 'Sleep', 'reason': 'Sleep', 'pump_event_id': ''}
+    def test_write_sleep_events(self):
+        nightscout = NightscoutApi()
+        nightscout.last_uploaded_entry = _stub_last_uploaded_entry
+        ns_write_pump_events(nightscout, [
+            self.SLEEP_EVENT
+        ])
+
+        self.assertDictEqual({
+            'treatments': [
+                self.SLEEP_NS
+            ]
+        }, dict(nightscout.uploaded_entries))
+
+        _id = 'sleep_id'
+        def _last_uploaded_entry(eventType, time_start=None, time_end=None):
+            if eventType == 'Sleep':
+                return {
+                    '_id': _id,
+                    **self.SLEEP_NS
+                }
+
+        nightscout.last_uploaded_entry = _last_uploaded_entry
+
+        ns_write_pump_events(nightscout, [
+            self.SLEEP_EXTENDED_EVENT
+        ])
+
+        self.assertListEqual([
+            'treatments/%s' % _id
+        ], nightscout.deleted_entries)
+
+        self.assertDictEqual({
+            'treatments': [
+                self.SLEEP_NS,
+                self.SLEEP_EXTENDED_NS
+            ]
+        }, dict(nightscout.uploaded_entries))
+
+
+if __name__ == '__main__':
+    unittest.main()
@@ -0,0 +1,368 @@
+#!/usr/bin/env python3
+
+import logging
+import unittest
+import datetime
+import contextlib
+
+from unittest.mock import patch
+
+from tconnectsync.autoupdate import Autoupdate, AutoupdateFailureError, AutoupdateFailureWarning, AutoupdateNoEventIndexesDetectedError, AutoupdateNoIndexChangeWarning
+
+from .api.fake import TConnectApi
+from .nightscout_fake import NightscoutApi
+from .secrets import build_secrets
+
+logger = logging.getLogger(__name__)
+
+def stub(*args, **kwargs):
+    pass
+
+@contextlib.contextmanager
+def build_mock_logger():
+    def fake_error(*args, **kwargs):
+        logger.error(*args, **kwargs)
+    
+    def fake_warn(*args, **kwargs):
+        logger.warning(*args, **kwargs)
+        
+    with patch("tconnectsync.autoupdate.logger.error") as mock_error, patch("tconnectsync.autoupdate.logger.warning") as mock_warn:
+        mock_error.side_effect = fake_error
+        mock_warn.side_effect = fake_warn
+        yield (mock_error, mock_warn)
+
+def num_instances_of(cls, m):
+    return sum([isinstance(i[0][0], cls) for i in m.call_args_list])
+
+class TestAutoupdate(unittest.TestCase):
+    maxDiff = None
+
+    # datetimes are unused
+    start = datetime.datetime(2021, 4, 20, 12, 0)
+    end = datetime.datetime(2021, 4, 21, 12, 0)
+
+    # each time the returned function is called, it returns the next argument
+    # until the end is reached, at which point it will repeat the last argument
+    def fake_last_event_uploaded(self, *indexes):
+        index = 0
+        def fake(*args, **kwargs):
+            nonlocal index
+            if index < len(indexes):
+                index += 1
+            data = {'maxPumpEventIndex': indexes[index-1], 'processingStatus': 1}
+            return data
+        
+        return fake
+
+    # each time the returned function is called, it returns the next argument
+    # until the end is reached, at which point it will repeat the last argument
+    def fake_process_time_range(self, *returns):
+        index = 0
+        def fake(*args, **kwargs):
+            nonlocal index
+            if index < len(returns):
+                index += 1
+            return returns[index - 1]
+        
+        return fake
+    
+    """process_time_range should always be invoked the first time"""
+    def test_process_time_range_called_on_start(self):
+        tconnect = TConnectApi()
+        tconnect._android.last_event_uploaded = self.fake_last_event_uploaded(1)
+
+        nightscout = NightscoutApi()
+
+        secret = build_secrets(
+            AUTOUPDATE_MAX_LOOP_INVOCATIONS=1,
+            AUTOUPDATE_USE_FIXED_SLEEP=True,
+            AUTOUPDATE_DEFAULT_SLEEP_SECONDS=0
+        )
+
+        with patch("tconnectsync.autoupdate.process_time_range") as mock_process_time_range:
+            mock_process_time_range.return_value = 0
+
+            u = Autoupdate(secret)
+            ret = u.process(tconnect, nightscout, self.start, self.end, pretend=False)
+            self.assertEqual(ret, 0)
+
+            self.assertEqual(mock_process_time_range.call_count, 1)
+            self.assertEqual(u.autoupdate_invocations, 1)
+            self.assertEqual(u.last_event_index, 1)
+
+
+    """process_time_range should never be called with pretend"""
+    def test_process_time_range_never_called_with_pretend(self):
+        tconnect = TConnectApi()
+        tconnect._android.last_event_uploaded = self.fake_last_event_uploaded(1)
+
+        nightscout = NightscoutApi()
+
+
+        secret = build_secrets(
+            AUTOUPDATE_MAX_LOOP_INVOCATIONS=1,
+            AUTOUPDATE_USE_FIXED_SLEEP=True,
+            AUTOUPDATE_DEFAULT_SLEEP_SECONDS=0
+        )
+
+        with patch("tconnectsync.autoupdate.process_time_range") as mock_process_time_range:
+            mock_process_time_range.return_value = 0
+
+            u = Autoupdate(secret)
+            ret = u.process(tconnect, nightscout, self.start, self.end, pretend=True)
+            self.assertEqual(ret, 0)
+
+            self.assertEqual(mock_process_time_range.call_count, 0)
+            self.assertEqual(u.autoupdate_invocations, 1)
+            self.assertEqual(u.last_event_index, 1)
+    
+
+    """
+    If the event index increases without process_time_range detecting new data,
+    AutoupdateFailureWarning should be raised.
+    """
+    def test_autoupdate_failure_warning_on_index_process_time_range_discrepancy(self):
+        tconnect = TConnectApi()
+        tconnect._android.last_event_uploaded = self.fake_last_event_uploaded(1, 2)
+
+        nightscout = NightscoutApi()
+
+        secret = build_secrets(
+            AUTOUPDATE_MAX_LOOP_INVOCATIONS=2,
+            AUTOUPDATE_USE_FIXED_SLEEP=True,
+            AUTOUPDATE_DEFAULT_SLEEP_SECONDS=0,
+            TCONNECT_EMAIL="test@email.com",
+            TCONNECT_PASSWORD="testpassword"
+        )
+
+        with patch("tconnectsync.autoupdate.process_time_range") as mock_process_time_range, build_mock_logger() as (mock_error, mock_warn):
+            mock_process_time_range.side_effect = self.fake_process_time_range(0, 0)
+
+            u = Autoupdate(secret)
+            ret = u.process(tconnect, nightscout, self.start, self.end, pretend=False)
+            self.assertEqual(ret, 0)
+
+            self.assertEqual(mock_process_time_range.call_count, 2)
+            self.assertEqual(u.autoupdate_invocations, 2)
+            self.assertEqual(u.last_event_index, 2)
+
+            self.assertEqual(num_instances_of(AutoupdateFailureWarning, mock_warn), 1)
+
+    """
+    On the first attempt, an AutoupdateFailureWarning should never be raised.
+    """
+    def test_autoupdate_no_failure_warning_on_index_process_time_range_discrepancy_first_attempt(self):
+        tconnect = TConnectApi()
+        tconnect._android.last_event_uploaded = self.fake_last_event_uploaded(1)
+
+        nightscout = NightscoutApi()
+
+        secret = build_secrets(
+            AUTOUPDATE_MAX_LOOP_INVOCATIONS=1,
+            AUTOUPDATE_USE_FIXED_SLEEP=True,
+            AUTOUPDATE_DEFAULT_SLEEP_SECONDS=0
+        )
+
+        with patch("tconnectsync.autoupdate.process_time_range") as mock_process_time_range, build_mock_logger() as (mock_error, mock_warn):
+            mock_process_time_range.side_effect = self.fake_process_time_range(0, 0)
+
+            u = Autoupdate(secret)
+            ret = u.process(tconnect, nightscout, self.start, self.end, pretend=False)
+            self.assertEqual(ret, 0)
+
+            self.assertEqual(mock_process_time_range.call_count, 1)
+            self.assertEqual(u.autoupdate_invocations, 1)
+            self.assertEqual(u.last_event_index, 1)
+
+            self.assertEqual(num_instances_of(AutoupdateFailureWarning, mock_warn), 0)
+
+
+    """
+    If the event index increases without process_time_range detecting new data
+    for AUTOUPDATE_FAILURE_MINUTES, an AutoupdateFailureError should be raised.
+    """
+    def test_autoupdate_failure_error_on_index_process_time_range_discrepancy_for_failure_minutes(self):
+        tconnect = TConnectApi()
+        tconnect._android.last_event_uploaded = self.fake_last_event_uploaded(1, 2)
+
+        nightscout = NightscoutApi()
+
+        secret = build_secrets(
+            AUTOUPDATE_MAX_LOOP_INVOCATIONS=2,
+            AUTOUPDATE_USE_FIXED_SLEEP=True,
+            AUTOUPDATE_DEFAULT_SLEEP_SECONDS=0,
+            AUTOUPDATE_FAILURE_MINUTES=0,
+            AUTOUPDATE_RESTART_ON_FAILURE=False,
+        )
+
+        with patch("tconnectsync.autoupdate.process_time_range") as mock_process_time_range, build_mock_logger() as (mock_error, mock_warn):
+            mock_process_time_range.side_effect = self.fake_process_time_range(0, 0)
+
+            u = Autoupdate(secret)
+            ret = u.process(tconnect, nightscout, self.start, self.end, pretend=False)
+            self.assertEqual(ret, 0)
+
+            self.assertEqual(mock_process_time_range.call_count, 2)
+            self.assertEqual(u.autoupdate_invocations, 2)
+            self.assertEqual(u.last_event_index, 2)
+
+            self.assertEqual(num_instances_of(AutoupdateFailureError, mock_error), 1)
+            
+    """
+    If the event index increases without process_time_range detecting new data
+    for AUTOUPDATE_FAILURE_MINUTES, and AUTOUPDATE_RESTART_ON_FAILURE is true,
+    then an AutoupdateFailureError should be raised AND 1 should be returned.
+    """
+    def test_autoupdate_failure_error_on_index_process_time_range_discrepancy_for_failure_minutes_performs_restart(self):
+        tconnect = TConnectApi()
+        tconnect._android.last_event_uploaded = self.fake_last_event_uploaded(1, 2)
+
+        nightscout = NightscoutApi()
+
+        secret = build_secrets(
+            AUTOUPDATE_MAX_LOOP_INVOCATIONS=3,
+            AUTOUPDATE_USE_FIXED_SLEEP=True,
+            AUTOUPDATE_DEFAULT_SLEEP_SECONDS=0,
+            AUTOUPDATE_FAILURE_MINUTES=0,
+            AUTOUPDATE_RESTART_ON_FAILURE=True,
+        )
+
+        with patch("tconnectsync.autoupdate.process_time_range") as mock_process_time_range, build_mock_logger() as (mock_error, mock_warn):
+            mock_process_time_range.side_effect = self.fake_process_time_range(0, 0)
+
+            u = Autoupdate(secret)
+            ret = u.process(tconnect, nightscout, self.start, self.end, pretend=False)
+            self.assertEqual(ret, 1)
+
+            self.assertEqual(mock_process_time_range.call_count, 2)
+            self.assertEqual(u.autoupdate_invocations, 1) # exits before invocations is incremented
+            self.assertEqual(u.last_event_index, 1) # exits before changed to 2
+
+            self.assertEqual(num_instances_of(AutoupdateFailureError, mock_error), 1)
+
+
+    """Validate state after first successful update"""
+    def test_state_after_first_successful_update(self):
+        tconnect = TConnectApi()
+        tconnect._android.last_event_uploaded = self.fake_last_event_uploaded(1)
+
+        nightscout = NightscoutApi()
+
+        secret = build_secrets(
+            AUTOUPDATE_MAX_LOOP_INVOCATIONS=1,
+            AUTOUPDATE_USE_FIXED_SLEEP=True,
+            AUTOUPDATE_DEFAULT_SLEEP_SECONDS=0
+        )
+
+        with patch("tconnectsync.autoupdate.process_time_range") as mock_process_time_range:
+            mock_process_time_range.side_effect = self.fake_process_time_range(1)
+
+            u = Autoupdate(secret)
+            ret = u.process(tconnect, nightscout, self.start, self.end, pretend=False)
+            self.assertEqual(ret, 0)
+
+            self.assertEqual(mock_process_time_range.call_count, 1)
+            self.assertEqual(u.autoupdate_invocations, 1)
+            self.assertEqual(u.last_event_index, 1)
+            self.assertTrue(u.last_event_time == u.last_attempt_time == u.last_successful_process_time_range)
+            self.assertEqual(len(u.time_diffs_between_updates), 0)
+
+    """Validate sleep occurs for the given fixed length when set"""
+    def test_sleep_for_fixed_length_when_set(self):
+        tconnect = TConnectApi()
+        tconnect._android.last_event_uploaded = self.fake_last_event_uploaded(1)
+
+        nightscout = NightscoutApi()
+
+        sleep_length = 3 # sentinel
+        secret = build_secrets(
+            AUTOUPDATE_MAX_LOOP_INVOCATIONS=1,
+            AUTOUPDATE_USE_FIXED_SLEEP=True,
+            AUTOUPDATE_DEFAULT_SLEEP_SECONDS=sleep_length
+        )
+
+        with patch("tconnectsync.autoupdate.process_time_range") as mock_process_time_range, patch("tconnectsync.autoupdate.time.sleep") as mock_sleep:
+            mock_process_time_range.side_effect = self.fake_process_time_range(1)
+            mock_sleep.side_effect = None
+
+            u = Autoupdate(secret)
+            ret = u.process(tconnect, nightscout, self.start, self.end, pretend=False)
+            self.assertEqual(ret, 0)
+
+            self.assertEqual(mock_process_time_range.call_count, 1)
+            self.assertEqual(u.autoupdate_invocations, 1)
+            self.assertEqual(u.last_event_index, 1)
+            self.assertTrue(mock_sleep.called)
+            self.assertEqual(mock_sleep.call_args[0], (sleep_length,))
+
+
+    """
+    If there is no event index update for AUTOUPDATE_NO_DATA_FAILURE_MINUTES, 
+    then a AutoupdateNoEventIndexesDetectedError should be raised and
+    a restart should be triggered with AUTOUPDATE_RESTART_ON_FAILURE.
+    """
+    def test_autoupdate_no_event_indexes_detected_error_on_no_index_change_less_than_three_iterations(self):
+        tconnect = TConnectApi()
+        tconnect._android.last_event_uploaded = self.fake_last_event_uploaded(1)
+
+        nightscout = NightscoutApi()
+
+        secret = build_secrets(
+            AUTOUPDATE_MAX_LOOP_INVOCATIONS=100,
+            AUTOUPDATE_USE_FIXED_SLEEP=True,
+            AUTOUPDATE_DEFAULT_SLEEP_SECONDS=0.1,
+            AUTOUPDATE_UNEXPECTED_NO_INDEX_SLEEP_SECONDS=0.2,
+            AUTOUPDATE_RESTART_ON_FAILURE=True,
+            AUTOUPDATE_NO_DATA_FAILURE_MINUTES=1/600 # 0.1 second
+        )
+
+        # with more than 3 iterations, the sleep iteration will change
+
+        with patch("tconnectsync.autoupdate.process_time_range") as mock_process_time_range, build_mock_logger() as (mock_error, mock_warn):
+            mock_process_time_range.side_effect = self.fake_process_time_range(1, 0)
+
+            u = Autoupdate(secret)
+            ret = u.process(tconnect, nightscout, self.start, self.end, pretend=False)
+            self.assertEqual(ret, 1)
+
+            self.assertEqual(num_instances_of(AutoupdateNoEventIndexesDetectedError, mock_error), 1)
+
+
+    """
+    If there has been 3 failed attempts since the last time we found new data,
+    we should sleep for AUTOUPDATE_UNEXPECTED_NO_INDEX_SLEEP_SECONDS and
+    a AutoupdateNoIndexChangeWarning should be logged.
+    """
+    def test_autoupdate_no_index_change_warning_on_unexpected_no_index_sleep(self):
+        tconnect = TConnectApi()
+        tconnect._android.last_event_uploaded = self.fake_last_event_uploaded(1)
+
+        nightscout = NightscoutApi()
+
+        secret = build_secrets(
+            AUTOUPDATE_MAX_LOOP_INVOCATIONS=5,
+            AUTOUPDATE_USE_FIXED_SLEEP=True,
+            AUTOUPDATE_DEFAULT_SLEEP_SECONDS=0.1,
+            AUTOUPDATE_UNEXPECTED_NO_INDEX_SLEEP_SECONDS=0.2
+        )
+
+        with patch("tconnectsync.autoupdate.process_time_range") as mock_process_time_range, patch("tconnectsync.autoupdate.time.sleep") as mock_sleep, build_mock_logger() as (mock_error, mock_warn):
+            mock_process_time_range.side_effect = self.fake_process_time_range(0)
+            mock_sleep.side_effect = None
+
+            u = Autoupdate(secret)
+            ret = u.process(tconnect, nightscout, self.start, self.end, pretend=False)
+            self.assertEqual(ret, 0)
+
+            self.assertEqual(u.autoupdate_invocations, 5)
+            self.assertEqual(u.last_event_index, 1)
+            self.assertTrue(mock_sleep.called)
+            self.assertEqual(len(mock_sleep.call_args_list), 5)
+            self.assertEqual(mock_sleep.call_args_list[0][0], (0.1,))
+            self.assertEqual(mock_sleep.call_args_list[1][0], (0.1,))
+            self.assertEqual(mock_sleep.call_args_list[2][0], (0.1,))
+            self.assertEqual(mock_sleep.call_args_list[3][0], (0.2,))
+            self.assertEqual(mock_sleep.call_args_list[4][0], (0.2,))
+
+            self.assertEqual(num_instances_of(AutoupdateNoIndexChangeWarning, mock_warn), 2)
+
@@ -3,20 +3,34 @@
 import unittest
 import datetime
 import pprint
+import copy
+from unittest.mock import patch

 from tconnectsync.process import process_time_range
-from tconnectsync.parser.nightscout import NightscoutEntry
+from tconnectsync.parser.nightscout import EXERCISE_EVENTTYPE, IOB_ACTIVITYTYPE, SLEEP_EVENTTYPE, NightscoutEntry
+from tconnectsync.features import BASAL, BOLUS, IOB, PROFILES, PUMP_EVENTS, PUMP_EVENTS_BASAL_SUSPENSION
+from tconnectsync.domain.device_settings import Device
+from tests.secrets import build_secrets
+from tests.sync.test_profile import DEVICE_PROFILE_A, DEVICE_PROFILE_B, DEVICE_SETTINGS, NS_PROFILE_A, NS_PROFILE_B, build_ns_profile
+

 from .api.fake import TConnectApi
 from .nightscout_fake import NightscoutApi
 from .sync.test_basal import TestBasalSync
 from .sync.test_bolus import TestBolusSync
+from .sync.test_iob import TestIOBSync
+from .domain.test_therapy_event import BOLUS_FULL_EXAMPLES, TestCGMTherapyEvent

 class TestProcessTimeRange(unittest.TestCase):
    maxDiff = None

    def stub_therapy_timeline(self, time_start, time_end):
-        pass
+        return copy.deepcopy(TestBasalSync.base)
+
+    def stub_ciq_therapy_events(self, time_start, time_end):
+        return {
+            "event": []
+        }

    def stub_therapy_timeline_csv(self, time_start, time_end):
        return {
@@ -26,16 +40,20 @@ class TestProcessTimeRange(unittest.TestCase):
            "bolusData": []
        }

-    def stub_last_uploaded_entry(self, event_type):
+    def stub_ws2_basalsuspension(self, time_start, time_end):
+        return {"BasalSuspension": []}
+
+    def stub_last_uploaded_entry(self, event_type, **kwargs):
        return None

-    def stub_last_uploaded_activity(self, activity_type):
+    def stub_last_uploaded_activity(self, activity_type, **kwargs):
        return None

    """No data in Nightscout. Uploads all basal data from tconnect."""
    def test_new_ciq_basal_data(self):
        tconnect = TConnectApi()

+        # datetimes are unused by the API fake
        start = datetime.datetime(2021, 4, 20, 12, 0)
        end = datetime.datetime(2021, 4, 21, 12, 0)

@@ -46,6 +64,7 @@ class TestProcessTimeRange(unittest.TestCase):
            return TestBasalSync.get_example_ciq_basal_events()

        tconnect.controliq.therapy_timeline = fake_therapy_timeline
+        tconnect.controliq.therapy_events = self.stub_ciq_therapy_events
        tconnect.ws2.therapy_timeline_csv = self.stub_therapy_timeline_csv

        nightscout = NightscoutApi()
@@ -53,7 +72,7 @@ class TestProcessTimeRange(unittest.TestCase):
        nightscout.last_uploaded_entry = self.stub_last_uploaded_entry
        nightscout.last_uploaded_activity = self.stub_last_uploaded_activity

-        process_time_range(tconnect, nightscout, start, end, pretend=False)
+        count = process_time_range(tconnect, nightscout, start, end, pretend=False, features=[BOLUS, BASAL])

        self.assertEqual(len(nightscout.uploaded_entries["treatments"]), 4)
        self.assertDictEqual(dict(nightscout.uploaded_entries), {
@@ -61,16 +80,17 @@ class TestProcessTimeRange(unittest.TestCase):
                NightscoutEntry.basal(0.8, 20.35, "2021-03-16 00:00:00-04:00", reason="tempDelivery"),
                NightscoutEntry.basal(0.799, 5.0, "2021-03-16 00:20:21-04:00", reason="profileDelivery"),
                NightscoutEntry.basal(0.797, 5.0, "2021-03-16 00:25:21-04:00", reason="algorithmDelivery"),
-                NightscoutEntry.basal(0, 2693/60, "2021-03-16 00:30:21-04:00", reason="algorithmDelivery")
+                NightscoutEntry.basal(0, 2693/60, "2021-03-16 00:30:21-04:00", reason="algorithmDelivery (control-iq suspension)")
        ]})
        self.assertDictEqual(nightscout.put_entries, {})
-        self.assertDictEqual(nightscout.deleted_entries, {})
+        self.assertListEqual(nightscout.deleted_entries, [])
+        self.assertEqual(count, 4)

-
-    """Two basal entries in Nightscout. Two new basal entries in tconnect."""
-    def test_partial_ciq_basal_data(self):
+    """No data in Nightscout. Nothing should be updated in Nightscout without the BASAL feature."""
+    def test_basal_data_not_updated_without_feature(self):
        tconnect = TConnectApi()

+        # datetimes are unused by the API fake
        start = datetime.datetime(2021, 4, 20, 12, 0)
        end = datetime.datetime(2021, 4, 21, 12, 0)

@@ -81,11 +101,42 @@ class TestProcessTimeRange(unittest.TestCase):
            return TestBasalSync.get_example_ciq_basal_events()

        tconnect.controliq.therapy_timeline = fake_therapy_timeline
+        tconnect.controliq.therapy_events = self.stub_ciq_therapy_events
        tconnect.ws2.therapy_timeline_csv = self.stub_therapy_timeline_csv

        nightscout = NightscoutApi()

-        def fake_last_uploaded_entry(event_type):
+        nightscout.last_uploaded_entry = self.stub_last_uploaded_entry
+        nightscout.last_uploaded_activity = self.stub_last_uploaded_activity
+
+        count = process_time_range(tconnect, nightscout, start, end, pretend=False, features=[BOLUS, IOB])
+
+        self.assertEqual(len(nightscout.uploaded_entries["treatments"]), 0)
+        self.assertDictEqual(nightscout.put_entries, {})
+        self.assertListEqual(nightscout.deleted_entries, [])
+        self.assertEqual(count, 0)
+
+    """Two basal entries in Nightscout. Two new basal entries in tconnect."""
+    def test_partial_ciq_basal_data(self):
+        tconnect = TConnectApi()
+
+        # datetimes are unused by the API fake
+        start = datetime.datetime(2021, 4, 20, 12, 0)
+        end = datetime.datetime(2021, 4, 21, 12, 0)
+
+        def fake_therapy_timeline(time_start, time_end):
+            self.assertEqual(time_start, start)
+            self.assertEqual(time_end, end)
+
+            return TestBasalSync.get_example_ciq_basal_events()
+
+        tconnect.controliq.therapy_timeline = fake_therapy_timeline
+        tconnect.controliq.therapy_events = self.stub_ciq_therapy_events
+        tconnect.ws2.therapy_timeline_csv = self.stub_therapy_timeline_csv
+
+        nightscout = NightscoutApi()
+
+        def fake_last_uploaded_entry(event_type, **kwargs):
            if event_type == "Temp Basal":
                return {
                    "created_at": "2021-03-16 00:20:21-04:00",
@@ -95,16 +146,17 @@ class TestProcessTimeRange(unittest.TestCase):
        nightscout.last_uploaded_entry = fake_last_uploaded_entry
        nightscout.last_uploaded_activity = self.stub_last_uploaded_activity

-        process_time_range(tconnect, nightscout, start, end, pretend=False)
+        count = process_time_range(tconnect, nightscout, start, end, pretend=False, features=[BOLUS, BASAL])

        self.assertEqual(len(nightscout.uploaded_entries["treatments"]), 2)
        self.assertDictEqual(dict(nightscout.uploaded_entries), {
            "treatments": [
                NightscoutEntry.basal(0.797, 5.0, "2021-03-16 00:25:21-04:00", reason="algorithmDelivery"),
-                NightscoutEntry.basal(0, 2693/60, "2021-03-16 00:30:21-04:00", reason="algorithmDelivery")
+                NightscoutEntry.basal(0, 2693/60, "2021-03-16 00:30:21-04:00", reason="algorithmDelivery (control-iq suspension)")
        ]})
        self.assertDictEqual(nightscout.put_entries, {})
-        self.assertDictEqual(nightscout.deleted_entries, {})
+        self.assertListEqual(nightscout.deleted_entries, [])
+        self.assertEqual(count, 2)


    """
@@ -113,6 +165,7 @@ class TestProcessTimeRange(unittest.TestCase):
    def test_with_updated_duration_ciq_basal_data(self):
        tconnect = TConnectApi()

+        # datetimes are unused by the API fake
        start = datetime.datetime(2021, 4, 20, 12, 0)
        end = datetime.datetime(2021, 4, 21, 12, 0)

@@ -123,11 +176,12 @@ class TestProcessTimeRange(unittest.TestCase):
            return TestBasalSync.get_example_ciq_basal_events()

        tconnect.controliq.therapy_timeline = fake_therapy_timeline
+        tconnect.controliq.therapy_events = self.stub_ciq_therapy_events
        tconnect.ws2.therapy_timeline_csv = self.stub_therapy_timeline_csv

        nightscout = NightscoutApi()

-        def fake_last_uploaded_entry(event_type):
+        def fake_last_uploaded_entry(event_type, **kwargs):
            if event_type == "Temp Basal":
                return {
                    "created_at": "2021-03-16 00:20:21-04:00",
@@ -138,13 +192,13 @@ class TestProcessTimeRange(unittest.TestCase):
        nightscout.last_uploaded_entry = fake_last_uploaded_entry
        nightscout.last_uploaded_activity = self.stub_last_uploaded_activity

-        process_time_range(tconnect, nightscout, start, end, pretend=False)
+        count = process_time_range(tconnect, nightscout, start, end, pretend=False, features=[BOLUS, BASAL])

        self.assertEqual(len(nightscout.uploaded_entries["treatments"]), 2)
        self.assertDictEqual(nightscout.uploaded_entries, {
            "treatments": [
                NightscoutEntry.basal(0.797, 5.0, "2021-03-16 00:25:21-04:00", reason="algorithmDelivery"),
-                NightscoutEntry.basal(0, 2693/60, "2021-03-16 00:30:21-04:00", reason="algorithmDelivery")
+                NightscoutEntry.basal(0, 2693/60, "2021-03-16 00:30:21-04:00", reason="algorithmDelivery (control-iq suspension)")
        ]})
        self.assertEqual(len(nightscout.put_entries["treatments"]), 1)
        self.assertDictEqual(dict(nightscout.put_entries), {
@@ -155,21 +209,25 @@ class TestProcessTimeRange(unittest.TestCase):
                }
            ]
        })
-        self.assertDictEqual(nightscout.deleted_entries, {})
+        self.assertListEqual(nightscout.deleted_entries, [])
+        self.assertEqual(count, 3)

-    """No data in Nightscout. Uploads all bolus data from tconnect."""
-    def test_new_ciq_bolus_data(self):
+    """No data in Nightscout. Uploads all bolus data from tconnect via the WS2 API."""
+    def test_new_ciq_bolus_data_from_ws2(self):
        tconnect = TConnectApi()

+        # datetimes are unused by the API fake
        start = datetime.datetime(2021, 4, 20, 12, 0)
        end = datetime.datetime(2021, 4, 21, 12, 0)

        tconnect.controliq.therapy_timeline = self.stub_therapy_timeline
+        tconnect.controliq.therapy_events = self.stub_ciq_therapy_events

+        bolusData = TestBolusSync.get_example_csv_bolus_events()
        def fake_therapy_timeline_csv(time_start, time_end):
            return {
                **self.stub_therapy_timeline_csv(time_start, time_end),
-                "bolusData": TestBolusSync.get_example_csv_bolus_events(),
+                "bolusData": bolusData,
            }

        tconnect.ws2.therapy_timeline_csv = fake_therapy_timeline_csv
@@ -179,19 +237,741 @@ class TestProcessTimeRange(unittest.TestCase):
        nightscout.last_uploaded_entry = self.stub_last_uploaded_entry
        nightscout.last_uploaded_activity = self.stub_last_uploaded_activity

-        process_time_range(tconnect, nightscout, start, end, pretend=False)
+        count = process_time_range(tconnect, nightscout, start, end, pretend=False, features=[BOLUS, BASAL])

        pprint.pprint(nightscout.uploaded_entries)
-        self.assertEqual(len(nightscout.uploaded_entries["treatments"]), 3)
+        self.assertEqual(len(nightscout.uploaded_entries["treatments"]), len(bolusData))
        self.assertDictEqual(dict(nightscout.uploaded_entries), {
            "treatments": [
                NightscoutEntry.bolus(13.53, 75, "2021-04-01 12:58:26-04:00", notes="Standard/Correction"),
                NightscoutEntry.bolus(1.25, 0, "2021-04-01 23:23:17-04:00", notes="Standard (Override)"),
                NightscoutEntry.bolus(1.7, 0, "2021-04-02 01:00:47-04:00", notes="Automatic Bolus/Correction"),
+                NightscoutEntry.bolus(1.82, 0, "2021-09-06 12:24:47-04:00", notes="Standard/Correction (Terminated by Alarm: requested 2.63 units)"),
        ]})
        self.assertDictEqual(nightscout.put_entries, {})
-        self.assertDictEqual(nightscout.deleted_entries, {})
+        self.assertListEqual(nightscout.deleted_entries, [])
+        self.assertEqual(count, 4)

+    """No data in Nightscout. Uploads all bolus data from tconnect via CIQ therapy_events."""
+    def test_new_ciq_bolus_data_from_ciq_therapy_events(self):
+        tconnect = TConnectApi()
+
+        # datetimes are unused by the API fake
+        start = datetime.datetime(2022, 8, 9, 12, 0)
+        end = datetime.datetime(2021, 8, 10, 12, 0)
+
+        tconnect.controliq.therapy_timeline = self.stub_therapy_timeline
+
+        def fake_ciq_therapy_events(time_start, time_end):
+            return {
+                "event": BOLUS_FULL_EXAMPLES
+            }
+        tconnect.controliq.therapy_events = fake_ciq_therapy_events
+
+        tconnect.ws2.therapy_timeline_csv = self.stub_therapy_timeline_csv
+
+        nightscout = NightscoutApi()
+
+        nightscout.last_uploaded_entry = self.stub_last_uploaded_entry
+        nightscout.last_uploaded_activity = self.stub_last_uploaded_activity
+
+        count = process_time_range(tconnect, nightscout, start, end, pretend=False, features=[BOLUS, BASAL])
+
+        pprint.pprint(nightscout.uploaded_entries)
+        self.assertEqual(len(nightscout.uploaded_entries["treatments"]), len(BOLUS_FULL_EXAMPLES))
+        self.assertDictEqual(dict(nightscout.uploaded_entries), {
+            "treatments": [
+                # BGs are excluded because BG is not enabled in features for this test
+                NightscoutEntry.bolus(2.9, 0, "2022-07-21 11:55:24-04:00", notes="Automatic Bolus/Correction"),
+                NightscoutEntry.bolus(4.17, 25, "2022-07-21 12:29:21-04:00", notes="Standard"),
+                # NOTE: the extended bolus is 0.2+0.2 but we currently only surface standard
+                # BUG: inconsistency: we use the completion timestamp as the event timestamp for standard boluses,
+                # but the standard strand time for extended
+                NightscoutEntry.bolus(0.2, 0, "2022-08-09 23:20:04-04:00", notes="Extended 50.00%/0.00 (Override) (Extended)"),
+        ]})
+        self.assertDictEqual(nightscout.put_entries, {})
+        self.assertListEqual(nightscout.deleted_entries, [])
+        self.assertEqual(count, 3)
+
+    """No data in Nightscout. Nothing should be updated in Nightscout without the BOLUS feature."""
+    def test_bolus_data_not_updated_without_feature(self):
+        tconnect = TConnectApi()
+
+        # datetimes are unused by the API fake
+        start = datetime.datetime(2021, 4, 20, 12, 0)
+        end = datetime.datetime(2021, 4, 21, 12, 0)
+
+        tconnect.controliq.therapy_timeline = self.stub_therapy_timeline
+
+        bolusData = TestBolusSync.get_example_csv_bolus_events()
+        def fake_therapy_timeline_csv(time_start, time_end):
+            return {
+                **self.stub_therapy_timeline_csv(time_start, time_end),
+                "bolusData": bolusData,
+            }
+
+        tconnect.ws2.therapy_timeline_csv = fake_therapy_timeline_csv
+
+        nightscout = NightscoutApi()
+
+        nightscout.last_uploaded_entry = self.stub_last_uploaded_entry
+        nightscout.last_uploaded_activity = self.stub_last_uploaded_activity
+
+        count = process_time_range(tconnect, nightscout, start, end, pretend=False, features=[BASAL, IOB])
+
+        pprint.pprint(nightscout.uploaded_entries)
+        self.assertEqual(len(nightscout.uploaded_entries["treatments"]), 0)
+        self.assertDictEqual(nightscout.put_entries, {})
+        self.assertListEqual(nightscout.deleted_entries, [])
+        self.assertEqual(count, 0)
+
+    """No data in Nightscout. Uploads new iob reading from tconnect."""
+    def test_new_ciq_iob_data(self):
+        tconnect = TConnectApi()
+
+        # datetimes are unused by the API fake
+        start = datetime.datetime(2021, 4, 20, 12, 0)
+        end = datetime.datetime(2021, 4, 21, 12, 0)
+
+        tconnect.controliq.therapy_timeline = self.stub_therapy_timeline
+        tconnect.controliq.therapy_events = self.stub_ciq_therapy_events
+
+        iobData = TestIOBSync.get_example_csv_iob_events()
+        def fake_therapy_timeline_csv(time_start, time_end):
+            return {
+                **self.stub_therapy_timeline_csv(time_start, time_end),
+                "iobData": iobData,
+            }
+
+        tconnect.ws2.therapy_timeline_csv = fake_therapy_timeline_csv
+
+        nightscout = NightscoutApi()
+
+        nightscout.last_uploaded_entry = self.stub_last_uploaded_entry
+        nightscout.last_uploaded_activity = self.stub_last_uploaded_activity
+
+        count = process_time_range(tconnect, nightscout, start, end, pretend=False, features=[BOLUS, BASAL, IOB])
+
+        pprint.pprint(nightscout.uploaded_entries)
+        self.assertEqual(len(nightscout.uploaded_entries["activity"]), 1)
+        self.assertDictEqual(dict(nightscout.uploaded_entries), {
+            "activity": [
+                # the most recent IOB entry is added
+                NightscoutEntry.iob(6.80, "2021-10-12 00:10:30-04:00")
+        ]})
+        self.assertDictEqual(nightscout.put_entries, {})
+        self.assertListEqual(nightscout.deleted_entries, [])
+        self.assertEqual(count, 1)
+
+    """No data in Nightscout. Nothing should be updated in Nightscout without the IOB feature."""
+    def test_iob_data_not_updated_without_feature(self):
+        tconnect = TConnectApi()
+
+        # datetimes are unused by the API fake
+        start = datetime.datetime(2021, 4, 20, 12, 0)
+        end = datetime.datetime(2021, 4, 21, 12, 0)
+
+        tconnect.controliq.therapy_timeline = self.stub_therapy_timeline
+        tconnect.controliq.therapy_events = self.stub_ciq_therapy_events
+
+        iobData = TestIOBSync.get_example_csv_iob_events()
+        def fake_therapy_timeline_csv(time_start, time_end):
+            return {
+                **self.stub_therapy_timeline_csv(time_start, time_end),
+                "iobData": iobData,
+            }
+
+        tconnect.ws2.therapy_timeline_csv = fake_therapy_timeline_csv
+
+        nightscout = NightscoutApi()
+
+        nightscout.last_uploaded_entry = self.stub_last_uploaded_entry
+        nightscout.last_uploaded_activity = self.stub_last_uploaded_activity
+
+        count = process_time_range(tconnect, nightscout, start, end, pretend=False, features=[BASAL, BOLUS])
+
+        self.assertEqual(len(nightscout.uploaded_entries["activity"]), 0)
+        self.assertDictEqual(nightscout.put_entries, {})
+        self.assertListEqual(nightscout.deleted_entries, [])
+        self.assertEqual(count, 0)
+
+    """Existing IOB in Nightscout. Uploads new iob reading and deletes old IOB."""
+    def test_updates_ciq_iob_data(self):
+        tconnect = TConnectApi()
+
+        # datetimes are unused by the API fake
+        start = datetime.datetime(2021, 4, 20, 12, 0)
+        end = datetime.datetime(2021, 4, 21, 12, 0)
+
+        tconnect.controliq.therapy_timeline = self.stub_therapy_timeline
+
+        iobData = TestIOBSync.get_example_csv_iob_events()
+        iobData[0]["created_at"] = start
+        iobData[0]["_id"] = "sentinel_existing_iob_id"
+
+        def fake_therapy_timeline_csv(time_start, time_end):
+            return {
+                **self.stub_therapy_timeline_csv(time_start, time_end),
+                "iobData": iobData,
+            }
+
+        tconnect.ws2.therapy_timeline_csv = fake_therapy_timeline_csv
+
+        nightscout = NightscoutApi()
+
+        nightscout.last_uploaded_entry = self.stub_last_uploaded_entry
+
+        def fake_last_uploaded_activity(activityType, **kwargs):
+            if activityType == IOB_ACTIVITYTYPE:
+                return iobData[0]
+            return self.stub_last_uploaded_activity(activityType)
+
+        nightscout.last_uploaded_activity = fake_last_uploaded_activity
+
+        count = process_time_range(tconnect, nightscout, start, end, pretend=False, features=[IOB])
+
+        pprint.pprint(nightscout.uploaded_entries)
+        self.assertEqual(len(nightscout.uploaded_entries["activity"]), 1)
+        self.assertDictEqual(dict(nightscout.uploaded_entries), {
+            "activity": [
+                # the most recent IOB entry is added
+                NightscoutEntry.iob(6.80, "2021-10-12 00:10:30-04:00")
+        ]})
+        self.assertDictEqual(nightscout.put_entries, {})
+        self.assertListEqual(nightscout.deleted_entries, [
+            "activity/sentinel_existing_iob_id"
+        ])
+        self.assertEqual(count, 1)
+
+    """No pump activity events in Nightscout. New CIQ activity events."""
+    def test_new_ciq_activity_events(self):
+        tconnect = TConnectApi()
+
+        # datetimes are unused by the API fake
+        start = datetime.datetime(2021, 5, 1, 0, 0)
+        end = datetime.datetime(2021, 5, 3, 0, 0)
+
+        def fake_therapy_timeline(time_start, time_end):
+            self.assertEqual(time_start, start)
+            self.assertEqual(time_end, end)
+
+            return {
+                **TestBasalSync.base,
+                "events": [{
+                    "duration": 1200,
+                    "eventType": 2, # Exercise
+                    "continuation": None,
+                    "timeZoneId": "America/Los_Angeles",
+                    "x": 1619901912 # 2021-05-01 13:45:12-04:00
+                }, {
+                    "duration": 30661,
+                    "eventType": 1, # Sleep
+                    "continuation": None,
+                    "timeZoneId": "America/Los_Angeles",
+                    "x": 1619992000 # 2021-05-02 14:46:40-04:00
+                }]
+            }
+
+        tconnect.controliq.therapy_timeline = fake_therapy_timeline
+        tconnect.ws2.therapy_timeline_csv = self.stub_therapy_timeline_csv
+        tconnect.ws2.basalsuspension = self.stub_ws2_basalsuspension
+
+        nightscout = NightscoutApi()
+
+        nightscout.last_uploaded_entry = self.stub_last_uploaded_entry
+        nightscout.last_uploaded_activity = self.stub_last_uploaded_activity
+
+        count = process_time_range(tconnect, nightscout, start, end, pretend=False, features=[PUMP_EVENTS])
+
+        self.assertEqual(len(nightscout.uploaded_entries["treatments"]), 2)
+        self.assertDictEqual(dict(nightscout.uploaded_entries), {
+            "treatments": [
+                NightscoutEntry.activity(created_at="2021-05-01 13:45:12-04:00", duration=20, reason="Exercise", event_type=EXERCISE_EVENTTYPE),
+                NightscoutEntry.activity(created_at="2021-05-02 14:46:40-04:00", duration=30661/60, reason="Sleep", event_type=SLEEP_EVENTTYPE),
+        ]})
+        self.assertDictEqual(nightscout.put_entries, {})
+        self.assertListEqual(nightscout.deleted_entries, [])
+        self.assertEqual(count, 2)
+
+    """No pump activity events in Nightscout. New CIQ activity events, but feature is disabled."""
+    def test_no_ciq_activity_events_without_feature(self):
+        tconnect = TConnectApi()
+
+        # datetimes are unused by the API fake
+        start = datetime.datetime(2021, 5, 1, 0, 0)
+        end = datetime.datetime(2021, 5, 3, 0, 0)
+
+        def fake_therapy_timeline(time_start, time_end):
+            self.assertEqual(time_start, start)
+            self.assertEqual(time_end, end)
+
+            return {
+                **TestBasalSync.base,
+                "events": [{
+                    "duration": 1200,
+                    "eventType": 2, # Exercise
+                    "continuation": None,
+                    "timeZoneId": "America/Los_Angeles",
+                    "x": 1619901912 # 2021-05-01 13:45:12-04:00
+                }, {
+                    "duration": 30661,
+                    "eventType": 1, # Sleep
+                    "continuation": None,
+                    "timeZoneId": "America/Los_Angeles",
+                    "x": 1619992000 # 2021-05-02 14:46:40-04:00
+                }]
+            }
+
+        tconnect.controliq.therapy_timeline = fake_therapy_timeline
+        tconnect.controliq.therapy_events = self.stub_ciq_therapy_events
+        tconnect.ws2.therapy_timeline_csv = self.stub_therapy_timeline_csv
+        tconnect.ws2.basalsuspension = self.stub_ws2_basalsuspension
+
+        nightscout = NightscoutApi()
+
+        nightscout.last_uploaded_entry = self.stub_last_uploaded_entry
+        nightscout.last_uploaded_activity = self.stub_last_uploaded_activity
+
+        count = process_time_range(tconnect, nightscout, start, end, pretend=False, features=[BOLUS, BASAL, IOB])
+
+        self.assertEqual(len(nightscout.uploaded_entries["treatments"]), 0)
+        self.assertDictEqual(nightscout.put_entries, {})
+        self.assertListEqual(nightscout.deleted_entries, [])
+        self.assertEqual(count, 0)
+
+
+    """
+    Existing Sleep event in Nightscout with shorter duration than current, as well as a past Exercise event.
+    Ensures that the old sleep event is deleted and a new one is created with the correct duration."""
+    def test_existing_ciq_activity_events(self):
+        tconnect = TConnectApi()
+
+        # datetimes are unused by the API fake
+        start = datetime.datetime(2021, 5, 1, 0, 0)
+        end = datetime.datetime(2021, 5, 3, 0, 0)
+
+        def fake_therapy_timeline(time_start, time_end):
+            self.assertEqual(time_start, start)
+            self.assertEqual(time_end, end)
+
+            return {
+                **TestBasalSync.base,
+                "events": [{
+                    "duration": 1200,
+                    "eventType": 2, # Exercise
+                    "continuation": None,
+                    "timeZoneId": "America/Los_Angeles",
+                    "x": 1619901912 # 2021-05-01 13:45:12-04:00
+                }, {
+                    "duration": 4200, # Currently 60 mins (3600), changing to 70 mins (4200)
+                    "eventType": 1, # Sleep
+                    "continuation": None,
+                    "timeZoneId": "America/Los_Angeles",
+                    "x": 1619992000 # 2021-05-02 14:46:40-04:00
+                }]
+            }
+
+        tconnect.controliq.therapy_timeline = fake_therapy_timeline
+        tconnect.ws2.therapy_timeline_csv = self.stub_therapy_timeline_csv
+        tconnect.ws2.basalsuspension = self.stub_ws2_basalsuspension
+
+        nightscout = NightscoutApi()
+
+        def fake_last_uploaded_entry(event_type, **kwargs):
+            if event_type == "Sleep":
+                return {
+                    "created_at": "2021-05-02 14:46:40-04:00",
+                    "duration": 60,
+                    "_id": "old_sleep"
+                }
+            elif event_type == "Exercise":
+                return {
+                    "created_at": "2021-05-01 13:45:12-04:00",
+                    "duration": 20,
+                    "_id": "exercise"
+                }
+            return self.stub_last_uploaded_entry(**kwargs)
+
+        nightscout.last_uploaded_entry = fake_last_uploaded_entry
+        nightscout.last_uploaded_activity = self.stub_last_uploaded_activity
+
+        count = process_time_range(tconnect, nightscout, start, end, pretend=False, features=[PUMP_EVENTS])
+
+        self.assertEqual(len(nightscout.uploaded_entries["treatments"]), 1)
+        self.assertDictEqual(dict(nightscout.uploaded_entries), {
+            "treatments": [
+                # Already exists:
+                # NightscoutEntry.activity(created_at="2021-05-01 13:45:12-04:00", duration=20, reason="Exercise", event_type=EXERCISE_EVENTTYPE),
+                # Updated event duration:
+                NightscoutEntry.activity(created_at="2021-05-02 14:46:40-04:00", duration=70, reason="Sleep", event_type=SLEEP_EVENTTYPE),
+        ]})
+        self.assertDictEqual(nightscout.put_entries, {})
+        self.assertEqual(len(nightscout.deleted_entries), 1)
+        self.assertListEqual(nightscout.deleted_entries, [
+            "treatments/old_sleep"
+        ])
+        self.assertEqual(count, 1)
+
+    """No pump activity events in Nightscout. New WS2 activity events."""
+    def test_new_ws2_activity_events(self):
+        tconnect = TConnectApi()
+
+        # datetimes are unused by the API fake
+        start = datetime.datetime(2021, 5, 1, 0, 0)
+        end = datetime.datetime(2021, 5, 3, 0, 0)
+
+        tconnect.controliq.therapy_timeline = self.stub_therapy_timeline
+        tconnect.ws2.therapy_timeline_csv = self.stub_therapy_timeline_csv
+
+        def fake_basalsuspension(time_start, time_end):
+            self.assertEqual(time_start, start)
+            self.assertEqual(time_end, end)
+
+            return {"BasalSuspension": [
+                {
+                    'EventDateTime': '/Date(1638663490000-0000)/',
+                    'SuspendReason': 'site-cart'
+                },
+                {
+                    'EventDateTime': '/Date(1637863616000-0000)/',
+                    'SuspendReason': 'alarm'
+                },
+                {
+                    'EventDateTime': '/Date(1638662852000-0000)/',
+                    'SuspendReason': 'manual'
+                }
+            ]}
+
+        tconnect.ws2.basalsuspension = fake_basalsuspension
+
+        nightscout = NightscoutApi()
+
+        nightscout.last_uploaded_entry = self.stub_last_uploaded_entry
+        nightscout.last_uploaded_activity = self.stub_last_uploaded_activity
+
+        count = process_time_range(tconnect, nightscout, start, end, pretend=False, features=[PUMP_EVENTS, PUMP_EVENTS_BASAL_SUSPENSION])
+
+        self.assertEqual(len(nightscout.uploaded_entries["treatments"]), 3)
+        self.assertDictEqual(dict(nightscout.uploaded_entries), {
+            "treatments": [
+                NightscoutEntry.sitechange(created_at="2021-12-04 16:18:10-05:00", reason="Site/Cartridge Change"),
+                NightscoutEntry.basalsuspension(created_at="2021-11-25 10:06:56-05:00", reason="Empty Cartridge/Pump Shutdown"),
+                NightscoutEntry.basalsuspension(created_at="2021-12-04 16:07:32-05:00", reason="User Suspended")
+        ]})
+        self.assertDictEqual(nightscout.put_entries, {})
+        self.assertListEqual(nightscout.deleted_entries, [])
+        self.assertEqual(count, 3)
+
+    """Existing pump activity events in Nightscout. New WS2 activity events. Only adds new events."""
+    def test_existing_ws2_activity_events(self):
+        tconnect = TConnectApi()
+
+        # datetimes are unused by the API fake
+        start = datetime.datetime(2021, 5, 1, 0, 0)
+        end = datetime.datetime(2021, 5, 3, 0, 0)
+
+        tconnect.controliq.therapy_timeline = self.stub_therapy_timeline
+        tconnect.ws2.therapy_timeline_csv = self.stub_therapy_timeline_csv
+
+        def fake_basalsuspension(time_start, time_end):
+            self.assertEqual(time_start, start)
+            self.assertEqual(time_end, end)
+
+            return {"BasalSuspension": [
+                {
+                    'EventDateTime': '/Date(1638663490000-0000)/',
+                    'SuspendReason': 'site-cart'
+                },
+                {
+                    'EventDateTime': '/Date(1637863616000-0000)/',
+                    'SuspendReason': 'alarm'
+                },
+                {
+                    'EventDateTime': '/Date(1638662852000-0000)/',
+                    'SuspendReason': 'manual'
+                },
+                # This event is new:
+                {
+                    'EventDateTime': '/Date(1638672852000-0000)/',
+                    'SuspendReason': 'manual'
+                }
+            ]}
+
+        tconnect.ws2.basalsuspension = fake_basalsuspension
+
+        nightscout = NightscoutApi()
+
+        def fake_last_uploaded_entry(event_type, **kwargs):
+            if event_type == "Site Change":
+                return {
+                    "created_at": "2021-12-04 16:18:10-05:00"
+                }
+            elif event_type == "Basal Suspension":
+                return {
+                    "created_at": "2021-12-04 16:07:32-05:00"
+                }
+            return self.stub_last_uploaded_entry(**kwargs)
+
+        nightscout.last_uploaded_entry = fake_last_uploaded_entry
+        nightscout.last_uploaded_activity = self.stub_last_uploaded_activity
+
+        count = process_time_range(tconnect, nightscout, start, end, pretend=False, features=[PUMP_EVENTS, PUMP_EVENTS_BASAL_SUSPENSION])
+
+        self.assertEqual(len(nightscout.uploaded_entries["treatments"]), 1)
+        self.assertDictEqual(dict(nightscout.uploaded_entries), {
+            "treatments": [
+                NightscoutEntry.basalsuspension(created_at="2021-12-04 18:54:12-05:00", reason="User Suspended")
+        ]})
+        self.assertDictEqual(nightscout.put_entries, {})
+        self.assertListEqual(nightscout.deleted_entries, [])
+        self.assertEqual(count, 1)
+
+    """No pump activity events in nightscout. New WS2 activity events, but only of skipped types. None should be added."""
+    def test_skipped_ws2_activity_events(self):
+        tconnect = TConnectApi()
+
+        # datetimes are unused by the API fake
+        start = datetime.datetime(2021, 5, 1, 0, 0)
+        end = datetime.datetime(2021, 5, 3, 0, 0)
+
+        tconnect.controliq.therapy_timeline = self.stub_therapy_timeline
+        tconnect.ws2.therapy_timeline_csv = self.stub_therapy_timeline_csv
+
+        def fake_basalsuspension(time_start, time_end):
+            self.assertEqual(time_start, start)
+            self.assertEqual(time_end, end)
+
+            return {"BasalSuspension": [
+                {
+                    'EventDateTime': '/Date(1638659343000-0000)/',
+                    'SuspendReason': 'basal-profile',
+                },
+                {
+                    'Continuation': 'continuation',
+                    'EventDateTime': '/Date(1638604800000-0000)/',
+                    'SuspendReason': 'previous',
+                },
+                {
+                    'EventDateTime': '/Date(1638659343000-0000)/',
+                    'SuspendReason': 'basal-profile',
+                }
+            ]}
+
+        tconnect.ws2.basalsuspension = fake_basalsuspension
+
+        nightscout = NightscoutApi()
+
+        nightscout.last_uploaded_entry = self.stub_last_uploaded_entry
+        nightscout.last_uploaded_activity = self.stub_last_uploaded_activity
+
+        count = process_time_range(tconnect, nightscout, start, end, pretend=False, features=[PUMP_EVENTS])
+
+        self.assertEqual(len(nightscout.uploaded_entries["treatments"]), 0)
+        self.assertDictEqual(nightscout.put_entries, {})
+        self.assertListEqual(nightscout.deleted_entries, [])
+        self.assertEqual(count, 0)
+
+    """Profile present on pump and not in Nightscout with PROFILES feature enabled, adds profile."""
+    def test_pump_profile_added(self):
+        tconnect = TConnectApi()
+
+        # datetimes are unused by the API fake
+        start = datetime.datetime(2021, 5, 1, 0, 0)
+        end = datetime.datetime(2021, 5, 3, 0, 0)
+
+        pump_guid = '00000000-0000-0000-0000-000000000001'
+        serial_number = '12345'
+
+        def fake_my_devices():
+            return {
+                serial_number: Device(
+                    name='test',
+                    model_number=serial_number,
+                    status='OK',
+                    guid=pump_guid)
+            }
+        tconnect.webui.my_devices = fake_my_devices
+
+        def fake_device_settings_from_guid(guid):
+            if guid != pump_guid:
+                raise RuntimeError('invalid guid')
+            return [DEVICE_PROFILE_A.activeProfile()], DEVICE_SETTINGS
+
+        tconnect.webui.device_settings_from_guid = fake_device_settings_from_guid
+
+        nightscout = NightscoutApi()
+
+        def fake_current_profile(time_start=None, time_end=None):
+            return build_ns_profile({}, '')
+
+        nightscout.current_profile = fake_current_profile
+
+        count = None
+        with patch("tconnectsync.sync.profile._get_default_upload_mode") as mock_upload_mode, \
+             patch("tconnectsync.sync.profile._get_default_serial_number") as mock_serial_number:
+            mock_upload_mode.return_value = 'add'
+            mock_serial_number.return_value = serial_number
+
+            count = process_time_range(tconnect, nightscout, start, end, pretend=False, features=[PROFILES])
+
+        self.assertEqual(len(nightscout.uploaded_entries["profile"]), 1)
+        self.assertDictEqual(nightscout.uploaded_entries["profile"][0]['store']['A'], NS_PROFILE_A)
+        self.assertDictEqual(nightscout.put_entries, {})
+        self.assertListEqual(nightscout.deleted_entries, [])
+        self.assertEqual(count, 1)
+
+    """Profile present on pump and in Nightscout with PROFILES feature enabled, does not add profile."""
+    def test_pump_profile_not_updated(self):
+        tconnect = TConnectApi()
+
+        # datetimes are unused by the API fake
+        start = datetime.datetime(2021, 5, 1, 0, 0)
+        end = datetime.datetime(2021, 5, 3, 0, 0)
+
+        pump_guid = '00000000-0000-0000-0000-000000000001'
+        serial_number = '12345'
+
+        def fake_my_devices():
+            return {
+                serial_number: Device(
+                    name='test',
+                    model_number=serial_number,
+                    status='OK',
+                    guid=pump_guid)
+            }
+        tconnect.webui.my_devices = fake_my_devices
+
+        def fake_device_settings_from_guid(guid):
+            if guid != pump_guid:
+                raise RuntimeError('invalid guid')
+            return [DEVICE_PROFILE_A.activeProfile()], DEVICE_SETTINGS
+
+        tconnect.webui.device_settings_from_guid = fake_device_settings_from_guid
+
+        nightscout = NightscoutApi()
+
+        def fake_current_profile(time_start=None, time_end=None):
+            return build_ns_profile({'A': NS_PROFILE_A}, 'A')
+
+        nightscout.current_profile = fake_current_profile
+
+        count = None
+        with patch("tconnectsync.sync.profile._get_default_upload_mode") as mock_upload_mode, \
+             patch("tconnectsync.sync.profile._get_default_serial_number") as mock_serial_number:
+            mock_upload_mode.return_value = 'add'
+            mock_serial_number.return_value = serial_number
+
+            count = process_time_range(tconnect, nightscout, start, end, pretend=False, features=[PROFILES])
+
+        self.assertEqual(len(nightscout.uploaded_entries["profile"]), 0)
+        self.assertDictEqual(nightscout.put_entries, {})
+        self.assertListEqual(nightscout.deleted_entries, [])
+        self.assertEqual(count, 0)
+
+    """Profile present on pump and in Nightscout with PROFILES feature enabled, with changes on pump, adds new profile object."""
+    def test_pump_profile_new_entry_added(self):
+        tconnect = TConnectApi()
+
+        # datetimes are unused by the API fake
+        start = datetime.datetime(2021, 5, 1, 0, 0)
+        end = datetime.datetime(2021, 5, 3, 0, 0)
+
+        pump_guid = '00000000-0000-0000-0000-000000000001'
+        serial_number = '12345'
+
+        def fake_my_devices():
+            return {
+                serial_number: Device(
+                    name='test',
+                    model_number=serial_number,
+                    status='OK',
+                    guid=pump_guid)
+            }
+        tconnect.webui.my_devices = fake_my_devices
+
+        def fake_device_settings_from_guid(guid):
+            if guid != pump_guid:
+                raise RuntimeError('invalid guid')
+            return [DEVICE_PROFILE_A, DEVICE_PROFILE_B.activeProfile()], DEVICE_SETTINGS
+
+        tconnect.webui.device_settings_from_guid = fake_device_settings_from_guid
+
+        nightscout = NightscoutApi()
+
+        def fake_current_profile(time_start=None, time_end=None):
+            return build_ns_profile({'A': NS_PROFILE_A}, 'A')
+
+        nightscout.current_profile = fake_current_profile
+
+        count = None
+        with patch("tconnectsync.sync.profile._get_default_upload_mode") as mock_upload_mode, \
+             patch("tconnectsync.sync.profile._get_default_serial_number") as mock_serial_number:
+            mock_upload_mode.return_value = 'add'
+            mock_serial_number.return_value = serial_number
+
+            count = process_time_range(tconnect, nightscout, start, end, pretend=False, features=[PROFILES])
+
+        self.assertEqual(len(nightscout.uploaded_entries["profile"]), 1)
+        self.assertEqual(len(nightscout.uploaded_entries["profile"][0]['store']), 2)
+        self.assertDictEqual(nightscout.uploaded_entries["profile"][0]['store']['A'], NS_PROFILE_A)
+        self.assertDictEqual(nightscout.uploaded_entries["profile"][0]['store']['B'], NS_PROFILE_B)
+        self.assertDictEqual(nightscout.put_entries, {})
+        self.assertListEqual(nightscout.deleted_entries, [])
+        self.assertEqual(count, 1)
+
+    """
+    Profile present on pump and in Nightscout with PROFILES feature enabled, with changes on pump,
+    replaces existing profile object with NIGHTSCOUT_PROFILE_UPLOAD_MODE=replace.
+    """
+    def test_pump_profile_new_entry_replaced(self):
+        tconnect = TConnectApi()
+
+        # datetimes are unused by the API fake
+        start = datetime.datetime(2021, 5, 1, 0, 0)
+        end = datetime.datetime(2021, 5, 3, 0, 0)
+
+        pump_guid = '00000000-0000-0000-0000-000000000001'
+        serial_number = '12345'
+
+        def fake_my_devices():
+            return {
+                serial_number: Device(
+                    name='test',
+                    model_number=serial_number,
+                    status='OK',
+                    guid=pump_guid)
+            }
+        tconnect.webui.my_devices = fake_my_devices
+
+        def fake_device_settings_from_guid(guid):
+            if guid != pump_guid:
+                raise RuntimeError('invalid guid')
+            return [DEVICE_PROFILE_A, DEVICE_PROFILE_B.activeProfile()], DEVICE_SETTINGS
+
+        tconnect.webui.device_settings_from_guid = fake_device_settings_from_guid
+
+        nightscout = NightscoutApi()
+
+        def fake_current_profile(time_start=None, time_end=None):
+            return build_ns_profile({'A': NS_PROFILE_A}, 'A')
+
+        nightscout.current_profile = fake_current_profile
+
+        count = None
+        with patch("tconnectsync.sync.profile._get_default_upload_mode") as mock_upload_mode, \
+             patch("tconnectsync.sync.profile._get_default_serial_number") as mock_serial_number:
+            mock_upload_mode.return_value = 'replace'
+            mock_serial_number.return_value = serial_number
+
+            count = process_time_range(tconnect, nightscout, start, end, pretend=False, features=[PROFILES])
+
+        self.assertDictEqual(nightscout.uploaded_entries, {})
+        self.assertEqual(len(nightscout.put_entries["profile"]), 1)
+        self.assertEqual(len(nightscout.put_entries["profile"][0]['store']), 2)
+        self.assertDictEqual(nightscout.put_entries["profile"][0]['store']['A'], NS_PROFILE_A)
+        self.assertDictEqual(nightscout.put_entries["profile"][0]['store']['B'], NS_PROFILE_B)
+        self.assertListEqual(nightscout.deleted_entries, [])
+        self.assertEqual(count, 1)


 if __name__ == '__main__':
@@ -0,0 +1,106 @@
+#!/usr/bin/env python3
+
+import unittest
+import unittest.mock
+import tempfile
+import importlib
+import contextlib
+import pathlib
+import os
+
+@contextlib.contextmanager
+def chdir(dir):
+    orig_cwd = os.getcwd()
+    os.chdir(dir)
+
+    try:
+        yield
+    finally:
+        os.chdir(orig_cwd)
+
+class TestSecretDotEnv(unittest.TestCase):
+    maxDiff = None
+
+    def setUp(self):
+        if 'TCONNECT_EMAIL' in os.environ:
+            del os.environ['TCONNECT_EMAIL']
+
+        if 'NS_URL' in os.environ:
+            del os.environ['NS_URL']
+
+    def write_test_dotenv_file(self, path, type):
+        with open(os.path.join(path, ".env"), "w") as f:
+            f.write("""
+TCONNECT_EMAIL=test_%s_email@email.com
+NS_URL=http://test_%s_url
+            """ % (type, type))
+            f.close()
+    
+    def import_secret(self):
+        return importlib.reload(importlib.import_module("tconnectsync.secret"))
+
+    def test_dotenv_in_current_working_directory(self):
+        with tempfile.TemporaryDirectory(prefix='dotenv_cwd') as dir, chdir(dir):
+            self.write_test_dotenv_file(dir, "dotenv_cwd")
+
+            secret = self.import_secret()
+            self.assertEqual(secret.TCONNECT_EMAIL, "test_dotenv_cwd_email@email.com")
+            self.assertEqual(secret.NS_URL, "http://test_dotenv_cwd_url")
+
+    def test_dotenv_in_homedir_config_folder(self):
+        with tempfile.TemporaryDirectory(prefix='dotenv_homedir_config') as dir, chdir(dir):
+            config_dir = os.path.join(dir, '.config/tconnectsync')
+            os.makedirs(config_dir)
+
+            self.write_test_dotenv_file(config_dir, "dotenv_homedir_config")
+
+            with unittest.mock.patch.object(pathlib.Path, "home") as mock_home:
+                mock_home.return_value = dir
+
+                secret = self.import_secret()
+                self.assertEqual(secret.TCONNECT_EMAIL, "test_dotenv_homedir_config_email@email.com")
+                self.assertEqual(secret.NS_URL, "http://test_dotenv_homedir_config_url")
+
+    def test_no_dotenv_file_reads_from_environment(self):
+        with tempfile.TemporaryDirectory(prefix='dotenv_environ') as dir, chdir(dir):
+            environ = {
+                "TCONNECT_EMAIL": "test_environ_email@email.com", 
+                "NS_URL": "http://test_environ_url"
+            }
+
+            with unittest.mock.patch.dict(os.environ, environ):
+                secret = self.import_secret()
+                self.assertEqual(secret.TCONNECT_EMAIL, environ["TCONNECT_EMAIL"])
+                self.assertEqual(secret.NS_URL, environ["NS_URL"])
+
+    def test_environment_merges_with_dotenv_file(self):
+        with tempfile.TemporaryDirectory(prefix='env_plus_environ') as dir, chdir(dir):
+            self.write_test_dotenv_file(dir, "dotenv_cwd_defaults")
+
+            environ = {
+                "TCONNECT_EMAIL": "test_environ_override_email@email.com"
+            }
+
+            with unittest.mock.patch.dict(os.environ, environ):
+                secret = self.import_secret()
+                self.assertEqual(secret.TCONNECT_EMAIL, "test_environ_override_email@email.com")
+                self.assertEqual(secret.NS_URL, "http://test_dotenv_cwd_defaults_url")
+
+    def test_dotenv_in_current_working_directory_overrides_homedir_config(self):
+        with tempfile.TemporaryDirectory(prefix='dotenv_cwd') as dir, chdir(dir):
+            self.write_test_dotenv_file(dir, "dotenv_cwd")
+
+            config_dir = os.path.join(dir, '.config/tconnectsync')
+            os.makedirs(config_dir)
+
+            self.write_test_dotenv_file(config_dir, "dotenv_homedir_config")
+
+            with unittest.mock.patch.object(pathlib.Path, "home") as mock_home:
+                mock_home.return_value = dir
+
+                secret = self.import_secret()
+                self.assertEqual(secret.TCONNECT_EMAIL, "test_dotenv_cwd_email@email.com")
+                self.assertEqual(secret.NS_URL, "http://test_dotenv_cwd_url")
+
+if __name__ == '__main__':
+    unittest.main()